v9.0.0

pkg/cloudbroker/compute/affinity_group_check_start.go

@@ -0,0 +1,36 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityGroupCheckStartRequest struct to check all computes with current affinity label can start
+type AffinityGroupCheckStartRequest struct {
+	// ID of the resource group
+	// Required: true
+	RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
+}
+
+// AffinityGroupCheckStart check all computes with current affinity label can start
+func (c Compute) AffinityGroupCheckStart(ctx context.Context, req AffinityGroupCheckStartRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityGroupCheckStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/affinity_label_remove.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityLabelRemoveRequest struct for clear affinity label for compute
+type AffinityLabelRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// AffinityLabelRemove clear affinity label for compute
+func (c Compute) AffinityLabelRemove(ctx context.Context, req AffinityLabelRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityLabelRemove"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/affinity_label_set.go

@@ -0,0 +1,41 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityLabelSetRequest struct to set affinity label for compute
+type AffinityLabelSetRequest struct {
+	// IDs of the compute instances
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
+}
+
+// AffinityLabelSet sets affinity label for compute
+func (c Compute) AffinityLabelSet(ctx context.Context, req AffinityLabelSetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityLabelSet"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/affinity_relations.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRelationsRequest struct to get dict of computes
+type AffinityRelationsRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// AffinityRelations gets dict of computes divided by affinity and anti affinity rules
+func (c Compute) AffinityRelations(ctx context.Context, req AffinityRelationsRequest) (*RecordAffinityRelations, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityRelations"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordAffinityRelations{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudbroker/compute/affinity_rule_add.go

@@ -0,0 +1,68 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRuleAddRequest struct to add affinity rule
+type AffinityRuleAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Should be one of:
+	//	- node
+	//	- compute
+	// Required: true
+	Topology string `url:"topology" json:"topology" validate:"computeTopology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy" json:"policy" validate:"computePolicy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode" json:"mode" validate:"computeMode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// AffinityRuleAdd adds affinity rule
+func (c Compute) AffinityRuleAdd(ctx context.Context, req AffinityRuleAddRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityRuleAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/affinity_rule_remove.go

@@ -0,0 +1,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRuleRemoveRequest struct to remove affinity rule
+type AffinityRuleRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology" json:"topology" validate:"computeTopology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy" json:"policy" validate:"computePolicy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode" json:"mode" validate:"computeMode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// AffinityRuleRemove remove affinity rule
+func (c Compute) AffinityRuleRemove(ctx context.Context, req AffinityRuleRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityRuleRemove"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/affinity_rules_clear.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRulesClearRequest struct to clear affinity rules
+type AffinityRulesClearRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// AffinityRulesClear clears affinity rules
+func (c Compute) AffinityRulesClear(ctx context.Context, req AffinityRulesClearRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/affinityRulesClear"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/anti_affinity_rule_add.go

@@ -0,0 +1,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AntiAffinityRuleAddRequest struct to add anti affinity rule
+type AntiAffinityRuleAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology" json:"topology" validate:"computeTopology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy" json:"policy" validate:"computePolicy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode" json:"mode" validate:"computeMode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// AntiAffinityRuleAdd adds anti affinity rule
+func (c Compute) AntiAffinityRuleAdd(ctx context.Context, req AntiAffinityRuleAddRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/antiAffinityRuleAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/anti_affinity_rule_clear.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AntiAffinityRulesClearRequest struct to clear anti affinity rules
+type AntiAffinityRulesClearRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// AntiAffinityRulesClear clear anti affinity rules
+func (c Compute) AntiAffinityRulesClear(ctx context.Context, req AntiAffinityRulesClearRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/antiAffinityRulesClear"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/anti_affinity_rule_remove.go

@@ -0,0 +1,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AntiAffinityRuleRemoveRequest struct to remove anti affinity rule
+type AntiAffinityRuleRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Compute or node, for whom rule applies
+	// Required: true
+	Topology string `url:"topology" json:"topology" validate:"computeTopology"`
+
+	// The degree of 'strictness' of this rule
+	// Should be one of:
+	//	- RECOMMENDED
+	//	- REQUIRED
+	// Required: true
+	Policy string `url:"policy" json:"policy" validate:"computePolicy"`
+
+	// The comparison mode is 'value', recorded by the specified 'key'
+	// Should be one of:
+	//	- EQ
+	//	- EN
+	//	- ANY
+	// Required: true
+	Mode string `url:"mode" json:"mode" validate:"computeMode"`
+
+	// Key that are taken into account when analyzing this rule will be identified
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+
+	// Value that must match the key to be taken into account when analyzing this rule
+	// Required: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// AntiAffinityRuleRemove removes anti affinity rule
+func (c Compute) AntiAffinityRuleRemove(ctx context.Context, req AntiAffinityRuleRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/antiAffinityRuleRemove"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/attach_gpu.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AttachGPURequest struct to attach GPU for compute
+type AttachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Identifier vGPU
+	// Required: true
+	VGPUID uint64 `url:"vgpuId" json:"vgpuId" validate:"required"`
+}
+
+// AttachGPU attaches GPU for compute, returns vGPU ID on success
+func (c Compute) AttachGPU(ctx context.Context, req AttachGPURequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/attachGpu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/attach_pci_device.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AttachPCIDeviceRequest struct to attach PCI device
+type AttachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// PCI device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
+}
+
+// AttachPCIDevice attaches PCI device
+func (c Compute) AttachPCIDevice(ctx context.Context, req AttachPCIDeviceRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/attachPciDevice"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/audits.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AuditsRequest struct to get audit records
+type AuditsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Audits gets audit records for the specified compute object
+func (c Compute) Audits(ctx context.Context, req AuditsRequest) (ListDetailedAudits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/audits"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListDetailedAudits{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/boot_disk_set.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootDiskSetRequest struct to set boot disk for compute
+type BootDiskSetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to set as boot
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+}
+
+// BootDiskSet sets boot disk for compute
+func (c Compute) BootDiskSet(ctx context.Context, req BootDiskSetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/bootDiskSet"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/boot_order_get.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootOrderGetRequest struct to get boot order
+type BootOrderGetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// BootOrderGet gets actual compute boot order information
+func (c Compute) BootOrderGet(ctx context.Context, req BootOrderGetRequest) ([]string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/bootOrderGet"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	orders := make([]string, 0)
+
+	err = json.Unmarshal(res, &orders)
+	if err != nil {
+		return nil, err
+	}
+
+	return orders, nil
+}

pkg/cloudbroker/compute/boot_order_set.go

@@ -0,0 +1,48 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootOrderSetRequest struct to set boot order
+type BootOrderSetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// List of boot devices
+	// Should be one of:
+	//	- cdrom
+	//	- network
+	//	- hd
+	// Required: true
+	Order []string `url:"order" json:"order" validate:"min=1,computeOrder"`
+}
+
+// BootOrderSet sets compute boot order
+func (c Compute) BootOrderSet(ctx context.Context, req BootOrderSetRequest) ([]string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/bootOrderSet"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	orders := make([]string, 0)
+
+	err = json.Unmarshal(res, &orders)
+	if err != nil {
+		return nil, err
+	}
+
+	return orders, nil
+}

pkg/cloudbroker/compute/cd_eject.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CDEjectRequest struct to eject CD image
+type CDEjectRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// CDEject ejects CD image to compute's CD-ROM
+func (c Compute) CDEject(ctx context.Context, req CDEjectRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, err
+}

pkg/cloudbroker/compute/cd_insert.go

@@ -0,0 +1,36 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CDInsertRequest struct to insert new CD image
+type CDInsertRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of CD-ROM image
+	// Required: true
+	CDROMID uint64 `url:"cdromId" json:"cdromId" validate:"required"`
+}
+
+// CDInsert inserts new CD image to compute's CD-ROM
+func (c Compute) CDInsert(ctx context.Context, req CDInsertRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/cdInsert"
+
+	_, err = c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}

pkg/cloudbroker/compute/change_ip.go

@@ -0,0 +1,54 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ChangeIPRequest struct to change IP for network
+type ChangeIPRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Network type
+	// 'EXTNET' for connect to external network directly
+	// 'VINS' for connect to ViNS
+	// Required: true
+	NetType string `url:"netType" json:"netType" validate:"computeNetType"`
+
+	// Network ID for connect to
+	// For EXTNET - external network ID
+	// For VINS - VINS ID
+	// Required: true
+	NetID uint64 `url:"netId" json:"netId" validate:"required"`
+
+	// IP address to which we will change the existing one, it must be from the same subnet
+	// Required: true
+	IPAddr string `url:"ipAddr" json:"ipAddr" validate:"required"`
+}
+
+// ChangeIP change reserved IP for compute instance
+func (c Compute) ChangeIP(ctx context.Context, req ChangeIPRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/changeIp"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/change_link_state.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ChangeLinkStateRequest struct for changing link state
+type ChangeLinkStateRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Interface name or MAC address
+	// Required: true
+	Interface string `url:"interface" json:"interface" validate:"required"`
+
+	// Interface state
+	// Must be either "on" or "off"
+	// Required: true
+	State string `url:"state" json:"state" validate:"required,interfaceState"`
+}
+
+// ChangeLinkState changes the status link virtual of compute
+func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/changeLinkState"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+	return result, nil
+}

pkg/cloudbroker/compute/clone.go

@@ -0,0 +1,55 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CloneRequest struct to clone compute instance
+type CloneRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the clone
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// Timestamp of the parent's snapshot to create clone from
+	// Required: false
+	SnapshotTimestamp uint64 `url:"snapshotTimestamp" json:"snapshotTimestamp"`
+
+	// Name of the parent's snapshot to create clone from
+	// Required: false
+	SnapshotName string `url:"snapshotName" json:"snapshotName"`
+
+	// true ignore that the compute is running
+	// Default: false
+	// Required: false
+	Force bool `url:"force" json:"force"`
+}
+
+// Clone clones compute instance
+func (c Compute) Clone(ctx context.Context, req CloneRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/clone"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/compute.go

@@ -0,0 +1,16 @@
+// API Actor for managing Compute. This actor is a final API for admin to manage Compute
+package compute
+
+import "repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/interfaces"
+
+// Structure for creating request to compute
+type Compute struct {
+	client interfaces.Caller
+}
+
+// Builder for compute endpoints
+func New(client interfaces.Caller) *Compute {
+	return &Compute{
+		client: client,
+	}
+}

pkg/cloudbroker/compute/computeci_set.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ComputeCISetRequest struct to set compute CI
+type ComputeCISetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the Compute CI
+	// Required: true
+	ComputeCIID uint64 `url:"computeciId" json:"computeciId" validate:"required"`
+}
+
+// ComputeCISet sets compute CI ID for compute
+func (c Compute) ComputeCISet(ctx context.Context, req ComputeCISetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/computeciSet"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/computeci_unset.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ComputeCIUnsetRequest struct to unset compute CI
+type ComputeCIUnsetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// ComputeCIUnset unsets compute CI ID from compute
+func (c Compute) ComputeCIUnset(ctx context.Context, req ComputeCIUnsetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/computeciUnset"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/create_template.go

@@ -0,0 +1,78 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CreateTemplateRequest struct to create template
+type CreateTemplateRequest struct {
+	// ID of the compute to create template from
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name to assign to the template being created
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+}
+
+type wrapperCreateTemplateRequest struct {
+	CreateTemplateRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// CreateTemplateAsync create template from compute instance
+func (c Compute) CreateTemplateAsync(ctx context.Context, req CreateTemplateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCreateTemplateRequest{
+		CreateTemplateRequest: req,
+		AsyncMode:             true,
+	}
+
+	url := "/cloudbroker/compute/createTemplate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}
+
+// CreateTemplate create template from compute instance
+func (c Compute) CreateTemplate(ctx context.Context, req CreateTemplateRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCreateTemplateRequest{
+		CreateTemplateRequest: req,
+		AsyncMode:             false,
+	}
+
+	url := "/cloudbroker/compute/createTemplate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/create_template_from_blank.go

@@ -0,0 +1,112 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CreateTemplateFromBlankRequest struct to create template from boot disk of current compute
+type CreateTemplateFromBlankRequest struct {
+	// ID of the compute to create template from
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the rescue disk
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// Boot type of image BIOS or UEFI
+	// Required: true
+	BootType string `url:"boottype" json:"boottype" validate:"imageBootType"`
+
+	// Image type linux, windows or other
+	// Required: true
+	ImageType string `url:"imagetype" json:"imagetype" validate:"imageType"`
+
+	// Username for the image
+	// Required: false
+	Username string `url:"username,omitempty" json:"username,omitempty"`
+
+	// Password for the image
+	// Required: false
+	Password string `url:"password,omitempty" json:"password,omitempty"`
+
+	// Account ID to make the image exclusive
+	// Required: false
+	AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
+
+	// SEP ID
+	// Required: false
+	SepID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
+
+	// Pool for image create
+	// Required: false
+	PoolName string `url:"poolName,omitempty" json:"poolName,omitempty"`
+
+	// Does this machine supports hot resize
+	// Default: false
+	// Required: false
+	HotResize bool `url:"hotresize" json:"hotresize"`
+}
+
+type wrapperCreateTemplateFromBlankRequest struct {
+	CreateTemplateFromBlankRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// CreateTemplateFromBlank creates template from boot disk of current compute in sync mode.
+// It returns id of created compute and error.
+func (c Compute) CreateTemplateFromBlank(ctx context.Context, req CreateTemplateFromBlankRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCreateTemplateFromBlankRequest{
+		CreateTemplateFromBlankRequest: req,
+		AsyncMode:                      false,
+	}
+
+	url := "/cloudbroker/compute/createTemplateFromBlank"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}
+
+// CreateTemplateFromBlankAsync creates template from boot disk of current compute in async mode.
+// It returns guid of task and error.
+func (c Compute) CreateTemplateFromBlankAsync(ctx context.Context, req CreateTemplateFromBlankRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCreateTemplateFromBlankRequest{
+		CreateTemplateFromBlankRequest: req,
+		AsyncMode:                      true,
+	}
+
+	url := "/cloudbroker/compute/createTemplateFromBlank"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/delete.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteRequest struct to delete compute
+type DeleteRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Delete permanently
+	// Required: false
+	Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
+
+	// Set True if you want to detach data disks (if any) from the compute before its deletion
+	// Required: false
+	DetachDisks bool `url:"detachDisks,omitempty" json:"detachDisks,omitempty"`
+}
+
+// Delete deletes compute
+func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/delete_custom_fields.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteCustomFieldsRequest struct to delete compute's custom fields
+type DeleteCustomFieldsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// DeleteCustomFields deletes computes custom fields
+func (c Compute) DeleteCustomFields(ctx context.Context, req DeleteCustomFieldsRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/deleteCustomFields"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/detach_gpu.go

@@ -0,0 +1,43 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DetachGPURequest struct to detach VGPU for compute
+type DetachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Identifier virtual GPU
+	// Required: false
+	VGPUID int64 `url:"vgpuId,omitempty" json:"vgpuId,omitempty"`
+}
+
+// DetachGPU detaches VGPU for compute.
+// If param VGPU ID is equivalent -1, then detach all VGPU for compute
+func (c Compute) DetachGPU(ctx context.Context, req DetachGPURequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/detachGpu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/detach_pci_device.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DetachPCIDeviceRequest struct to detach PCI device
+type DetachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// PCI device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
+}
+
+// DetachPciDevice detaches PCI device
+func (c Compute) DetachPciDevice(ctx context.Context, req DetachPCIDeviceRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/detachPciDevice"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disable.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DisableRequest struct to disable compute
+type DisableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Disable disables compute
+func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_add.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskAddRequest struct to create and attach disk to compute
+type DiskAddRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name for disk
+	// Required: true
+	DiskName string `url:"diskName" json:"diskName" validate:"required"`
+
+	// Disk size in GB
+	// Required: true
+	Size uint64 `url:"size" json:"size" validate:"required"`
+
+	// Storage endpoint provider ID
+	// By default the same with boot disk
+	// Required: false
+	SepID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
+
+	// Type of the disk
+	// Should be one of:
+	//	- D
+	//	- B
+	// Required: false
+	DiskType string `url:"diskType,omitempty" json:"diskType,omitempty" validate:"omitempty,computeDiskType"`
+
+	// Pool name
+	// By default will be chosen automatically
+	// Required: false
+	Pool string `url:"pool,omitempty" json:"pool,omitempty"`
+
+	// Optional description
+	// Required: false
+	Description string `url:"desc,omitempty" json:"desc,omitempty"`
+
+	// Specify image id for create disk from template
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
+}
+
+// DiskAdd creates new disk and attach to compute
+func (c Compute) DiskAdd(ctx context.Context, req DiskAddRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_attach.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskAttachRequest struct to attach disk to compute
+type DiskAttachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to attach
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// Type of the disk B;D
+	// Required: false
+	DiskType string `url:"diskType,omitempty" json:"diskType,omitempty"`
+}
+
+// DiskAttach attach disk to compute
+func (c Compute) DiskAttach(ctx context.Context, req DiskAttachRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_del.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskDelRequest struct to detach and delete disk from compute
+type DiskDelRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of disk instance
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// False if disk is to be deleted to recycle bin
+	// Required: true
+	Permanently bool `url:"permanently" json:"permanently"`
+}
+
+// DiskDel deletes disk and detaches it from compute
+func (c Compute) DiskDel(ctx context.Context, req DiskDelRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_detach.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskDetachRequest struct to detach disk from compute
+type DiskDetachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to detach
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+}
+
+// DiskDetach detaches disk from compute
+func (c Compute) DiskDetach(ctx context.Context, req DiskDetachRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_migrate.go

@@ -0,0 +1,53 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskMigrateRequest struct to migrate compute's disk to target disk
+type DiskMigrateRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID source disk
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// ID target disk
+	// Required: true
+	TargetDiskID uint64 `url:"targetDiskId" json:"targetDiskId" validate:"required"`
+
+	// Migration mode. 1 - Data migration and domain update were already completed by third-party software.
+	// Use this if target disk already connected to compute and you only need to save changes for next reboot.
+	// Required: false
+	Mode int64 `url:"mode,omitempty" json:"mode,omitempty"`
+}
+
+// DiskMigrate - migrate compute's disk to target disk. Source disk will be detached, target disk will be attached to the same PCI slot.
+// (WARNING) Current realisation is limited. No actual data migration will be performed.
+// Use this API if target disk already connected to compute and you only need to save changes for next reboot (mode: 1).
+func (c Compute) DiskMigrate(ctx context.Context, req DiskMigrateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskMigrate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_qos.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskQOSRequest struct to change QOS of the disk
+type DiskQOSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to apply limits
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// Limit IO for a certain disk total and read/write options are not allowed to be combined
+	// Required: true
+	Limits string `url:"limits" json:"limits" validate:"required"`
+}
+
+// DiskQOS changes QOS of the disk
+func (c Compute) DiskQOS(ctx context.Context, req DiskQOSRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_resize.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskResizeRequest struct to change disk size
+type DiskResizeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to resize
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// New disk size
+	// Required: true
+	Size uint64 `url:"size" json:"size" validate:"required"`
+}
+
+// DiskResize changes disk size
+func (c Compute) DiskResize(ctx context.Context, req DiskResizeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskResize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/disk_switch_to_replication.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DiskSwitchToReplicationRequest struct to switch disk to it's replication
+type DiskSwitchToReplicationRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to switch
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+
+	// Delete replication relationship
+	// Required: false
+	StopReplication bool `url:"stopReplication" json:"stopReplication"`
+}
+
+// DiskSwitchToReplication switches disk to it's replication
+func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToReplicationRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/diskSwitchToReplication"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/enable.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// EnableRequest struct to enable compute
+type EnableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Enable enables compute
+func (c Compute) Enable(ctx context.Context, req EnableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/enable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/filter.go

@@ -0,0 +1,170 @@
+package compute
+
+import (
+	"context"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/interfaces"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudbroker/k8s"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudbroker/lb"
+)
+
+// FilterByID returns ListComputes with specified ID.
+func (lc ListComputes) FilterByID(id uint64) ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		return ic.ID == id
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByName returns ListComputes with specified Name.
+func (lc ListComputes) FilterByName(name string) ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		return ic.Name == name
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByStatus returns ListComputes with specified Status.
+func (lc ListComputes) FilterByStatus(status string) ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		return ic.Status == status
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByTechStatus returns ListComputes with specified TechStatus.
+func (lc ListComputes) FilterByTechStatus(techStatus string) ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		return ic.TechStatus == techStatus
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByDiskID return ListComputes with specified DiskID.
+func (lc ListComputes) FilterByDiskID(diskID uint64) ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		for _, disk := range ic.Disks {
+			if disk.ID == diskID {
+				return true
+			}
+		}
+		return false
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByK8SID returns master and worker nodes (ListComputes) inside specified K8S cluster.
+func (lc ListComputes) FilterByK8SID(ctx context.Context, k8sID uint64, decortClient interfaces.Caller) (*ListComputes, error) {
+	caller := k8s.New(decortClient)
+
+	req := k8s.GetRequest{
+		K8SID: k8sID,
+	}
+
+	cluster, err := caller.Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	predicate := func(ic ItemCompute) bool {
+		for _, info := range cluster.K8SGroups.Masters.DetailedInfo {
+			if info.ID == ic.ID {
+				return true
+			}
+		}
+
+		for _, worker := range cluster.K8SGroups.Workers {
+			for _, info := range worker.DetailedInfo {
+				if info.ID == ic.ID {
+					return true
+				}
+			}
+		}
+
+		return false
+	}
+
+	result := lc.FilterFunc(predicate)
+
+	return &result, nil
+}
+
+// K8SMasters is used to filter master nodes. Best used after FilterByK8SID function.
+func (lc ListComputes) FilterByK8SMasters() ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		for _, rule := range ic.AntiAffinityRules {
+			if rule.Value == "master" {
+				return true
+			}
+		}
+		return false
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// K8SMasters is used to filter worker nodes. Best used after FilterByK8SID function.
+func (lc ListComputes) FilterByK8SWorkers() ListComputes {
+	predicate := func(ic ItemCompute) bool {
+		for _, rule := range ic.AntiAffinityRules {
+			if rule.Value == "worker" {
+				return true
+			}
+		}
+		return false
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByLBID is used to filter ListComputes used by specified Load Balancer.
+func (lc ListComputes) FilterByLBID(ctx context.Context, lbID uint64, decortClient interfaces.Caller) (*ListComputes, error) {
+	caller := lb.New(decortClient)
+
+	req := lb.GetRequest{
+		LBID: lbID,
+	}
+
+	foundLB, err := caller.Get(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	predicate := func(ic ItemCompute) bool {
+		return ic.ID == foundLB.PrimaryNode.ComputeID || ic.ID == foundLB.SecondaryNode.ComputeID
+	}
+
+	result := lc.FilterFunc(predicate)
+
+	return &result, nil
+}
+
+// FilterFunc allows filtering ListComputes based on a user-specified predicate.
+func (lc ListComputes) FilterFunc(predicate func(ItemCompute) bool) ListComputes {
+	var result ListComputes
+
+	for _, item := range lc.Data {
+		if predicate(item) {
+			result.Data = append(result.Data, item)
+		}
+	}
+
+	result.EntryCount = uint64(len(result.Data))
+
+	return result
+}
+
+// FindOne returns first found ItemCompute
+// If none was found, returns an empty struct.
+func (lc ListComputes) FindOne() ItemCompute {
+	if len(lc.Data) == 0 {
+		return ItemCompute{}
+	}
+
+	return lc.Data[0]
+}

pkg/cloudbroker/compute/filter_test.go

@@ -0,0 +1,250 @@
+package compute
+
+import (
+	"testing"
+)
+
+var computes = ListComputes{
+	Data: []ItemCompute{
+		{
+			Disks: []InfoDisk{
+				{
+					ID:      65191,
+					PCISlot: 6,
+				},
+			},
+			InfoCompute: InfoCompute{
+				ACL:           []interface{}{},
+				AccountID:     132847,
+				AccountName:   "std_2",
+				AffinityLabel: "",
+				AffinityRules: []ItemRule{
+					{
+						GUID:     "",
+						Key:      "aff_key",
+						Mode:     "ANY",
+						Policy:   "RECOMMENDED",
+						Topology: "compute",
+						Value:    "aff_val",
+					},
+				},
+				AffinityWeight: 0,
+				AntiAffinityRules: []ItemRule{
+					{
+						GUID:     "",
+						Key:      "antiaff_key",
+						Mode:     "ANY",
+						Policy:   "RECOMMENDED",
+						Topology: "compute",
+						Value:    "antiaff_val",
+					},
+				},
+				Arch: "X86_64",
+				BootOrder: []string{
+					"hd", "cdrom",
+				},
+				BootDiskSize:     0,
+				CloneReference:   0,
+				Clones:           []uint64{},
+				ComputeCIID:      0,
+				CPUs:             4,
+				CreatedBy:        "timofey_tkachev_1@decs3o",
+				CreatedTime:      1676975175,
+				CustomFields:     map[string]interface{}{},
+				DeletedBy:        "",
+				DeletedTime:      0,
+				Description:      "",
+				Devices:          nil,
+				Driver:           "KVM_X86",
+				GID:              212,
+				GUID:             48500,
+				ID:               48500,
+				ImageID:          9884,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363500,
+				Name:             "test",
+				Pinned:           false,
+				RAM:              4096,
+				ReferenceID:      "c7cb19ac-af4a-4067-852f-c5572949207e",
+				Registered:       true,
+				ResName:          "compute-48500",
+				RGID:             79724,
+				RGName:           "std_broker2",
+				SnapSets:         ListSnapshots{},
+				StatelessSEPID:   0,
+				StatelessSEPType: "",
+				Status:           "ENABLED",
+				Tags:             map[string]interface{}{},
+				TechStatus:       "STOPPED",
+				TotalDiskSize:    2,
+				UpdatedBy:        "",
+				UpdatedTime:      1677058904,
+				UserManaged:      true,
+				VGPUs:            []uint64{},
+				VINSConnected:    0,
+				VirtualImageID:   0,
+			},
+		},
+		{
+			Disks: []InfoDisk{
+				{
+					ID:      65248,
+					PCISlot: 6,
+				},
+			},
+			InfoCompute: InfoCompute{
+				ACL:               []interface{}{},
+				AccountID:         132848,
+				AccountName:       "std_broker",
+				AffinityLabel:     "",
+				AffinityRules:     []ItemRule{},
+				AffinityWeight:    0,
+				AntiAffinityRules: []ItemRule{},
+				Arch:              "X86_64",
+				BootOrder: []string{
+					"hd", "cdrom",
+				},
+				BootDiskSize:     0,
+				CloneReference:   0,
+				Clones:           []uint64{},
+				ComputeCIID:      0,
+				CPUs:             6,
+				CreatedBy:        "timofey_tkachev_1@decs3o",
+				CreatedTime:      1677579436,
+				CustomFields:     map[string]interface{}{},
+				DeletedBy:        "",
+				DeletedTime:      0,
+				Description:      "",
+				Devices:          nil,
+				Driver:           "KVM_X86",
+				GID:              212,
+				GUID:             48556,
+				ID:               48556,
+				ImageID:          9884,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363853,
+				Name:             "compute_2",
+				Pinned:           false,
+				RAM:              4096,
+				ReferenceID:      "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff",
+				Registered:       true,
+				ResName:          "compute-48556",
+				RGID:             79727,
+				RGName:           "sdk_negative_fields_test",
+				SnapSets:         ListSnapshots{},
+				StatelessSEPID:   0,
+				StatelessSEPType: "",
+				Status:           "ENABLED",
+				Tags:             map[string]interface{}{},
+				TechStatus:       "STARTED",
+				TotalDiskSize:    1,
+				UpdatedBy:        "",
+				UpdatedTime:      1677579436,
+				UserManaged:      true,
+				VGPUs:            []uint64{},
+				VINSConnected:    0,
+				VirtualImageID:   0,
+			},
+		},
+	},
+	EntryCount: 2,
+}
+
+func TestFilterByID(t *testing.T) {
+	actual := computes.FilterByID(48500).FindOne()
+
+	if actual.ID != 48500 {
+		t.Fatal("expected ID 48500, found: ", actual.ID)
+	}
+
+	actualEmpty := computes.FilterByID(0)
+
+	if len(actualEmpty.Data) != 0 {
+		t.Fatal("expected empty, actual: ", len(actualEmpty.Data))
+	}
+}
+
+func TestFilterByName(t *testing.T) {
+	actual := computes.FilterByName("compute_2").FindOne()
+
+	if actual.Name != "compute_2" {
+		t.Fatal("expected compute with name 'test', found: ", actual.Name)
+	}
+}
+
+func TestFilterByStatus(t *testing.T) {
+	actual := computes.FilterByStatus("ENABLED")
+
+	for _, item := range actual.Data {
+		if item.Status != "ENABLED" {
+			t.Fatal("expected ENABLED status, found: ", item.Status)
+		}
+	}
+}
+
+func TestFilterByTechStatus(t *testing.T) {
+	actual := computes.FilterByTechStatus("STARTED").FindOne()
+
+	if actual.ID != 48556 {
+		t.Fatal("expected 48556 with STARTED techStatus, found: ", actual.ID)
+	}
+}
+
+func TestFilterByDiskID(t *testing.T) {
+	actual := computes.FilterByDiskID(65248).FindOne()
+
+	if actual.ID != 48556 {
+		t.Fatal("expected 48556 with DiskID 65248, found: ", actual.ID)
+	}
+}
+
+func TestFilterFunc(t *testing.T) {
+	actual := computes.FilterFunc(func(ic ItemCompute) bool {
+		return ic.Registered == true
+	})
+
+	if len(actual.Data) != 2 {
+		t.Fatal("expected 2 elements found, actual: ", len(actual.Data))
+	}
+
+	for _, item := range actual.Data {
+		if item.Registered != true {
+			t.Fatal("expected Registered to be true, actual: ", item.Registered)
+		}
+	}
+}
+
+func TestSortingByCreatedTime(t *testing.T) {
+	actual := computes.SortByCreatedTime(false)
+
+	if actual.Data[0].Name != "test" {
+		t.Fatal("expected 'test', found: ", actual.Data[0].Name)
+	}
+
+	actual = computes.SortByCreatedTime(true)
+	if actual.Data[0].Name != "compute_2" {
+		t.Fatal("expected 'compute_2', found: ", actual.Data[0].Name)
+	}
+}
+
+func TestSortingByCPU(t *testing.T) {
+	actual := computes.SortByCPU(false)
+
+	if actual.Data[0].CPUs != 4 {
+		t.Fatal("expected 4 CPU cores, found: ", actual.Data[0].CPUs)
+	}
+
+	actual = computes.SortByCPU(true)
+
+	if actual.Data[0].CPUs != 6 {
+		t.Fatal("expected 6 CPU cores, found: ", actual.Data[0].CPUs)
+	}
+}

pkg/cloudbroker/compute/get.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetRequest to get information about compute
+type GetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Get gets information about compute as a RecordCompute struct
+func (c Compute) Get(ctx context.Context, req GetRequest) (*RecordCompute, error) {
+	res, err := c.GetRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordCompute{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets information about compute as an array of bytes
+func (c Compute) GetRaw(ctx context.Context, req GetRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/get"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/compute/get_audits.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetAuditsRequest struct to get compute audits
+type GetAuditsRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// GetAudits gets compute audits
+func (c Compute) GetAudits(ctx context.Context, req GetAuditsRequest) (ListAudits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/getAudits"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListAudits{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/get_console_url.go

@@ -0,0 +1,37 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetConsoleURLRequest struct to get console URL
+type GetConsoleURLRequest struct {
+	// ID of compute instance to get console for
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// GetConsoleURL gets computes console URL
+func (c Compute) GetConsoleURL(ctx context.Context, req GetConsoleURLRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/getConsoleUrl"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	result = strings.ReplaceAll(result, "\\", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/get_custom_fields.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetCustomFieldsRequest struct to get Compute's customFields
+type GetCustomFieldsRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// GetCustomFields gets Compute's customFields
+func (c Compute) GetCustomFields(ctx context.Context, req GetCustomFieldsRequest) (interface{}, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/getCustomFields"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var info interface{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudbroker/compute/get_log.go

@@ -0,0 +1,36 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetLogRequest struct to get compute logs
+type GetLogRequest struct {
+	// ID of compute instance to get log for
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Path to log file
+	// Required: true
+	Path string `url:"path" json:"path" validate:"required"`
+}
+
+// GetLog gets compute's log file by path
+func (c Compute) GetLog(ctx context.Context, req GetLogRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/getLog"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/ids.go

@@ -0,0 +1,46 @@
+package compute
+
+// IDs gets array of ComputeIDs from ListComputes struct
+func (lc ListComputes) IDs() []uint64 {
+	res := make([]uint64, 0, len(lc.Data))
+	for _, c := range lc.Data {
+		res = append(res, c.ID)
+	}
+	return res
+}
+
+// IDs gets array of DiskIDs from ListInfoDisks struct
+func (lid ListInfoDisks) IDs() []uint64 {
+	res := make([]uint64, 0, len(lid))
+	for _, d := range lid {
+		res = append(res, d.ID)
+	}
+	return res
+}
+
+// IDs gets array of PFWsIDs from ListPFW struct
+func (lp ListPFW) IDs() []uint64 {
+	res := make([]uint64, 0, len(lp.Data))
+	for _, p := range lp.Data {
+		res = append(res, p.ID)
+	}
+	return res
+}
+
+// IDs gets array of DiskIDs from ListDisks struct
+func (ld ListDisks) IDs() []uint64 {
+	res := make([]uint64, 0, len(ld))
+	for _, d := range ld {
+		res = append(res, d.ID)
+	}
+	return res
+}
+
+// IDs gets array of PCIDeviceIDs from ListPCIDevices struct
+func (lpd ListPCIDevices) IDs() []uint64 {
+	res := make([]uint64, 0, len(lpd.Data))
+	for _, pd := range lpd.Data {
+		res = append(res, pd.ID)
+	}
+	return res
+}

pkg/cloudbroker/compute/list.go

@@ -0,0 +1,108 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListRequest struct to get list of available computes
+type ListRequest struct {
+	// Find by ID
+	// Required: false
+	ByID uint64 `url:"by_id,omitempty" json:"by_id,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by account ID
+	// Required: false
+	AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
+
+	// Find by resource group name
+	// Required: false
+	RGName string `url:"rgName,omitempty" json:"rgName,omitempty"`
+
+	// Find by resource group ID
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
+
+	// Find by tech status
+	// Required: false
+	TechStatus string `url:"techStatus,omitempty" json:"techStatus,omitempty"`
+
+	// Find by status
+	// Required: false
+	Status string `url:"status,omitempty" json:"status,omitempty"`
+
+	// Find by IP address
+	// Required: false
+	IPAddress string `url:"ipAddress,omitempty" json:"ipAddress,omitempty"`
+
+	// Find by stack ID
+	// Required: false
+	StackID uint64 `url:"stackId,omitempty" json:"stackId,omitempty"`
+
+	// Find by image ID
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
+
+	// Find by external network name
+	// Required: false
+	ExtNetName string `url:"extNetName,omitempty" json:"extNetName,omitempty"`
+
+	// Find by external network ID
+	// Required: false
+	ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"`
+
+	// Include deleted computes
+	// Required: false
+	IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+}
+
+// List gets list of the available computes as a ListComputes struct.
+// Filtering based on status is possible
+func (c Compute) List(ctx context.Context, req ListRequest) (*ListComputes, error) {
+
+	res, err := c.ListRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListComputes{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}
+
+// ListRaw gets list of the available computes as an array of bytes
+func (c Compute) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/list"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudbroker/compute/list_deleted.go

@@ -0,0 +1,84 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListDeletedRequest struct to get deleted computes list
+type ListDeletedRequest struct {
+	// Find by ID
+	// Required: false
+	ByID uint64 `url:"by_id,omitempty" json:"by_id,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by account ID
+	// Required: false
+	AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
+
+	// Find by resource group name
+	// Required: false
+	RGName string `url:"rgName,omitempty" json:"rgName,omitempty"`
+
+	// Find by resource group ID
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
+
+	// Find by tech status
+	// Required: false
+	TechStatus string `url:"techStatus,omitempty" json:"techStatus,omitempty"`
+
+	// Find by IP address
+	// Required: false
+	IPAddress string `url:"ipAddress,omitempty" json:"ipAddress,omitempty"`
+
+	// Find by external network name
+	// Required: false
+	ExtNetName string `url:"extNetName,omitempty" json:"extNetName,omitempty"`
+
+	// Find by external network ID
+	// Required: false
+	ExtNetID uint64 `url:"extNetId,omitempty" json:"extNetId,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+}
+
+// ListDeleted gets list all deleted computes
+func (c Compute) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListComputes, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/listDeleted"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListComputes{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/list_pci_device.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListPCIDeviceRequest struct to get list of PCI devices
+type ListPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Find by resource group ID
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
+
+	// Find by device id
+	// Required: false
+	DevID uint64 `url:"devId,omitempty" json:"devId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by status
+	// Required: false
+	Status string `url:"status,omitempty" json:"status,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+}
+
+// ListPCIDevice gets list of PCI device
+func (c Compute) ListPCIDevice(ctx context.Context, req ListPCIDeviceRequest) (*ListPCIDevices, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/listPciDevice"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListPCIDevices{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/list_vgpu.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListVGPURequest struct to get list of GPU for compute
+type ListVGPURequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Find by GPU id
+	// Required: false
+	GPUID uint64 `url:"gpuId,omitempty" json:"gpuId,omitempty"`
+
+	// Find by type
+	// Required: false
+	Type string `url:"type,omitempty" json:"type,omitempty"`
+
+	// Find by status
+	// Required: false
+	Status string `url:"status,omitempty" json:"status,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+
+	// Include deleted computes. If using field 'status', then includedeleted will be ignored
+	// Required: false
+	IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"`
+}
+
+// ListVGPU gets list of GPU for compute
+func (c Compute) ListVGPU(ctx context.Context, req ListVGPURequest) (*ListVGPUs, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/listVGpu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListVGPUs{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/mass_delete.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MassDeleteRequest struct to delete several computes
+type MassDeleteRequest struct {
+	// IDs of compute instances to delete
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Delete computes permanently
+	// Required: false
+	Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
+}
+
+// MassDelete starts jobs to delete several computes
+func (c Compute) MassDelete(ctx context.Context, req MassDeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/massDelete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/mass_reboot.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MassRebootRequest struct to reboot several computes
+type MassRebootRequest struct {
+	// IDs of compute instances to reboot
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// MassReboot starts jobs to reboot several computes
+func (c Compute) MassReboot(ctx context.Context, req MassRebootRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/massReboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/mass_repair_boot_fs.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MassRepairBootFSRequest struct to repair boot disk filesystem on several computes
+type MassRepairBootFSRequest struct {
+	// IDs of compute instances which boot file systems will be repaired
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// MassRepairBootFS repairs boot disk filesystem on several computes
+func (c Compute) MassRepairBootFS(ctx context.Context, req MassRepairBootFSRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/massRepairBootFs"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/mass_start.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MassStartRequest struct to start several computes
+type MassStartRequest struct {
+	// IDs of compute instances to start
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+}
+
+// MassStart starts jobs to start several computes
+func (c Compute) MassStart(ctx context.Context, req MassStartRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/massStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/mass_stop.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MassStopRequest struct to stop several computes
+type MassStopRequest struct {
+	// IDs of compute instances to stop
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Force stop compute
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+}
+
+// MassStop starts jobs to stop several computes
+func (c Compute) MassStop(ctx context.Context, req MassStopRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/massStop"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MigrateRequest struct to migrate compute
+type MigrateRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Particular Stack ID to migrate this compute to
+	// Required: false
+	TargetStackID uint64 `url:"targetStackId,omitempty" json:"targetStackId,omitempty"`
+
+	// If live migration fails, destroy compute
+	// on source node and recreate on the target
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+}
+
+// Migrate migrates compute to another stack
+func (c Compute) Migrate(ctx context.Context, req MigrateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage.go

@@ -0,0 +1,54 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MigrateStorageRequest struct for migration
+type MigrateStorageRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// SEP ID to migrate disks
+	// Required: true
+	SEPID uint64 `url:"sepId" json:"sepId" validate:"required"`
+
+	// SEP pool name to migrate disks
+	// Required: true
+	PoolName string `url:"poolName" json:"poolName" validate:"required"`
+
+	// Target stack ID
+	// Required: true
+	StackID uint64 `url:"stackId" json:"stackId" validate:"required"`
+
+	// Async API call
+	// Required: true
+	Sync bool `url:"sync" json:"sync" validate:"required"`
+}
+
+// MigrateStorage gets complex compute migration
+// Compute will be migrated to specified stack, and compute disks will
+// be migrated to specified SEP to specified pool.
+// This action can take up to 84 hours
+func (c Compute) MigrateStorage(ctx context.Context, req MigrateStorageRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrateStorage"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage_abort.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MigrateStorageAbortRequest struct to abort migration
+type MigrateStorageAbortRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Status check
+	// Default: false
+	// Required: false
+	StatusCheck bool `url:"statusCheck" json:"statusCheck"`
+}
+
+// MigrateStorageAbort aborts complex compute migration job
+func (c Compute) MigrateStorageAbort(ctx context.Context, req MigrateStorageAbortRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrateStorageAbort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage_clean_up.go

@@ -0,0 +1,37 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MigrateStorageCleanUpRequest struct to cleanup resources after finished migration
+type MigrateStorageCleanUpRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// MigrateStorageCleanUp cleanup resources after finished (success of failed) complex compute migration.
+// If the migration was successful, then old disks will be removed, else new (target) disks will be removed.
+// Do it wisely!
+func (c Compute) MigrateStorageCleanUp(ctx context.Context, req MigrateStorageCleanUpRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrateStorageCleanup"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/migrate_storage_info.go

@@ -0,0 +1,35 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MigrateStorageInfoRequest struct to get info about migration
+type MigrateStorageInfoRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// MigrateStorageInfo gets info about last (include ongoing) storage migration
+func (c Compute) MigrateStorageInfo(ctx context.Context, req MigrateStorageInfoRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrateStorageInfo"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/move_to_rg.go

@@ -0,0 +1,57 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// MoveToRGRequest struct to move compute to new resource group
+type MoveToRGRequest struct {
+	// ID of the compute instance to move
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the target resource group
+	// Required: true
+	RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
+
+	// New name for the compute upon successful move,
+	// if name change required.
+	// Pass empty string if no name change necessary
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Should the compute be restarted upon successful move
+	// Required: false
+	Autostart bool `url:"autostart,omitempty" json:"autostart,omitempty"`
+
+	// By default moving compute in a running state is not allowed.
+	// Set this flag to True to force stop running compute instance prior to move.
+	// Required: false
+	ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
+}
+
+// MoveToRG moves compute instance to new resource group
+func (c Compute) Validate(ctx context.Context, req MoveToRGRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/moveToRg"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/net_attach.go

@@ -0,0 +1,62 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// NetAttachRequest struct to attach network
+type NetAttachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Network type
+	// 'EXTNET' for connect to external network directly
+	// 'VINS' for connect to ViNS
+	// 'VFNIC' for connect to vfpool
+	// 'DPDK' for connect to DPDK
+	// Required: true
+	NetType string `url:"netType" json:"netType" validate:"computex86NetType"`
+
+	// Network ID for connect to
+	// For EXTNET - external network ID
+	// For VINS - VINS ID
+	// Required: true
+	NetID uint64 `url:"netId" json:"netId" validate:"required"`
+
+	// Directly required IP address for new network interface
+	// Required: true
+	IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"`
+
+	// Used only for DPDK type, must be 1-9216
+	// Required: false
+	MTU uint64 `url:"mtu,omitempty" json:"mtu,omitempty" validate:"omitempty,mtu"`
+}
+
+// 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)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordNetAttach{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudbroker/compute/net_detach.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// NetDetachRequest struct to detach network from compute
+type NetDetachRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// IP of the network interface
+	// Required: false
+	IPAddr string `url:"ipAddr,omitempty" json:"ipAddr,omitempty"`
+
+	// MAC of the network interface
+	// Required: false
+	MAC string `url:"mac,omitempty" json:"mac,omitempty"`
+}
+
+// NetDetach detaches network from compute
+func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/netDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/net_qos.go

@@ -0,0 +1,61 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// NetQOSRequest struct for update QOS
+type NetQOSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Network ID
+	// Required: true
+	NetID uint64 `url:"netId" json:"netId" validate:"required"`
+
+	// Network type
+	// Should be one of:
+	//	- VINS
+	//	- EXTNET
+	// Required: true
+	NetType string `url:"netType" json:"netType" validate:"computeNetType"`
+
+	// Internal traffic, kbit
+	// Required: false
+	IngressRate uint64 `url:"ingress_rate,omitempty" json:"ingress_rate,omitempty"`
+
+	// Internal traffic burst, kbit
+	// Required: false
+	IngressBurst uint64 `url:"ingress_burst,omitempty" json:"ingress_burst,omitempty"`
+
+	// External traffic rate, kbit
+	// Required: false
+	EgressRate uint64 `url:"egress_rate,omitempty" json:"egress_rate,omitempty"`
+}
+
+// NetQOS updates compute interfaces QOS
+func (c Compute) NetQOS(ctx context.Context, req NetQOSRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/netQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/pause.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PauseRequest struct to pause compute
+type PauseRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Pause pause compute
+func (c Compute) Pause(ctx context.Context, req PauseRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/pause"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/pfw_add.go

@@ -0,0 +1,58 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PFWAddRequest struct to add port forward rule
+type PFWAddRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// External start port number for the rule
+	// Required: true
+	PublicPortStart uint64 `url:"publicPortStart" json:"publicPortStart" validate:"required"`
+
+	// End port number (inclusive) for the ranged rule
+	// Default value: -1
+	// Required: false
+	PublicPortEnd int64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"`
+
+	// Internal base port number
+	// Required: false
+	LocalBasePort uint64 `url:"localBasePort,omitempty" json:"localBasePort,omitempty"`
+
+	// Network protocol
+	// Should be one of:
+	//	- tcp
+	//	- udp
+	// Required: true
+	Proto string `url:"proto" json:"proto" validate:"proto"`
+}
+
+// PFWAdd adds port forward rule
+func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/pfwAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/pfw_del.go

@@ -0,0 +1,61 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PFWDelRequest struct to delete port forward rule
+type PFWDelRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the rule to delete. If specified, all other arguments will be ignored
+	// Required: false
+	RuleID uint64 `url:"ruleId,omitempty" json:"ruleId,omitempty"`
+
+	// External start port number for the rule
+	// Required: false
+	PublicPortStart uint64 `url:"publicPortStart,omitempty" json:"publicPortStart,omitempty"`
+
+	// End port number (inclusive) for the ranged rule
+	// Required: false
+	PublicPortEnd uint64 `url:"publicPortEnd,omitempty" json:"publicPortEnd,omitempty"`
+
+	// Internal base port number
+	// Required: false
+	LocalBasePort uint64 `url:"localBasePort,omitempty" json:"localBasePort,omitempty"`
+
+	// Network protocol
+	// Should be one of:
+	//	- tcp
+	//	- udp
+	// Required: false
+	Proto string `url:"proto,omitempty" json:"proto,omitempty" validate:"omitempty,proto"`
+}
+
+// PFWDel deletes port forward rule
+func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/pfw_list.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PFWListRequest struct to get list of port forwards
+type PFWListRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// PFWList gets compute port forwards list
+func (c Compute) PFWList(ctx context.Context, req PFWListRequest) (*ListPFW, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/pfwList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListPFW{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/pin_to_stack.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PinToStackRequest struct to pin compute to stack
+type PinToStackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Stack ID to pin to
+	// Required: false
+	TargetStackID uint64 `url:"targetStackId" json:"targetStackId"`
+
+	// Try to migrate or not if compute in running states
+	// Required: false
+	Force bool `url:"force" json:"force"`
+}
+
+// PinToStack pins compute to current stack
+func (c Compute) PinToStack(ctx context.Context, req PinToStackRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/pinToStack"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseUint(string(res), 10, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/power_cycle.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// PowerCycleRequest struct to force stop and start compute
+type PowerCycleRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// PowerCycle makes force stop and start compute
+func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/powerCycle"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/raise_down.go

@@ -0,0 +1,24 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+)
+
+// RaiseDown starting all computes in "DOWN" tech status
+func (c Compute) RaiseDown(ctx context.Context) (bool, error) {
+	url := "/cloudbroker/compute/raiseDown"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, nil)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/reboot.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RebootRequest struct to reboot compute
+type RebootRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Reboot reboots compute
+func (c Compute) Reboot(ctx context.Context, req RebootRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/reboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/redeploy.go

@@ -0,0 +1,62 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RedeployRequest struct for redeploy
+type RedeployRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the new OS image, if image change is required
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
+
+	// New size for the boot disk in GB, if boot disk size change is required
+	// Required: false
+	DiskSize uint64 `url:"diskSize,omitempty" json:"diskSize,omitempty"`
+
+	// How to handle data disks connected to this compute instance
+	// Should be one of:
+	//	- KEEP
+	//	- DETACH
+	//	- DESTROY
+	// Required: false
+	DataDisks string `url:"dataDisks,omitempty" json:"dataDisks,omitempty" validate:"omitempty,computeDataDisks"`
+
+	// Should the compute be restarted upon successful redeploy
+	// Required: false
+	AutoStart bool `url:"autoStart,omitempty" json:"autoStart,omitempty"`
+
+	// Set this flag to True to force stop running compute instance and redeploy next
+	// Required: false
+	ForceStop bool `url:"forceStop,omitempty" json:"forceStop,omitempty"`
+}
+
+// Redeploy redeploys compute
+func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/redeploy"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/registration.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RegistrationRequest struct to set compute registered in RT
+type RegistrationRequest struct {
+	// ID of the Compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Unique compute registration key
+	// Required: true
+	RegistrationKey string `url:"registrationKey" json:"registrationKey" validate:"required"`
+}
+
+// Registration sets compute registered in RT
+func (c Compute) Registration(ctx context.Context, req RegistrationRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/registration"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/repair_boot_fs.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RepairBootFSRequest struct to repair filesystem
+type RepairBootFSRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// RepairBootFS repairs compute boot disk filesystem
+func (c Compute) RepairBootFS(ctx context.Context, req RepairBootFSRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/repairBootFs"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/reset.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ResetRequest struct to reset compute
+type ResetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Reset resets compute
+func (c Compute) Reset(ctx context.Context, req ResetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/reset"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/resize.go

@@ -0,0 +1,62 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ResizeRequest struct to resize compute
+type ResizeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// New CPU count.
+	// Pass 0 if no change to CPU count is required
+	// Required: false
+	CPU uint64 `url:"cpu,omitempty" json:"cpu,omitempty"`
+
+	// New RAM volume in MB.
+	// Pass 0 if no change to RAM volume is required
+	// Required: false
+	RAM uint64 `url:"ram,omitempty" json:"ram,omitempty"`
+
+	// Force compute resize
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+}
+
+// GetRAM returns RAM field values
+func (r ResizeRequest) GetRAM() map[string]uint64 {
+
+	res := make(map[string]uint64, 1)
+
+	res["RAM"] = r.RAM
+
+	return res
+}
+
+// Resize resizes compute instance
+func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/resize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/restore.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RestoreRequest struct to restore compute
+type RestoreRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Restore restores compute from recycle bin
+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))
+	}
+
+	url := "/cloudbroker/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/resume.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ResumeRequest struct to resume compute
+type ResumeRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Resume resumes Compute from paused state
+func (c Compute) Resume(ctx context.Context, req ResumeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/resume"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/serialize.go

@@ -0,0 +1,43 @@
+package compute
+
+import (
+	"encoding/json"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/serialization"
+)
+
+// Serialize returns JSON-serialized []byte. Used as a wrapper over json.Marshal and json.MarshalIndent functions.
+//
+// In order to serialize with indent make sure to follow these guidelines:
+//   - First argument -> prefix
+//   - Second argument -> indent
+func (lc ListComputes) Serialize(params ...string) (serialization.Serialized, error) {
+	if len(lc.Data) == 0 {
+		return []byte{}, nil
+	}
+
+	if len(params) > 1 {
+		prefix := params[0]
+		indent := params[1]
+
+		return json.MarshalIndent(lc, prefix, indent)
+	}
+
+	return json.Marshal(lc)
+}
+
+// Serialize returns JSON-serialized []byte. Used as a wrapper over json.Marshal and json.MarshalIndent functions.
+//
+// In order to serialize with indent make sure to follow these guidelines:
+//   - First argument -> prefix
+//   - Second argument -> indent
+func (ic ItemCompute) Serialize(params ...string) (serialization.Serialized, error) {
+	if len(params) > 1 {
+		prefix := params[0]
+		indent := params[1]
+
+		return json.MarshalIndent(ic, prefix, indent)
+	}
+
+	return json.Marshal(ic)
+}

pkg/cloudbroker/compute/set_custom_fields.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SetCustomFieldsRequest struct for setting customFields values for the Compute
+type SetCustomFieldsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Custom fields for Compute. Must be dict.
+	// Required: true
+	CustomFields string `url:"customFields" json:"customFields" validate:"required"`
+}
+
+// SetCustomFields sets customFields values for the Compute
+func (c Compute) SetCustomFields(ctx context.Context, req SetCustomFieldsRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/setCustomFields"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/set_net_config.go

@@ -0,0 +1,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SetNetConfigRequest struct to Configure libvirt virtio interface parameters
+type SetNetConfigRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Interface MAC-address
+	// Required: true
+	MAC string `url:"mac" json:"mac" validate:"required"`
+
+	// TXMode, must be 'iothread', 'timer' or 'selected by hypervisor'
+	// Required: false
+	TXMode string `url:"txmode,omitempty" json:"txmode,omitempty" validate:"omitempty,interfaceTXModel"`
+
+	// IOEventFD, must be 'on', 'off' or 'selected by hypervisor'
+	// Required: false
+	IOEventFD string `url:"ioeventfd,omitempty" json:"ioeventfd,omitempty" validate:"omitempty,interfaceIOEventFD"`
+
+	// EventIDx, must be 'on', 'off' or 'selected by hypervisor'
+	// Required: false
+	EventIDx string `url:"event_idx,omitempty" json:"event_idx,omitempty" validate:"omitempty,interfaceEventIDx"`
+
+	// Number of queues
+	// Required: false
+	Queues uint64 `url:"queues,omitempty" json:"queues,omitempty"`
+
+	// RX queue size
+	// Required: false
+	RXQueueSize uint64 `url:"rx_queue_size,omitempty" json:"rx_queue_size,omitempty"`
+
+	// TX queue size
+	// Required: false
+	TXQueueSize uint64 `url:"tx_queue_size,omitempty" json:"tx_queue_size,omitempty"`
+}
+
+// Configure libvirt virtio interface parameters
+func (c Compute) SetNetConfig(ctx context.Context, req SetNetConfigRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/setNetConfig"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/snapshot_create.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotCreateRequest struct to create snapshot
+type SnapshotCreateRequest struct {
+	// ID of the compute instance to create snapshot for
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Text label for snapshot.
+	// Must be unique among this compute snapshots
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+// 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))
+	}
+
+	url := "/cloudbroker/compute/snapshotCreate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudbroker/compute/snapshot_delete.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotDeleteRequest struct to delete snapshot
+type SnapshotDeleteRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Text label of snapshot to delete
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+type wrapperSnapshotDeleteRequest struct {
+	SnapshotDeleteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// SnapshotDelete deletes specified compute snapshot
+func (c Compute) SnapshotDelete(ctx context.Context, req SnapshotDeleteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotDeleteRequest{
+		SnapshotDeleteRequest: req,
+		AsyncMode:             false,
+	}
+
+	url := "/cloudbroker/compute/snapshotDelete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// SnapshotDeleteAsync deletes specified compute snapshot with AsyncMode
+func (c Compute) SnapshotDeleteAsync(ctx context.Context, req SnapshotDeleteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotDeleteRequest{
+		SnapshotDeleteRequest: req,
+		AsyncMode:             true,
+	}
+
+	url := "/cloudbroker/compute/snapshotDelete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/snapshot_evict_disk.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotEvictDiskRequest struct to evict specified disk
+type SnapshotEvictDiskRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk instance
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+}
+
+// SnapshotEvictDisk evicts specified disk from all snapshots of a compute instance
+func (c Compute) SnapshotEvictDisk(ctx context.Context, req SnapshotEvictDiskRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/snapshotEvictDisk"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/snapshot_list.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotListRequest struct to get list of snapshots
+type SnapshotListRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// SnapshotList gets list of compute snapshots
+func (c Compute) SnapshotList(ctx context.Context, req SnapshotListRequest) (*ListSnapShot, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/snapshotList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListSnapShot{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/snapshot_rollback.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotRollbackRequest struct for rollback
+type SnapshotRollbackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Text label of snapshot to rollback
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+// SnapshotRollback rollbacks specified compute snapshot
+func (c Compute) SnapshotRollback(ctx context.Context, req SnapshotRollbackRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/snapshotRollback"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/snapshot_usage.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotUsageRequest struct tto get compute snapshot real size on storage
+type SnapshotUsageRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Specify to show usage exact for this snapshot.
+	// Leave empty for get usage for all compute snapshots
+	// Required: false
+	Label string `url:"label,omitempty" json:"label,omitempty"`
+}
+
+// SnapshotUsage gets compute snapshot real size on storage.
+// Always returns list of json objects, and first json object contains summary about all related
+// snapshots.
+func (c Compute) SnapshotUsage(ctx context.Context, req SnapshotUsageRequest) (ListSnapshotUsage, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/snapshotUsage"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListSnapshotUsage{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudbroker/compute/sorting.go

@@ -0,0 +1,98 @@
+package compute
+
+import "sort"
+
+// SortByCPU sorts ListComputes by the CPU core amount in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lc ListComputes) SortByCPU(inverse bool) ListComputes {
+	if len(lc.Data) < 2 {
+		return lc
+	}
+
+	sort.Slice(lc.Data, func(i, j int) bool {
+		if inverse {
+			return lc.Data[i].CPUs > lc.Data[j].CPUs
+		}
+
+		return lc.Data[i].CPUs < lc.Data[j].CPUs
+	})
+
+	return lc
+}
+
+// SortByRAM sorts ListComputes by the RAM amount in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lc ListComputes) SortByRAM(inverse bool) ListComputes {
+	if len(lc.Data) < 2 {
+		return lc
+	}
+
+	sort.Slice(lc.Data, func(i, j int) bool {
+		if inverse {
+			return lc.Data[i].RAM > lc.Data[j].RAM
+		}
+
+		return lc.Data[i].RAM < lc.Data[j].RAM
+	})
+
+	return lc
+}
+
+// SortByCreatedTime sorts ListComputes by the CreatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lc ListComputes) SortByCreatedTime(inverse bool) ListComputes {
+	if len(lc.Data) < 2 {
+		return lc
+	}
+
+	sort.Slice(lc.Data, func(i, j int) bool {
+		if inverse {
+			return lc.Data[i].CreatedTime > lc.Data[j].CreatedTime
+		}
+
+		return lc.Data[i].CreatedTime < lc.Data[j].CreatedTime
+	})
+
+	return lc
+}
+
+// SortByUpdatedTime sorts ListComputes by the UpdatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lc ListComputes) SortByUpdatedTime(inverse bool) ListComputes {
+	if len(lc.Data) < 2 {
+		return lc
+	}
+
+	sort.Slice(lc.Data, func(i, j int) bool {
+		if inverse {
+			return lc.Data[i].UpdatedTime > lc.Data[j].UpdatedTime
+		}
+
+		return lc.Data[i].UpdatedTime < lc.Data[j].UpdatedTime
+	})
+
+	return lc
+}
+
+// SortByDeletedTime sorts ListComputes by the DeletedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lc ListComputes) SortByDeletedTime(inverse bool) ListComputes {
+	if len(lc.Data) < 2 {
+		return lc
+	}
+
+	sort.Slice(lc.Data, func(i, j int) bool {
+		if inverse {
+			return lc.Data[i].DeletedTime > lc.Data[j].DeletedTime
+		}
+
+		return lc.Data[i].DeletedTime < lc.Data[j].DeletedTime
+	})
+
+	return lc
+}

pkg/cloudbroker/compute/start.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// StartRequest struct to start compute
+type StartRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of CD-ROM live image to boot
+	// Required: false
+	AltBootID uint64 `url:"altBootId,omitempty" json:"altBootId,omitempty"`
+
+	// ID of stack to start compute
+	// Required: false
+	StackID uint64 `url:"stackId,omitempty" json:"stackId,omitempty"`
+}
+
+// Start starts compute
+func (c Compute) Start(ctx context.Context, req StartRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/start"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/stop.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// StopRequest struct to stop compute
+type StopRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Force stop compute
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+
+	// whether to depresent compute disks from node or not
+	// Default: true
+	// Required: false
+	Depresent bool `url:"depresent" json:"depresent"`
+}
+
+// Stop stops compute
+func (c Compute) Stop(ctx context.Context, req StopRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/stop"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/tag_add.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// TagAddRequest struct to add tag to compute
+type TagAddRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Tag key
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+
+	// Tag value
+	// Required: true
+	Value string `url:"value" json:"value" validate:"required"`
+}
+
+// TagAdd adds tag to compute tags dict
+func (c Compute) TagAdd(ctx context.Context, req TagAddRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/tagAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/tag_remove.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// TagRemoveRequest struct to remove tag from compute
+type TagRemoveRequest struct {
+	// IDs of the compute instances
+	// Required: true
+	ComputeIDs []uint64 `url:"computeIds" json:"computeIds" validate:"min=1"`
+
+	// Tag key
+	// Required: true
+	Key string `url:"key" json:"key" validate:"required"`
+}
+
+// TagRemove removes tag from compute tags dict
+func (c Compute) TagRemove(ctx context.Context, req TagRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/tagRemove"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/unpin_from_stack.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UnpinFromStackRequest struct to unpin from stack
+type UnpinFromStackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// UnpinFromStack unpins compute from current stack
+func (c Compute) UnpinFromStack(ctx context.Context, req UnpinFromStackRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/unpinFromStack"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/update.go

@@ -0,0 +1,68 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UpdateRequest struct to update compute
+type UpdateRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// New name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// New description
+	// Required: false
+	Description string `url:"desc,omitempty" json:"desc,omitempty"`
+
+	// Rule for VM placement with NUMA affinity.
+	// Possible values - none (placement without NUMA affinity),
+	// strict (strictly with NUMA affinity, if not possible - do not start VM),
+	// loose (use NUMA affinity if possible)
+	// Required: false
+	// Default: none
+	NumaAffinity string `url:"numaAffinity,omitempty" json:"numaAffinity,omitempty" validate:"omitempty,numaAffinity"`
+
+	// Run VM on dedicated CPUs. To use this feature, the system must be pre-configured by allocating CPUs on the physical node
+	// Required: false
+	// Default: false
+	CPUPin bool `url:"cpupin" json:"cpupin"`
+
+	// Type of the emulated system, Q35 or i440fx
+	// Required: false
+	Chipset string `url:"chipset,omitempty" json:"chipset,omitempty" validate:"omitempty,chipset"`
+
+	// Use Huge Pages to allocate RAM of the virtual machine. The system must be pre-configured by allocating Huge Pages on the physical node
+	// Required: false
+	// Default: false
+	HPBacked bool `url:"hpBacked" json:"hpBacked"`
+}
+
+// Update updates some properties of the compute
+func (c Compute) Update(ctx context.Context, req UpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/user_grant.go

@@ -0,0 +1,50 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UserGrantRequest struct to grant access to compute
+type UserGrantRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the user to add
+	// Required: true
+	Username string `url:"userName" json:"userName" validate:"required"`
+
+	// Access type
+	// Should be one of:
+	//	- 'R' for Read only
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype" json:"accesstype" validate:"accessType"`
+}
+
+// UserGrant grants user access to the compute
+func (c Compute) UserGrant(ctx context.Context, req UserGrantRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/userGrant"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/user_list.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UserListRequest struct to get list of users for compute
+type UserListRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// UserList gets users list for compute
+func (c Compute) UserList(ctx context.Context, req UserListRequest) (*ListUsers, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/userList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListUsers{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}