v1.15.0

pkg/cloudapi/compute/abort_shared_snapshot_merge.go

@@ -18,6 +18,11 @@ type AbortSharedSnapshotMergeRequest struct {
 	Label string `url:"label" json:"label" validate:"required"`
 }
 
+type wrapperAbortSharedSnapshotMergeRequest struct {
+	AbortSharedSnapshotMergeRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // AbortSharedSnapshotMerge shared snapshots merge abort
 func (c Compute) AbortSharedSnapshotMerge(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
 	err := validators.ValidateRequest(req)
@@ -25,9 +30,36 @@ func (c Compute) AbortSharedSnapshotMerge(ctx context.Context, req AbortSharedSn
 		return "", validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
+		AbortSharedSnapshotMergeRequest: req,
+		AsyncMode:                       false,
+	}
+
 	url := "/cloudapi/compute/abort_shared_snapshot_merge"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// AbortSharedSnapshotMergeAsync shared snapshots merge abort in async mode
+func (c Compute) AbortSharedSnapshotMergeAsync(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
+		AbortSharedSnapshotMergeRequest: req,
+		AsyncMode:                       true,
+	}
+
+	url := "/cloudapi/compute/abort_shared_snapshot_merge"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return "", err
 	}

pkg/cloudapi/compute/cd_eject.go

@@ -15,6 +15,12 @@ type CDEjectRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperCDEjectRequest struct {
+	CDEjectRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // CDEject eject CD image to compute's CD-ROM
 func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error)
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperCDEjectRequest{
+		CDEjectRequest: req,
+		AsyncMode:      false,
+	}
+
 	url := "/cloudapi/compute/cdEject"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -33,5 +44,28 @@ func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error)
 	if err != nil {
 		return false, err
 	}
+
 	return result, nil
 }
+
+// CDEjectAsync ejects CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDEjectAsync(ctx context.Context, req CDEjectRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDEjectRequest{
+		CDEjectRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/cd_insert.go

@@ -19,6 +19,12 @@ type CDInsertRequest struct {
 	CDROMID uint64 `url:"cdromId" json:"cdromId" validate:"required"`
 }
 
+type wrapperCDInsertRequest struct {
+	CDInsertRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // CDInsert insert new CD image to compute's CD-ROM
 func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -26,9 +32,14 @@ func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperCDInsertRequest{
+		CDInsertRequest: req,
+		AsyncMode:       false,
+	}
+
 	url := "/cloudapi/compute/cdInsert"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -37,5 +48,28 @@ func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error
 	if err != nil {
 		return false, err
 	}
+
 	return result, nil
 }
+
+// CDInsertAsync inserts new CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDInsertAsync(ctx context.Context, req CDInsertRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDInsertRequest{
+		CDInsertRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudapi/compute/cdInsert"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_ip.go

@@ -31,6 +31,12 @@ type ChangeIPRequest struct {
 	IPAddr string `url:"ip_addr" json:"ip_addr" validate:"required"`
 }
 
+type wrapperChangeIPRequest struct {
+	ChangeIPRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // ChangeIP change reserved IP for compute instance
 func (c Compute) ChangeIP(ctx context.Context, req ChangeIPRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -38,9 +44,14 @@ func (c Compute) ChangeIP(ctx context.Context, req ChangeIPRequest) (bool, error
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperChangeIPRequest{
+		ChangeIPRequest: req,
+		AsyncMode:       false,
+	}
+
 	url := "/cloudapi/compute/changeIp"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -52,3 +63,25 @@ func (c Compute) ChangeIP(ctx context.Context, req ChangeIPRequest) (bool, error
 
 	return result, nil
 }
+
+// ChangeIPAsync change reserved IP for compute instance with AsyncMode
+func (c Compute) ChangeIPAsync(ctx context.Context, req ChangeIPRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeIPRequest{
+		ChangeIPRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudapi/compute/changeIp"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_link_state.go

@@ -3,8 +3,9 @@ package compute
 import (
 	"context"
 	"net/http"
-	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
 	"strconv"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
 )
 
 // ChangeLinkStateRequest struct to change link state
@@ -23,6 +24,12 @@ type ChangeLinkStateRequest struct {
 	State string `url:"state" json:"state" validate:"required,interfaceState"`
 }
 
+type wrapperChangeLinkStateRequest struct {
+	ChangeLinkStateRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // ChangeLinkState changes the status link virtual of compute
 func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +37,14 @@ func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperChangeLinkStateRequest{
+		ChangeLinkStateRequest: req,
+		AsyncMode:              false,
+	}
+
 	url := "/cloudapi/compute/changeLinkState"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -41,5 +53,28 @@ func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest
 	if err != nil {
 		return false, err
 	}
+
 	return result, nil
 }
+
+// ChangeLinkStateAsync changes the status link virtual of compute with AsyncMode
+func (c Compute) ChangeLinkStateAsync(ctx context.Context, req ChangeLinkStateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeLinkStateRequest{
+		ChangeLinkStateRequest: req,
+		AsyncMode:              true,
+	}
+
+	url := "/cloudapi/compute/changeLinkState"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_mtu.go

@@ -23,6 +23,12 @@ type ChangeMTURequest struct {
 	MTU uint64 `url:"mtu" json:"mtu" validate:"required" validate:"omitempty,mtu"`
 }
 
+type wrapperChangeMTURequest struct {
+	ChangeMTURequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // ChangeMTU change MTU for compute instance
 func (c Compute) ChangeMTU(ctx context.Context, req ChangeMTURequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) ChangeMTU(ctx context.Context, req ChangeMTURequest) (bool, err
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperChangeMTURequest{
+		ChangeMTURequest: req,
+		AsyncMode:        false,
+	}
+
 	url := "/cloudapi/compute/change_mtu"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) ChangeMTU(ctx context.Context, req ChangeMTURequest) (bool, err
 
 	return result, nil
 }
+
+// ChangeMTUAsync change MTU for compute instance with AsyncMode
+func (c Compute) ChangeMTUAsync(ctx context.Context, req ChangeMTURequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeMTURequest{
+		ChangeMTURequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudapi/compute/change_mtu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_secutity_group.go

@@ -27,6 +27,12 @@ type ChangeSecGroupsRequest struct {
 	EnableSecGroups interface{} `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty" validate:"omitempty,isBool"`
 }
 
+type wrapperChangeSecGroupsRequest struct {
+	ChangeSecGroupsRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // ChangeSecGroups changes security groups for compute
 func (c Compute) ChangeSecGroups(ctx context.Context, req ChangeSecGroupsRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -34,9 +40,14 @@ func (c Compute) ChangeSecGroups(ctx context.Context, req ChangeSecGroupsRequest
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperChangeSecGroupsRequest{
+		ChangeSecGroupsRequest: req,
+		AsyncMode:              false,
+	}
+
 	url := "/cloudapi/compute/change_security_groups"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -48,3 +59,25 @@ func (c Compute) ChangeSecGroups(ctx context.Context, req ChangeSecGroupsRequest
 
 	return result, nil
 }
+
+// ChangeSecGroupsAsync changes security groups for compute with AsyncMode
+func (c Compute) ChangeSecGroupsAsync(ctx context.Context, req ChangeSecGroupsRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeSecGroupsRequest{
+		ChangeSecGroupsRequest: req,
+		AsyncMode:              true,
+	}
+
+	url := "/cloudapi/compute/change_security_groups"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/clone.go

@@ -44,6 +44,12 @@ type CloneRequest struct {
 	SEPID uint64 `url:"sep_id" json:"sep_id"`
 }
 
+type wrapperCloneRequest struct {
+	CloneRequest
+
+	AsyncMode bool `url:"asyncMode" json:"asyncMode"`
+}
+
 // Clone clones compute instance
 func (c Compute) Clone(ctx context.Context, req CloneRequest) (string, error) {
 	err := validators.ValidateRequest(req)
@@ -51,9 +57,36 @@ func (c Compute) Clone(ctx context.Context, req CloneRequest) (string, error) {
 		return "", validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperCloneRequest{
+		CloneRequest: req,
+		AsyncMode:    false,
+	}
+
 	url := "/cloudapi/compute/clone"
 
-	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// CloneAsync clones compute instance with AsyncMode
+func (c Compute) CloneAsync(ctx context.Context, req CloneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCloneRequest{
+		CloneRequest: req,
+		AsyncMode:    true,
+	}
+
+	url := "/cloudapi/compute/clone"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
 	if err != nil {
 		return "", err
 	}

pkg/cloudapi/compute/delete.go

@@ -23,6 +23,12 @@ type DeleteRequest struct {
 	DetachDisks bool `url:"detachDisks,omitempty" json:"detachDisks,omitempty"`
 }
 
+type wrapperDeleteRequest struct {
+	DeleteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Delete deletes compute
 func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDeleteRequest{
+		DeleteRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/delete"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
 
 	return result, nil
 }
+
+// DeleteAsync deletes compute with AsyncMode
+func (c Compute) DeleteAsync(ctx context.Context, req DeleteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDeleteRequest{
+		DeleteRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/delete_cpu_alignment_profile.go

@@ -0,0 +1,39 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+// DeleteCPUAlignmentProfileRequest struct to delete CPU alignment profile for computes
+type DeleteCPUAlignmentProfileRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"compute_ids" json:"compute_ids" validate:"min=1"`
+}
+
+// DeleteCPUAlignmentProfile deletes CPU alignment profile for computes
+func (c Compute) DeleteCPUAlignmentProfile(ctx context.Context, req DeleteCPUAlignmentProfileRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/delete_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/disable.go

@@ -15,6 +15,12 @@ type DisableRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperDisableRequest struct {
+	DisableRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Disable disables compute
 func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error)
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDisableRequest{
+		DisableRequest: req,
+		AsyncMode:      false,
+	}
+
 	url := "/cloudapi/compute/disable"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error)
 
 	return result, nil
 }
+
+// DisableAsync disables compute with AsyncMode
+func (c Compute) DisableAsync(ctx context.Context, req DisableRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDisableRequest{
+		DisableRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_add.go

@@ -51,6 +51,16 @@ type DiskAddRequest struct {
 	// Desired bus number (hex string, e.g. "0x03")
 	// Required: false
 	BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
+
+	// Mount disk in read-only mode
+	// Required: false
+	ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
+}
+
+type wrapperDiskAddRequest struct {
+	DiskAddRequest
+
+	AsyncMode bool `url:"asyncMode"`
 }
 
 // DiskAdd creates new disk and attach to compute
@@ -60,9 +70,14 @@ func (c Compute) DiskAdd(ctx context.Context, req DiskAddRequest) (uint64, error
 		return 0, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskAddRequest{
+		DiskAddRequest: req,
+		AsyncMode:      false,
+	}
+
 	url := "/cloudapi/compute/diskAdd"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return 0, err
 	}
@@ -74,3 +89,25 @@ func (c Compute) DiskAdd(ctx context.Context, req DiskAddRequest) (uint64, error
 
 	return result, nil
 }
+
+// DiskAddAsync creates new disk and attach to compute with AsyncMode
+func (c Compute) DiskAddAsync(ctx context.Context, req DiskAddRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskAddRequest{
+		DiskAddRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/diskAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_attach.go

@@ -25,6 +25,16 @@ type DiskAttachRequest struct {
 	// Desired bus number (hex string, e.g. "0x03")
 	// Required: false
 	BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
+
+	// Mount disk in read-only mode
+	// Required: false
+	ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
+}
+
+type wrapperDiskAttachRequest struct {
+	DiskAttachRequest
+
+	AsyncMode bool `url:"asyncMode"`
 }
 
 // DiskAttach attach disk to compute
@@ -34,9 +44,14 @@ func (c Compute) DiskAttach(ctx context.Context, req DiskAttachRequest) (bool, e
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskAttachRequest{
+		DiskAttachRequest: req,
+		AsyncMode:         false,
+	}
+
 	url := "/cloudapi/compute/diskAttach"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -48,3 +63,25 @@ func (c Compute) DiskAttach(ctx context.Context, req DiskAttachRequest) (bool, e
 
 	return result, nil
 }
+
+// DiskAttachAsync attaches disk to compute with AsyncMode
+func (c Compute) DiskAttachAsync(ctx context.Context, req DiskAttachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskAttachRequest{
+		DiskAttachRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudapi/compute/diskAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_del.go

@@ -23,6 +23,12 @@ type DiskDelRequest struct {
 	Permanently bool `url:"permanently" json:"permanently"`
 }
 
+type wrapperDiskDelRequest struct {
+	DiskDelRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // DiskDel delete disk and detach from compute
 func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error)
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskDelRequest{
+		DiskDelRequest: req,
+		AsyncMode:      false,
+	}
+
 	url := "/cloudapi/compute/diskDel"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error)
 
 	return result, nil
 }
+
+// DiskDelAsync deletes disk and detaches from compute with AsyncMode
+func (c Compute) DiskDelAsync(ctx context.Context, req DiskDelRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskDelRequest{
+		DiskDelRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/diskDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_detach.go

@@ -19,6 +19,12 @@ type DiskDetachRequest struct {
 	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
 }
 
+type wrapperDiskDetachRequest struct {
+	DiskDetachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // DiskDetach detach disk from compute
 func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -26,9 +32,14 @@ func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, e
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskDetachRequest{
+		DiskDetachRequest: req,
+		AsyncMode:         false,
+	}
+
 	url := "/cloudapi/compute/diskDetach"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -40,3 +51,25 @@ func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, e
 
 	return result, nil
 }
+
+// DiskDetachAsync detaches disk from compute with AsyncMode
+func (c Compute) DiskDetachAsync(ctx context.Context, req DiskDetachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskDetachRequest{
+		DiskDetachRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudapi/compute/diskDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_qos.go

@@ -23,6 +23,12 @@ type DiskQOSRequest struct {
 	Limits string `url:"limits" json:"limits" validate:"required"`
 }
 
+type wrapperDiskQOSRequest struct {
+	DiskQOSRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // DiskQOS change QoS of the disk
 func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error)
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskQOSRequest{
+		DiskQOSRequest: req,
+		AsyncMode:      false,
+	}
+
 	url := "/cloudapi/compute/diskQos"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error)
 
 	return result, nil
 }
+
+// DiskQOSAsync changes QoS of the disk with AsyncMode
+func (c Compute) DiskQOSAsync(ctx context.Context, req DiskQOSRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskQOSRequest{
+		DiskQOSRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/diskQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_resize.go

@@ -23,6 +23,12 @@ type DiskResizeRequest struct {
 	Size uint64 `url:"size" json:"size" validate:"required"`
 }
 
+type wrapperDiskResizeRequest struct {
+	DiskResizeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // DiskResize change disk size
 func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, e
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskResizeRequest{
+		DiskResizeRequest: req,
+		AsyncMode:         false,
+	}
+
 	url := "/cloudapi/compute/diskResize"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, e
 
 	return result, nil
 }
+
+// DiskResizeAsync changes disk size with AsyncMode
+func (c Compute) DiskResizeAsync(ctx context.Context, req DiskResizeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskResizeRequest{
+		DiskResizeRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudapi/compute/diskResize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_switch_to_replication.go

@@ -23,6 +23,12 @@ type DiskSwitchToReplicationRequest struct {
 	StopReplication bool `url:"stopReplication" json:"stopReplication"`
 }
 
+type wrapperDiskSwitchToReplicationRequest struct {
+	DiskSwitchToReplicationRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // DiskSwitchToReplication switches disk to it's replication
 func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToReplicationRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToRe
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperDiskSwitchToReplicationRequest{
+		DiskSwitchToReplicationRequest: req,
+		AsyncMode:                      false,
+	}
+
 	url := "/cloudapi/compute/diskSwitchToReplication"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToRe
 
 	return result, nil
 }
+
+// DiskSwitchToReplicationAsync switches disk to it's replication with AsyncMode
+func (c Compute) DiskSwitchToReplicationAsync(ctx context.Context, req DiskSwitchToReplicationRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskSwitchToReplicationRequest{
+		DiskSwitchToReplicationRequest: req,
+		AsyncMode:                      true,
+	}
+
+	url := "/cloudapi/compute/diskSwitchToReplication"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/get_cpu_alignment_profile.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+// GetCPUAlignmentProfileRequest struct to get CPU alignment profile for compute
+type GetCPUAlignmentProfileRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+// GetCPUAlignmentProfile gets CPU alignment profile for compute
+func (c Compute) GetCPUAlignmentProfile(ctx context.Context, req GetCPUAlignmentProfileRequest) (*CPUAlignmentProfile, error) {
+	res, err := c.GetCPUAlignmentProfileRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := CPUAlignmentProfile{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetCPUAlignmentProfileRaw gets CPU alignment profile for compute as an array of bytes
+func (c Compute) GetCPUAlignmentProfileRaw(ctx context.Context, req GetCPUAlignmentProfileRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/get_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	return res, err
+}

pkg/cloudapi/compute/guest_agent_disable.go

@@ -15,6 +15,12 @@ type GuestAgentDisableRequest struct {
 	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
 }
 
+type wrapperGuestAgentDisableRequest struct {
+	GuestAgentDisableRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Disable guest agent at a specific compute
 func (c Compute) GuestAgentDisable(ctx context.Context, req GuestAgentDisableRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) GuestAgentDisable(ctx context.Context, req GuestAgentDisableReq
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperGuestAgentDisableRequest{
+		GuestAgentDisableRequest: req,
+		AsyncMode:                false,
+	}
+
 	url := "/cloudapi/compute/guest_agent_disable"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) GuestAgentDisable(ctx context.Context, req GuestAgentDisableReq
 
 	return result, nil
 }
+
+// GuestAgentDisableAsync disables guest agent at a specific compute with AsyncMode
+func (c Compute) GuestAgentDisableAsync(ctx context.Context, req GuestAgentDisableRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentDisableRequest{
+		GuestAgentDisableRequest: req,
+		AsyncMode:                true,
+	}
+
+	url := "/cloudapi/compute/guest_agent_disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_enable.go

@@ -15,6 +15,12 @@ type GuestAgentEnableRequest struct {
 	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
 }
 
+type wrapperGuestAgentEnableRequest struct {
+	GuestAgentEnableRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Enable guest agent at a specific compute
 func (c Compute) GuestAgentEnable(ctx context.Context, req GuestAgentEnableRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) GuestAgentEnable(ctx context.Context, req GuestAgentEnableReque
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperGuestAgentEnableRequest{
+		GuestAgentEnableRequest: req,
+		AsyncMode:               false,
+	}
+
 	url := "/cloudapi/compute/guest_agent_enable"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) GuestAgentEnable(ctx context.Context, req GuestAgentEnableReque
 
 	return result, nil
 }
+
+// GuestAgentEnableAsync enables guest agent at a specific compute with AsyncMode
+func (c Compute) GuestAgentEnableAsync(ctx context.Context, req GuestAgentEnableRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentEnableRequest{
+		GuestAgentEnableRequest: req,
+		AsyncMode:               true,
+	}
+
+	url := "/cloudapi/compute/guest_agent_enable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_execute.go

@@ -23,6 +23,12 @@ type GuestAgentExecuteRequest struct {
 	Arguments string `url:"arguments" json:"arguments" validate:"required"`
 }
 
+type wrapperGuestAgentExecuteRequest struct {
+	GuestAgentExecuteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Execute guest agent command
 func (c Compute) GuestAgentExecuteRequest(ctx context.Context, req GuestAgentExecuteRequest) (map[string]interface{}, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) GuestAgentExecuteRequest(ctx context.Context, req GuestAgentExe
 		return nil, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperGuestAgentExecuteRequest{
+		GuestAgentExecuteRequest: req,
+		AsyncMode:                false,
+	}
+
 	url := "/cloudapi/compute/guest_agent_execute"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return nil, err
 	}
@@ -46,3 +57,25 @@ func (c Compute) GuestAgentExecuteRequest(ctx context.Context, req GuestAgentExe
 
 	return result, nil
 }
+
+// GuestAgentExecuteRequestAsync executes guest agent command with AsyncMode
+func (c Compute) GuestAgentExecuteRequestAsync(ctx context.Context, req GuestAgentExecuteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentExecuteRequest{
+		GuestAgentExecuteRequest: req,
+		AsyncMode:                true,
+	}
+
+	url := "/cloudapi/compute/guest_agent_execute"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_feature_update.go

@@ -15,6 +15,12 @@ type GuestAgentFeatureUpdateRequest struct {
 	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
 }
 
+type wrapperGuestAgentFeatureUpdateRequest struct {
+	GuestAgentFeatureUpdateRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Feature update guest agent
 func (c Compute) GuestAgentFeatureUpdate(ctx context.Context, req GuestAgentFeatureUpdateRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) GuestAgentFeatureUpdate(ctx context.Context, req GuestAgentFeat
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
+		GuestAgentFeatureUpdateRequest: req,
+		AsyncMode:                      false,
+	}
+
 	url := "/cloudapi/compute/guest_agent_feature_update"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) GuestAgentFeatureUpdate(ctx context.Context, req GuestAgentFeat
 
 	return result, nil
 }
+
+// GuestAgentFeatureUpdateAsync feature updates guest agent with AsyncMode
+func (c Compute) GuestAgentFeatureUpdateAsync(ctx context.Context, req GuestAgentFeatureUpdateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
+		GuestAgentFeatureUpdateRequest: req,
+		AsyncMode:                      true,
+	}
+
+	url := "/cloudapi/compute/guest_agent_feature_update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/migrate_to_zone.go

@@ -19,6 +19,12 @@ type MigrateToZoneRequest struct {
 	ZoneID uint64 `url:"zoneId" json:"zoneId " validate:"required"`
 }
 
+type wrapperMigrateToZoneRequest struct {
+	MigrateToZoneRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // MoveToRG moves compute instance to new resource group
 func (c Compute) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -26,9 +32,14 @@ func (c Compute) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (b
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperMigrateToZoneRequest{
+		MigrateToZoneRequest: req,
+		AsyncMode:            false,
+	}
+
 	url := "/cloudapi/compute/migrateToZone"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -40,3 +51,25 @@ func (c Compute) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (b
 
 	return result, nil
 }
+
+// MigrateToZoneAsync moves compute to another zone with AsyncMode
+func (c Compute) MigrateToZoneAsync(ctx context.Context, req MigrateToZoneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateToZoneRequest{
+		MigrateToZoneRequest: req,
+		AsyncMode:            true,
+	}
+
+	url := "/cloudapi/compute/migrateToZone"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/models.go

@@ -83,6 +83,9 @@ type ListUsageSnapshots []ItemUsageSnapshot
 
 // Main information about snapshot
 type ItemSnapshot struct {
+	// Compute info
+	Compute RecordCompute `json:"compute"`
+
 	// List disk ID
 	Disks []uint64 `json:"disks"`
 
@@ -92,6 +95,9 @@ type ItemSnapshot struct {
 	// Label
 	Label string `json:"label"`
 
+	// Memory dump image ID
+	MemoryDumpImage uint64 `json:"memory_dump_image"`
+
 	// Timestamp
 	Timestamp uint64 `json:"timestamp"`
 }
@@ -356,6 +362,9 @@ type RecordCompute struct {
 	// List clone IDs
 	Clones []uint64 `json:"clones"`
 
+	// Clock
+	Clock string `json:"clock"`
+
 	// Compute CI ID
 	ComputeCIID uint64 `json:"computeciId"`
 
@@ -482,6 +491,9 @@ type RecordCompute struct {
 	// PreferredCPU
 	PreferredCPU []int64 `json:"preferredCpu"`
 
+	// CPU alignment profile
+	CPUAlignmentProfile CPUAlignmentProfile `json:"cpu_alignment_profile"`
+
 	// Qemu_quest
 	QemuQuest QemuQuest `json:"qemu_guest"`
 
@@ -552,6 +564,7 @@ type RecordCompute struct {
 	// Required: false
 	ZoneID uint64 `json:"zoneId"`
 }
+
 type LoaderMetaIso struct {
 	// Name
 	DeviceName string `json:"devicename"`
@@ -568,6 +581,12 @@ type QemuQuest struct {
 	User                 string   `json:"user"`
 }
 
+type CPUAlignmentProfile struct {
+	Model  string `json:"model"`
+	Name   string `json:"name"`
+	Vendor string `json:"vendor"`
+}
+
 type VGPUItem struct {
 	// ID
 	ID uint64 `json:"id"`
@@ -792,8 +811,8 @@ type ItemComputeDisk struct {
 	// Account ID
 	AccountID uint64 `json:"accountId"`
 
-	// BLK Discard
-	BLKDiscard bool `json:"blkdiscard"`
+	// Discard
+	Discard string `json:"discard"`
 
 	// Block Size
 	BlockSize string `json:"block_size"`
@@ -938,6 +957,9 @@ type ItemComputeDisk struct {
 
 	// UpdatedTime
 	UpdatedTime uint64 `json:"updatedTime"`
+
+	// Read-only
+	ReadOnly bool `json:"read_only"`
 }
 
 type ItemReplication struct {
@@ -1079,6 +1101,9 @@ type ItemCompute struct {
 	// Clone reference
 	CloneReference uint64 `json:"cloneReference"`
 
+	// Clock
+	Clock string `json:"clock"`
+
 	// List clone IDs
 	Clones []uint64 `json:"clones"`
 
@@ -1184,6 +1209,9 @@ type ItemCompute struct {
 	// Name of OS
 	OSVersion string `json:"os_version"`
 
+	// CPU alignment profile
+	CPUAlignmentProfile CPUAlignmentProfile `json:"cpu_alignment_profile"`
+
 	// Qemu_quest
 	QemuQuest QemuQuest `json:"qemu_guest"`
 
@@ -1261,6 +1289,9 @@ type InfoDisk struct {
 
 	// SEP ID
 	SepID int64 `json:"sepId"`
+
+	// Read-only
+	ReadOnly bool `json:"read_only"`
 }
 
 // List information about computes

pkg/cloudapi/compute/move_to_rg.go

@@ -34,6 +34,12 @@ type MoveToRGRequest struct {
 	ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
 }
 
+type wrapperMoveToRGRequest struct {
+	MoveToRGRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // MoveToRG moves compute instance to new resource group
 func (c Compute) MoveToRG(ctx context.Context, req MoveToRGRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -41,9 +47,14 @@ func (c Compute) MoveToRG(ctx context.Context, req MoveToRGRequest) (bool, error
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperMoveToRGRequest{
+		MoveToRGRequest: req,
+		AsyncMode:       false,
+	}
+
 	url := "/cloudapi/compute/moveToRg"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -55,3 +66,25 @@ func (c Compute) MoveToRG(ctx context.Context, req MoveToRGRequest) (bool, error
 
 	return result, nil
 }
+
+// MoveToRGAsync moves compute instance to new resource group with AsyncMode
+func (c Compute) MoveToRGAsync(ctx context.Context, req MoveToRGRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMoveToRGRequest{
+		MoveToRGRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudapi/compute/moveToRg"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/net_attach.go

@@ -53,9 +53,9 @@ type NetAttachRequest struct {
 	// Required: false
 	SDNSegmentID string `url:"sdn_segment_id,omitempty" json:"sdn_segment_id,omitempty"`
 
-	// SDN Object Group ID
+	// SDN Object Group IDs
 	// Required: false
-	SDNObjectGroupID string `url:"sdn_object_group_id,omitempty" json:"sdn_object_group_id,omitempty"`
+	SDNObjectGroupIDs []string `url:"sdn_object_group_ids,omitempty" json:"sdn_object_group_ids,omitempty"`
 
 	// SDN Logical Port Display Name
 	// Required: false
@@ -83,6 +83,12 @@ type NetAttachRequest struct {
 	Enabled interface{} `url:"enabled,omitempty" json:"enabled,omitempty" validate:"omitempty,isBool"`
 }
 
+type wrapperNetAttachRequest struct {
+	NetAttachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // NetAttach attaches network to compute and gets info about network
 func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNetAttach, error) {
 	err := validators.ValidateRequest(req)
@@ -90,9 +96,14 @@ func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNe
 		return nil, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperNetAttachRequest{
+		NetAttachRequest: req,
+		AsyncMode:        false,
+	}
+
 	url := "/cloudapi/compute/netAttach"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return nil, err
 	}
@@ -106,3 +117,25 @@ func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNe
 
 	return &info, nil
 }
+
+// NetAttachAsync attaches network to compute with AsyncMode
+func (c Compute) NetAttachAsync(ctx context.Context, req NetAttachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetAttachRequest{
+		NetAttachRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudapi/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/net_detach.go

@@ -23,6 +23,12 @@ type NetDetachRequest struct {
 	MAC string `url:"mac,omitempty" json:"mac,omitempty"`
 }
 
+type wrapperNetDetachRequest struct {
+	NetDetachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // NetDetach detaches network from compute
 func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -30,9 +36,14 @@ func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, err
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperNetDetachRequest{
+		NetDetachRequest: req,
+		AsyncMode:        false,
+	}
+
 	url := "/cloudapi/compute/netDetach"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -44,3 +55,25 @@ func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, err
 
 	return result, nil
 }
+
+// NetDetachAsync detaches network from compute with AsyncMode
+func (c Compute) NetDetachAsync(ctx context.Context, req NetDetachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetDetachRequest{
+		NetDetachRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudapi/compute/netDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pause.go

@@ -15,6 +15,12 @@ type PauseRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperPauseRequest struct {
+	PauseRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Pause pause compute
 func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperPauseRequest{
+		PauseRequest: req,
+		AsyncMode:    false,
+	}
+
 	url := "/cloudapi/compute/pause"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
 
 	return result, nil
 }
+
+// PauseAsync pauses compute with AsyncMode
+func (c Compute) PauseAsync(ctx context.Context, req PauseRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPauseRequest{
+		PauseRequest: req,
+		AsyncMode:    true,
+	}
+
+	url := "/cloudapi/compute/pause"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pfw_add.go

@@ -33,6 +33,12 @@ type PFWAddRequest struct {
 	Proto string `url:"proto" json:"proto" validate:"proto"`
 }
 
+type wrapperPFWAddRequest struct {
+	PFWAddRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // PFWAdd add port forward rule
 func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error) {
 	err := validators.ValidateRequest(req)
@@ -40,9 +46,14 @@ func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error)
 		return 0, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperPFWAddRequest{
+		PFWAddRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/pfwAdd"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return 0, err
 	}
@@ -54,3 +65,25 @@ func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error)
 
 	return result, nil
 }
+
+// PFWAddAsync adds port forward rule with AsyncMode
+func (c Compute) PFWAddAsync(ctx context.Context, req PFWAddRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWAddRequest{
+		PFWAddRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/pfwAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pfw_del.go

@@ -36,6 +36,12 @@ type PFWDelRequest struct {
 	Proto string `url:"proto,omitempty" json:"proto,omitempty"`
 }
 
+type wrapperPFWDelRequest struct {
+	PFWDelRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // PFWDel deletes port forward rule
 func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -43,9 +49,14 @@ func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperPFWDelRequest{
+		PFWDelRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/pfwDel"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -57,3 +68,25 @@ func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
 
 	return result, nil
 }
+
+// PFWDelAsync deletes port forward rule with AsyncMode
+func (c Compute) PFWDelAsync(ctx context.Context, req PFWDelRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWDelRequest{
+		PFWDelRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pin_to_node.go

@@ -20,6 +20,12 @@ type PinToNodeRequest struct {
 	AutoStart bool `url:"autoStart" json:"autoStart"`
 }
 
+type wrapperPinToNodeRequest struct {
+	PinToNodeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // PinToNode pin compute to current node
 func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -27,9 +33,14 @@ func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (bool, err
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        false,
+	}
+
 	url := "/cloudapi/compute/pin_to_node"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -41,3 +52,25 @@ func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (bool, err
 
 	return result, nil
 }
+
+// PinToNodeAsync pins compute to current node with AsyncMode
+func (c Compute) PinToNodeAsync(ctx context.Context, req PinToNodeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudapi/compute/pin_to_node"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/power_cycle.go

@@ -15,6 +15,12 @@ type PowerCycleRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperPowerCycleRequest struct {
+	PowerCycleRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // PowerCycle makes force stop and start compute
 func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, e
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperPowerCycleRequest{
+		PowerCycleRequest: req,
+		AsyncMode:         false,
+	}
+
 	url := "/cloudapi/compute/powerCycle"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, e
 
 	return result, nil
 }
+
+// PowerCycleAsync makes force stop and start compute with AsyncMode
+func (c Compute) PowerCycleAsync(ctx context.Context, req PowerCycleRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPowerCycleRequest{
+		PowerCycleRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudapi/compute/powerCycle"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/reboot.go

@@ -15,6 +15,12 @@ type RebootRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperRebootRequest struct {
+	RebootRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Reboot reboots compute
 func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperRebootRequest{
+		RebootRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/reboot"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
 
 	return result, nil
 }
+
+// RebootAsync reboots compute with AsyncMode
+func (c Compute) RebootAsync(ctx context.Context, req RebootRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRebootRequest{
+		RebootRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/reboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/redeploy.go

@@ -44,6 +44,12 @@ type RedeployRequest struct {
 	ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
 }
 
+type wrapperRedeployRequest struct {
+	RedeployRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Redeploy redeploys compute
 func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -51,9 +57,14 @@ func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperRedeployRequest{
+		RedeployRequest: req,
+		AsyncMode:       false,
+	}
+
 	url := "/cloudapi/compute/redeploy"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -65,3 +76,25 @@ func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error
 
 	return result, nil
 }
+
+// RedeployAsync redeploys compute with AsyncMode
+func (c Compute) RedeployAsync(ctx context.Context, req RedeployRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRedeployRequest{
+		RedeployRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudapi/compute/redeploy"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/reset.go

@@ -15,6 +15,12 @@ type ResetRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperResetRequest struct {
+	ResetRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Reset resets compute
 func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperResetRequest{
+		ResetRequest: req,
+		AsyncMode:    false,
+	}
+
 	url := "/cloudapi/compute/reset"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
 
 	return result, nil
 }
+
+// ResetAsync resets compute with AsyncMode
+func (c Compute) ResetAsync(ctx context.Context, req ResetRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperResetRequest{
+		ResetRequest: req,
+		AsyncMode:    true,
+	}
+
+	url := "/cloudapi/compute/reset"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/resize.go

@@ -43,6 +43,12 @@ func (r ResizeRequest) GetRAM() map[string]uint64 {
 	return res
 }
 
+type wrapperResizeRequest struct {
+	ResizeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Resize resizes compute instance
 func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -50,9 +56,14 @@ func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperResizeRequest{
+		ResizeRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/resize"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -64,3 +75,25 @@ func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
 
 	return result, nil
 }
+
+// ResizeAsync resizes compute instance with AsyncMode
+func (c Compute) ResizeAsync(ctx context.Context, req ResizeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperResizeRequest{
+		ResizeRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/resize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/restore.go

@@ -3,6 +3,7 @@ package compute
 import (
 	"context"
 	"net/http"
+	"strconv"
 
 	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
 )
@@ -14,16 +15,54 @@ type RestoreRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperRestoreRequest struct {
+	RestoreRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Restore restores compute from recycle bin
-func (c Compute) Restore(ctx context.Context, req RestoreRequest) (string, error) {
+func (c Compute) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRestoreRequest{
+		RestoreRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudapi/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// RestoreAsync restores compute from recycle bin with AsyncMode
+func (c Compute) RestoreAsync(ctx context.Context, req RestoreRequest) (string, error) {
 	err := validators.ValidateRequest(req)
 	if err != nil {
 		return "", validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperRestoreRequest{
+		RestoreRequest: req,
+		AsyncMode:      true,
+	}
+
 	url := "/cloudapi/compute/restore"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return "", err
 	}

pkg/cloudapi/compute/resume.go

@@ -15,6 +15,12 @@ type ResumeRequest struct {
 	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
 }
 
+type wrapperResumeRequest struct {
+	ResumeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Resume resume Compute from paused state
 func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -22,9 +28,14 @@ func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperResumeRequest{
+		ResumeRequest: req,
+		AsyncMode:     false,
+	}
+
 	url := "/cloudapi/compute/resume"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -36,3 +47,25 @@ func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
 
 	return result, nil
 }
+
+// ResumeAsync resumes Compute from paused state with AsyncMode
+func (c Compute) ResumeAsync(ctx context.Context, req ResumeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperResumeRequest{
+		ResumeRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudapi/compute/resume"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/set_cpu_alignment_profile.go

@@ -0,0 +1,43 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/constants"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/internal/validators"
+)
+
+// SetCPUAlignmentProfileRequest struct to set CPU alignment profile for computes
+type SetCPUAlignmentProfileRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []int64 `url:"compute_ids" json:"compute_ids" validate:"min=1"`
+
+	// CPU alignment profile name
+	// Required: true
+	CPUAlignmentProfile string `url:"cpu_alignment_profile" json:"cpu_alignment_profile" validate:"required"`
+}
+
+// SetCPUAlignmentProfile sets CPU alignment profile for computes
+func (c Compute) SetCPUAlignmentProfile(ctx context.Context, req SetCPUAlignmentProfileRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/set_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/snapshot_create.go

@@ -20,18 +20,33 @@ type SnapshotCreateRequest struct {
 	// Maximum length: 36 characters
 	// Required: true
 	Label string `url:"label" json:"label" validate:"required,max=36,excludesall=<>"`
+
+	// Create snapshot with memory dump
+	// Required: false
+	// Default: false
+	WithMemory bool `url:"with_memory" json:"with_memory"`
 }
 
-// SnapshotCreate create compute snapshot
+type wrapperSnapshotCreateRequest struct {
+	SnapshotCreateRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// SnapshotCreate creates compute snapshot
 func (c Compute) SnapshotCreate(ctx context.Context, req SnapshotCreateRequest) (string, error) {
 	err := validators.ValidateRequest(req)
 	if err != nil {
 		return "", validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperSnapshotCreateRequest{
+		SnapshotCreateRequest: req,
+		AsyncMode:             false,
+	}
+
 	url := "/cloudapi/compute/snapshotCreate"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return "", err
 	}
@@ -40,3 +55,25 @@ func (c Compute) SnapshotCreate(ctx context.Context, req SnapshotCreateRequest)
 
 	return result, nil
 }
+
+// SnapshotCreateAsync creates compute snapshot in async mode
+func (c Compute) SnapshotCreateAsync(ctx context.Context, req SnapshotCreateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotCreateRequest{
+		SnapshotCreateRequest: req,
+		AsyncMode:             true,
+	}
+
+	url := "/cloudapi/compute/snapshotCreate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/snapshot_rollback.go

@@ -17,6 +17,16 @@ type SnapshotRollbackRequest struct {
 	// Text label of snapshot to rollback
 	// Required: true
 	Label string `url:"label" json:"label" validate:"required"`
+
+	// Rollback with memory dump restore
+	// Required: false
+	// Default: true
+	WithMemory interface{} `url:"with_memory,omitempty" json:"with_memory,omitempty" validate:"omitempty,isBool"`
+}
+
+type wrapperSnapshotRollbackRequest struct {
+	SnapshotRollbackRequest
+	AsyncMode bool `url:"asyncMode"`
 }
 
 // SnapshotRollback rollbacks specified compute snapshot
@@ -26,9 +36,14 @@ func (c Compute) SnapshotRollback(ctx context.Context, req SnapshotRollbackReque
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperSnapshotRollbackRequest{
+		SnapshotRollbackRequest: req,
+		AsyncMode:               false,
+	}
+
 	url := "/cloudapi/compute/snapshotRollback"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -40,3 +55,25 @@ func (c Compute) SnapshotRollback(ctx context.Context, req SnapshotRollbackReque
 
 	return result, nil
 }
+
+// SnapshotRollbackAsync rollbacks specified compute snapshot in async mode
+func (c Compute) SnapshotRollbackAsync(ctx context.Context, req SnapshotRollbackRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotRollbackRequest{
+		SnapshotRollbackRequest: req,
+		AsyncMode:               true,
+	}
+
+	url := "/cloudapi/compute/snapshotRollback"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/start.go

@@ -19,6 +19,12 @@ type StartRequest struct {
 	AltBootID uint64 `url:"altBootId,omitempty" json:"altBootId,omitempty"`
 }
 
+type wrapperStartRequest struct {
+	StartRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Start starts compute
 func (c Compute) Start(ctx context.Context, req StartRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -26,9 +32,14 @@ func (c Compute) Start(ctx context.Context, req StartRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperStartRequest{
+		StartRequest: req,
+		AsyncMode:    false,
+	}
+
 	url := "/cloudapi/compute/start"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -40,3 +51,25 @@ func (c Compute) Start(ctx context.Context, req StartRequest) (bool, error) {
 
 	return result, nil
 }
+
+// StartAsync starts compute with AsyncMode
+func (c Compute) StartAsync(ctx context.Context, req StartRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperStartRequest{
+		StartRequest: req,
+		AsyncMode:    true,
+	}
+
+	url := "/cloudapi/compute/start"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/stop.go

@@ -19,6 +19,12 @@ type StopRequest struct {
 	Force bool `url:"force,omitempty" json:"force,omitempty"`
 }
 
+type wrapperStopRequest struct {
+	StopRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
 // Stop stops compute
 func (c Compute) Stop(ctx context.Context, req StopRequest) (bool, error) {
 	err := validators.ValidateRequest(req)
@@ -26,9 +32,14 @@ func (c Compute) Stop(ctx context.Context, req StopRequest) (bool, error) {
 		return false, validators.ValidationErrors(validators.GetErrors(err))
 	}
 
+	reqWrapped := wrapperStopRequest{
+		StopRequest: req,
+		AsyncMode:   false,
+	}
+
 	url := "/cloudapi/compute/stop"
 
-	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
 	if err != nil {
 		return false, err
 	}
@@ -40,3 +51,25 @@ func (c Compute) Stop(ctx context.Context, req StopRequest) (bool, error) {
 
 	return result, nil
 }
+
+// StopAsync stops compute with AsyncMode
+func (c Compute) StopAsync(ctx context.Context, req StopRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperStopRequest{
+		StopRequest: req,
+		AsyncMode:   true,
+	}
+
+	url := "/cloudapi/compute/stop"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/update.go

@@ -69,6 +69,11 @@ type UpdateRequest struct {
 	// The OS version that will be installed on the virtual machine
 	// Required: false
 	OSVersion string `url:"os_version,omitempty" json:"os_version,omitempty"`
+
+	// Clock type for the VM
+	// Required: false
+	// Default: null
+	Clock string `url:"clock,omitempty" json:"clock,omitempty"`
 }
 
 // Update updates some properties of the compute