git test

pkg/cloudbroker/compute/abort_shared_snapshot_merge.go

@@ -0,0 +1,68 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// AbortSharedSnapshotMergeRequest struct to abort shared snapshots merge
+type AbortSharedSnapshotMergeRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Label of the snapshot
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+type wrapperAbortSharedSnapshotMergeRequest struct {
+	AbortSharedSnapshotMergeRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// AbortSharedSnapshotMerge shared snapshots merge abort
+func (c Compute) AbortSharedSnapshotMerge(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
+		AbortSharedSnapshotMergeRequest: req,
+		AsyncMode:                       false,
+	}
+
+	url := "/cloudbroker/compute/abort_shared_snapshot_merge"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// AbortSharedSnapshotMergeAsync shared snapshots merge abort in async mode
+func (c Compute) AbortSharedSnapshotMergeAsync(ctx context.Context, req AbortSharedSnapshotMergeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperAbortSharedSnapshotMergeRequest{
+		AbortSharedSnapshotMergeRequest: req,
+		AsyncMode:                       true,
+	}
+
+	url := "/cloudbroker/compute/abort_shared_snapshot_merge"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

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/v15/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/v15/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/v15/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/v15/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,67 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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: true
+	Value string `url:"value" json:"value" validate:"required"`
+}
+
+// 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,65 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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: true
+	Value string `url:"value" json:"value" validate:"required"`
+}
+
+// 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/v15/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,65 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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: true
+	Value string `url:"value" json:"value" validate:"required"`
+}
+
+// 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/v15/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,65 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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: true
+	Value string `url:"value" json:"value" validate:"required"`
+}
+
+// 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/v15/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/v15/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,76 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// AuditsRequest struct to get audit records
+type AuditsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Find all audits after point in time
+	// Required: false
+	TimestampAT uint64 `url:"timestamp_at,omitempty" json:"timestamp_at,omitempty"`
+
+	// Find all audits before point in time
+	// Required: false
+	TimestampTO uint64 `url:"timestamp_to,omitempty" json:"timestamp_to,omitempty"`
+
+	// Find by user
+	// Required: false
+	User string `url:"user,omitempty" json:"user,omitempty"`
+
+	// Find by api endpoints
+	// Required: false
+	Call string `url:"call,omitempty" json:"call,omitempty"`
+
+	// Sort by one of supported fields, format ±<field>
+	// Required: false
+	SortBy string `url:"sort_by,omitempty" json:"sort_by,omitempty"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+
+	// Find by HTTP min status code
+	// Required: false
+	MinStatusCode uint64 `url:"min_status_code,omitempty" json:"min_status_code,omitempty"`
+
+	// Find by HTTP max status code
+	// Required: false
+	MaxStatusCode uint64 `url:"max_status_code,omitempty" json:"max_status_code,omitempty"`
+}
+
+// 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.MethodGet, 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/v15/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/v15/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/v15/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,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperCDEjectRequest struct {
+	CDEjectRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperCDEjectRequest{
+		CDEjectRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudbroker/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, err
+}
+
+// CDEjectAsync ejects CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDEjectAsync(ctx context.Context, req CDEjectRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDEjectRequest{
+		CDEjectRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudbroker/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/cd_insert.go

@@ -0,0 +1,69 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperCDInsertRequest struct {
+	CDInsertRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperCDInsertRequest{
+		CDInsertRequest: req,
+		AsyncMode:       false,
+	}
+
+	url := "/cloudbroker/compute/cdInsert"
+
+	_, err = c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+// CDInsertAsync inserts new CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDInsertAsync(ctx context.Context, req CDInsertRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDInsertRequest{
+		CDInsertRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudbroker/compute/cdInsert"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/change_ip.go

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

pkg/cloudbroker/compute/change_link_state.go

@@ -0,0 +1,80 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperChangeLinkStateRequest struct {
+	ChangeLinkStateRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// ChangeLinkState changes the status link virtual of compute
+func (c Compute) ChangeLinkState(ctx context.Context, req ChangeLinkStateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeLinkStateRequest{
+		ChangeLinkStateRequest: req,
+		AsyncMode:              false,
+	}
+
+	url := "/cloudbroker/compute/changeLinkState"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// ChangeLinkStateAsync changes the status link virtual of compute with AsyncMode
+func (c Compute) ChangeLinkStateAsync(ctx context.Context, req ChangeLinkStateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeLinkStateRequest{
+		ChangeLinkStateRequest: req,
+		AsyncMode:              true,
+	}
+
+	url := "/cloudbroker/compute/changeLinkState"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/change_mac.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// ChangeMACRequest struct to change MAC for network
+type ChangeMACRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Current mac address
+	// Required: true
+	СurrentMAC string `url:"current_mac_address" json:"current_mac_address" validate:"required"`
+
+	// the MAC address to which we will change the existing one
+	// Required: true
+	NewMAC string `url:"new_mac_address" json:"new_mac_address" validate:"required"`
+}
+
+// ChangeMAC change MAC for compute instance
+func (c Compute) ChangeMAC(ctx context.Context, req ChangeMACRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/changeMac"
+
+	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_mtu.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// ChangeMTURequest struct to change MTU for a compute
+type ChangeMTURequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Interface name or MAC address
+	// Required: true
+	Interface string `url:"interface" json:"interface" validate:"required"`
+
+	// Maximum transmission unit
+	// Required: true
+	MTU uint64 `url:"mtu" json:"mtu" validate:"required" validate:"omitempty,mtu"`
+}
+
+type wrapperChangeMTURequest struct {
+	ChangeMTURequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// ChangeMTU change MTU for compute instance
+func (c Compute) ChangeMTU(ctx context.Context, req ChangeMTURequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeMTURequest{
+		ChangeMTURequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudbroker/compute/change_mtu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// ChangeMTUAsync change MTU for compute instance with AsyncMode
+func (c Compute) ChangeMTUAsync(ctx context.Context, req ChangeMTURequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeMTURequest{
+		ChangeMTURequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudbroker/compute/change_mtu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/change_read_only.go

@@ -0,0 +1,41 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// ChangeReadOnlyRequest defines parameters for toggling read-only mode.
+type ChangeReadOnlyRequest struct {
+	// Compute ID
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// ReadOnly indicates whether the read-only mode is enabled
+	// Required: true
+	ReadOnly bool `url:"read_only" json:"read_only" validate:"required"`
+}
+
+// ChangeReadOnly toggles compute read-only mode.
+func (c Compute) ChangeReadOnly(ctx context.Context, req ChangeReadOnlyRequest) (bool, error) {
+	if err := validators.ValidateRequest(req); err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/change_read_only"
+
+	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_secutity_group.go

@@ -0,0 +1,83 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// ChangeSecGroupsRequest struct to change security groups for compute
+type ChangeSecGroupsRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Interface name or MAC address
+	// Required: true
+	Interface string `url:"interface" json:"interface" validate:"required"`
+
+	// List of security group IDs to assign to this interface
+	// Required: false
+	SecGroups []uint64 `url:"security_groups,omitempty" json:"security_groups,omitempty"`
+
+	// Flag indicating whether security groups are enabled for this interface
+	// Required: false
+	EnableSecGroups interface{} `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty" validate:"omitempty,isBool"`
+}
+
+type wrapperChangeSecGroupsRequest struct {
+	ChangeSecGroupsRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// ChangeSecGroups changes security groups for compute
+func (c Compute) ChangeSecGroups(ctx context.Context, req ChangeSecGroupsRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeSecGroupsRequest{
+		ChangeSecGroupsRequest: req,
+		AsyncMode:              false,
+	}
+
+	url := "/cloudbroker/compute/change_security_groups"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// ChangeSecGroupsAsync changes security groups for compute with AsyncMode
+func (c Compute) ChangeSecGroupsAsync(ctx context.Context, req ChangeSecGroupsRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperChangeSecGroupsRequest{
+		ChangeSecGroupsRequest: req,
+		AsyncMode:              true,
+	}
+
+	url := "/cloudbroker/compute/change_security_groups"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/check_compute_placement.go

@@ -0,0 +1,47 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// CheckComputePlacementRequest struct for check compute placement
+type CheckComputePlacementRequest struct {
+	// IDs of compute instances to check
+	// Required: true
+	ComputeIDs []uint64 `url:"compute_ids" json:"compute_ids" validate:"required"`
+
+	// Filter by CPU and RAM when checking placement
+	// Required: false
+	// Default: true
+	FilterByCPURAM interface{} `url:"filter_by_cpu_ram,omitempty" json:"filter_by_cpu_ram,omitempty" validate:"omitempty,isBool"`
+}
+
+// CheckComputePlacement checks compute placement and returns structured result
+func (c Compute) CheckComputePlacement(ctx context.Context, req CheckComputePlacementRequest) (CheckComputePlacementResult, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/check_compute_placement"
+
+	if req.FilterByCPURAM == nil {
+		req.FilterByCPURAM = true
+	}
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make(CheckComputePlacementResult)
+	if err := json.Unmarshal(res, &result); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/clone.go

@@ -0,0 +1,95 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/constants"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+
+	// ID of the Storage Policy
+	// Required: true
+	StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" 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"`
+
+	// The name of the pool to migrate disks to
+	// Required: false
+	PoolName string `url:"pool_name" json:"pool_name"`
+
+	// The ID of the SEP to migrate disks to
+	// Required: false
+	SEPID uint64 `url:"sep_id" json:"sep_id"`
+}
+
+type wrapperCloneRequest struct {
+	CloneRequest
+
+	AsyncMode bool `url:"asyncMode" json:"asyncMode"`
+}
+
+// Clone clones compute instance
+func (c Compute) Clone(ctx context.Context, req CloneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCloneRequest{
+		CloneRequest: req,
+		AsyncMode:    false,
+	}
+
+	url := "/cloudbroker/compute/clone"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// CloneAsync clones compute instance with AsyncMode
+func (c Compute) CloneAsync(ctx context.Context, req CloneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCloneRequest{
+		CloneRequest: req,
+		AsyncMode:    true,
+	}
+
+	url := "/cloudbroker/compute/clone"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/clone_abort.go

@@ -0,0 +1,41 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/constants"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// CloneAbortRequest struct to abort a compute clone
+type CloneAbortRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+// CloneAbort aborts a compute clone
+func (c Compute) CloneAbort(ctx context.Context, req CloneAbortRequest) ([]RecordCloneAbort, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/clone_abort"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]RecordCloneAbort, 0)
+
+	err = json.Unmarshal(res, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

pkg/cloudbroker/compute/clone_status.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GetCloneStatusRequest struct to get information about compute clone status
+type GetCloneStatusRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID string `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+// GetCloneStatus gets information about compute clone status as a RecordCloneStatus struct
+func (c Compute) GetCloneStatus(ctx context.Context, req GetCloneStatusRequest) ([]RecordCloneStatus, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/clone_status"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	cloneStatus := make([]RecordCloneStatus, 0)
+
+	err = json.Unmarshal(res, &cloneStatus)
+	if err != nil {
+		return nil, err
+	}
+
+	return cloneStatus, 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/v15/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/v15/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/v15/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,72 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+// CreateTemplate create template from compute instance
+func (c Compute) CreateTemplate(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:             false,
+	}
+
+	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
+}
+
+// CreateTemplateAsync create template from compute instance with AsyncMode
+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
+	}
+
+	return string(res), 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/v15/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"`
+
+	// Storage policy id of compute. The rules of the specified storage policy will be used.
+	// Required: true
+	StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
+
+	// 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"`
+
+	// 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,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDeleteRequest struct {
+	DeleteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Delete deletes compute
+func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDeleteRequest{
+		DeleteRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudbroker/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DeleteAsync deletes compute with AsyncMode
+func (c Compute) DeleteAsync(ctx context.Context, req DeleteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDeleteRequest{
+		DeleteRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudbroker/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/delete_cpu_alignment_profile.go

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

pkg/cloudbroker/compute/delete_custom_fields.go

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

pkg/cloudbroker/compute/disk_add.go

@@ -0,0 +1,121 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+
+	// Storage policy id of compute. The rules of the specified storage policy will be used.
+	// Required: true
+	StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
+
+	// 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"`
+
+	// Desired PCI slot (hex string, e.g. "0x1A")
+	// Required: false
+	PCISlot string `url:"pci_slot,omitempty" json:"pci_slot,omitempty"`
+
+	// Desired bus number (hex string, e.g. "0x03")
+	// Required: false
+	BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
+
+	// Disk cache mode
+	// Required: false
+	Cache string `url:"cache,omitempty" json:"cache,omitempty"`
+
+	// Discard
+	// Required: false
+	Discard string `url:"discard,omitempty" json:"discard,omitempty"`
+
+	// Mount disk in read-only mode
+	// Required: false
+	ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
+}
+
+type wrapperDiskAddRequest struct {
+	DiskAddRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// DiskAdd creates new disk and attach to compute
+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))
+	}
+
+	reqWrapped := wrapperDiskAddRequest{
+		DiskAddRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudbroker/compute/diskAdd"
+
+	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
+}
+
+// DiskAddAsync creates new disk and attach to compute with AsyncMode
+func (c Compute) DiskAddAsync(ctx context.Context, req DiskAddRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskAddRequest{
+		DiskAddRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudbroker/compute/diskAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/disk_attach.go

@@ -0,0 +1,87 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+
+	// Desired PCI slot (hex string, e.g. "0x1A")
+	// Required: false
+	PCISlot string `url:"pci_slot,omitempty" json:"pci_slot,omitempty"`
+
+	// Desired bus number (hex string, e.g. "0x03")
+	// Required: false
+	BusNumber string `url:"bus_number,omitempty" json:"bus_number,omitempty"`
+
+	// Mount disk in read-only mode
+	// Required: false
+	ReadOnly bool `url:"read_only,omitempty" json:"read_only,omitempty"`
+}
+
+type wrapperDiskAttachRequest struct {
+	DiskAttachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// DiskAttach attach disk to compute
+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))
+	}
+
+	reqWrapped := wrapperDiskAttachRequest{
+		DiskAttachRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/diskAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskAttachAsync attach disk to compute with AsyncMode
+func (c Compute) DiskAttachAsync(ctx context.Context, req DiskAttachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskAttachRequest{
+		DiskAttachRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/diskAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/disk_del.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDiskDelRequest struct {
+	DiskDelRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperDiskDelRequest{
+		DiskDelRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudbroker/compute/diskDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskDelAsync deletes disk and detaches it from compute with AsyncMode
+func (c Compute) DiskDelAsync(ctx context.Context, req DiskDelRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskDelRequest{
+		DiskDelRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudbroker/compute/diskDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/disk_detach.go

@@ -0,0 +1,75 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDiskDetachRequest struct {
+	DiskDetachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperDiskDetachRequest{
+		DiskDetachRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/diskDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskDetachAsync detaches disk from compute with AsyncMode
+func (c Compute) DiskDetachAsync(ctx context.Context, req DiskDetachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskDetachRequest{
+		DiskDetachRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/diskDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), 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/v15/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,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDiskQOSRequest struct {
+	DiskQOSRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperDiskQOSRequest{
+		DiskQOSRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudbroker/compute/diskQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskQOSAsync changes QOS of the disk with AsyncMode
+func (c Compute) DiskQOSAsync(ctx context.Context, req DiskQOSRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskQOSRequest{
+		DiskQOSRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudbroker/compute/diskQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/disk_resize.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDiskResizeRequest struct {
+	DiskResizeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperDiskResizeRequest{
+		DiskResizeRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/diskResize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskResizeAsync changes disk size with AsyncMode
+func (c Compute) DiskResizeAsync(ctx context.Context, req DiskResizeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskResizeRequest{
+		DiskResizeRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/diskResize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/disk_switch_to_replication.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperDiskSwitchToReplicationRequest struct {
+	DiskSwitchToReplicationRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// DiskSwitchToReplication switches disk to it's replication
+func (c Compute) DiskSwitchToReplication(ctx context.Context, req DiskSwitchToReplicationRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskSwitchToReplicationRequest{
+		DiskSwitchToReplicationRequest: req,
+		AsyncMode:                      false,
+	}
+
+	url := "/cloudbroker/compute/diskSwitchToReplication"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// DiskSwitchToReplicationAsync switches disk to it's replication with AsyncMode
+func (c Compute) DiskSwitchToReplicationAsync(ctx context.Context, req DiskSwitchToReplicationRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskSwitchToReplicationRequest{
+		DiskSwitchToReplicationRequest: req,
+		AsyncMode:                      true,
+	}
+
+	url := "/cloudbroker/compute/diskSwitchToReplication"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/enable.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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,331 @@
+package compute
+
+import (
+	"context"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/interfaces"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/pkg/cloudbroker/k8s"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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]
+}
+
+// FilterByID returns ListDeletedComputes with specified ID.
+func (lc ListDeletedComputes) FilterByID(id uint64) ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		return ic.ID == id
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByName returns ListDeletedComputes with specified Name.
+func (lc ListDeletedComputes) FilterByName(name string) ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		return ic.Name == name
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByStatus returns ListDeletedComputes with specified Status.
+func (lc ListDeletedComputes) FilterByStatus(status string) ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		return ic.Status == status
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByTechStatus returns ListDeletedComputes with specified TechStatus.
+func (lc ListDeletedComputes) FilterByTechStatus(techStatus string) ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		return ic.TechStatus == techStatus
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByDiskID return ListDeletedComputes with specified DiskID.
+func (lc ListDeletedComputes) FilterByDiskID(diskID uint64) ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		for _, disk := range ic.Disks {
+			if disk.ID == diskID {
+				return true
+			}
+		}
+		return false
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByK8SID returns master and worker nodes (ListDeletedComputes) inside specified K8S cluster.
+func (lc ListDeletedComputes) FilterByK8SID(ctx context.Context, k8sID uint64, decortClient interfaces.Caller) (*ListDeletedComputes, 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 ItemDeletedCompute) 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 ListDeletedComputes) FilterByK8SMasters() ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) 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 ListDeletedComputes) FilterByK8SWorkers() ListDeletedComputes {
+	predicate := func(ic ItemDeletedCompute) bool {
+		for _, rule := range ic.AntiAffinityRules {
+			if rule.Value == "worker" {
+				return true
+			}
+		}
+		return false
+	}
+
+	return lc.FilterFunc(predicate)
+}
+
+// FilterByLBID is used to filter ListDeletedComputes used by specified Load Balancer.
+func (lc ListDeletedComputes) FilterByLBID(ctx context.Context, lbID uint64, decortClient interfaces.Caller) (*ListDeletedComputes, 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 ItemDeletedCompute) bool {
+		return ic.ID == foundLB.PrimaryNode.ComputeID || ic.ID == foundLB.SecondaryNode.ComputeID
+	}
+
+	result := lc.FilterFunc(predicate)
+
+	return &result, nil
+}
+
+// FilterFunc allows filtering ListDeletedComputes based on a user-specified predicate.
+func (lc ListDeletedComputes) FilterFunc(predicate func(ItemDeletedCompute) bool) ListDeletedComputes {
+	var result ListDeletedComputes
+
+	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 ItemDeletedCompute
+// If none was found, returns an empty struct.
+func (lc ListDeletedComputes) FindOne() ItemDeletedCompute {
+	if len(lc.Data) == 0 {
+		return ItemDeletedCompute{}
+	}
+
+	return lc.Data[0]
+}

pkg/cloudbroker/compute/filter_test.go

@@ -0,0 +1,481 @@
+package compute
+
+import (
+	"testing"
+)
+
+var computes = ListComputes{
+	Data: []ItemCompute{
+		{
+			Disks: []InfoDisk{
+				{
+					ID: 65191,
+				},
+			},
+			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,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363500,
+				Name:             "test",
+				PinnedToNode:     1,
+				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,
+			},
+		},
+		{
+			Disks: []InfoDisk{
+				{
+					ID: 65248,
+				},
+			},
+			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,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363853,
+				Name:             "compute_2",
+				PinnedToNode:     1,
+				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,
+			},
+		},
+	},
+	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)
+	}
+}
+
+var deleteComputes = ListDeletedComputes{
+	Data: []ItemDeletedCompute{
+		{
+			Disks: []InfoDisk{
+				{
+					ID: 65191,
+				},
+			},
+			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,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363500,
+				Name:             "test",
+				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,
+			},
+		},
+		{
+			Disks: []InfoDisk{
+				{
+					ID: 65248,
+				},
+			},
+			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,
+				Interfaces:       ListInterfaces{},
+				LockStatus:       "UNLOCKED",
+				ManagerID:        0,
+				ManagerType:      "",
+				MigrationJob:     0,
+				Milestones:       363853,
+				Name:             "compute_2",
+				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,
+			},
+		},
+	},
+	EntryCount: 2,
+}
+
+func TestFilterDeleteByID(t *testing.T) {
+	actual := deleteComputes.FilterByID(48500).FindOne()
+
+	if actual.ID != 48500 {
+		t.Fatal("expected ID 48500, found: ", actual.ID)
+	}
+
+	actualEmpty := deleteComputes.FilterByID(0)
+
+	if len(actualEmpty.Data) != 0 {
+		t.Fatal("expected empty, actual: ", len(actualEmpty.Data))
+	}
+}
+
+func TestFilterDeleteByName(t *testing.T) {
+	actual := deleteComputes.FilterByName("compute_2").FindOne()
+
+	if actual.Name != "compute_2" {
+		t.Fatal("expected compute with name 'test', found: ", actual.Name)
+	}
+}
+
+func TestFilterDeleteByStatus(t *testing.T) {
+	actual := deleteComputes.FilterByStatus("ENABLED")
+
+	for _, item := range actual.Data {
+		if item.Status != "ENABLED" {
+			t.Fatal("expected ENABLED status, found: ", item.Status)
+		}
+	}
+}
+
+func TestFilterDeleteByTechStatus(t *testing.T) {
+	actual := deleteComputes.FilterByTechStatus("STARTED").FindOne()
+
+	if actual.ID != 48556 {
+		t.Fatal("expected 48556 with STARTED techStatus, found: ", actual.ID)
+	}
+}
+
+func TestFilterDeleteByDiskID(t *testing.T) {
+	actual := deleteComputes.FilterByDiskID(65248).FindOne()
+
+	if actual.ID != 48556 {
+		t.Fatal("expected 48556 with DiskID 65248, found: ", actual.ID)
+	}
+}
+
+func TestFilterDeleteFunc(t *testing.T) {
+	actual := deleteComputes.FilterFunc(func(ic ItemDeletedCompute) 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 TestDeleteSortingByCreatedTime(t *testing.T) {
+	actual := deleteComputes.SortByCreatedTime(false)
+
+	if actual.Data[0].Name != "test" {
+		t.Fatal("expected 'test', found: ", actual.Data[0].Name)
+	}
+
+	actual = deleteComputes.SortByCreatedTime(true)
+	if actual.Data[0].Name != "compute_2" {
+		t.Fatal("expected 'compute_2', found: ", actual.Data[0].Name)
+	}
+}
+
+func TestDeleteSortingByCPU(t *testing.T) {
+	actual := deleteComputes.SortByCPU(false)
+
+	if actual.Data[0].CPUs != 4 {
+		t.Fatal("expected 4 CPU cores, found: ", actual.Data[0].CPUs)
+	}
+
+	actual = deleteComputes.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/v15/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/v15/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/v15/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_cpu_alignment_profile.go

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

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/v15/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/v15/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.MethodGet, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/guest_agent_disable.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GuestAgentDisableRequest struct to disable guest agent
+type GuestAgentDisableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+type wrapperGuestAgentDisableRequest struct {
+	GuestAgentDisableRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Disable guest agent at a specific compute
+func (c Compute) GuestAgentDisable(ctx context.Context, req GuestAgentDisableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentDisableRequest{
+		GuestAgentDisableRequest: req,
+		AsyncMode:                false,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// GuestAgentDisableAsync disables guest agent at a specific compute with AsyncMode
+func (c Compute) GuestAgentDisableAsync(ctx context.Context, req GuestAgentDisableRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentDisableRequest{
+		GuestAgentDisableRequest: req,
+		AsyncMode:                true,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/guest_agent_enable.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GuestAgentEnableRequest struct to enable guest agent
+type GuestAgentEnableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+type wrapperGuestAgentEnableRequest struct {
+	GuestAgentEnableRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Enable guest agent at a specific compute
+func (c Compute) GuestAgentEnable(ctx context.Context, req GuestAgentEnableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentEnableRequest{
+		GuestAgentEnableRequest: req,
+		AsyncMode:               false,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_enable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// GuestAgentEnableAsync enables guest agent at a specific compute with AsyncMode
+func (c Compute) GuestAgentEnableAsync(ctx context.Context, req GuestAgentEnableRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentEnableRequest{
+		GuestAgentEnableRequest: req,
+		AsyncMode:               true,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_enable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/guest_agent_execute.go

@@ -0,0 +1,81 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GuestAgentExecuteRequest struct to execute command from user to agent
+type GuestAgentExecuteRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+
+	// Custom command from user to agent
+	// Required: true
+	Command string `url:"command" json:"command" validate:"required"`
+
+	// Arguments to command
+	// Required: true
+	Arguments string `url:"arguments" json:"arguments" validate:"required"`
+}
+
+type wrapperGuestAgentExecuteRequest struct {
+	GuestAgentExecuteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Execute guest agent command
+func (c Compute) GuestAgentExecuteRequest(ctx context.Context, req GuestAgentExecuteRequest) (map[string]interface{}, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentExecuteRequest{
+		GuestAgentExecuteRequest: req,
+		AsyncMode:                false,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_execute"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return nil, err
+	}
+
+	var result map[string]interface{}
+
+	err = json.Unmarshal(res, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+// GuestAgentExecuteRequestAsync executes guest agent command with AsyncMode
+func (c Compute) GuestAgentExecuteRequestAsync(ctx context.Context, req GuestAgentExecuteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentExecuteRequest{
+		GuestAgentExecuteRequest: req,
+		AsyncMode:                true,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_execute"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/guest_agent_feature_get.go

@@ -0,0 +1,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GuestAgentFeatureGetRequest struct to feature get guest agent
+type GuestAgentFeatureGetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+// List of features
+func (c Compute) GuestAgentFeatureGet(ctx context.Context, req GuestAgentFeatureGetRequest) ([]string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/guest_agent_feature_get"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	features := make([]string, 0)
+
+	err = json.Unmarshal(res, &features)
+	if err != nil {
+		return nil, err
+	}
+
+	return features, nil
+}

pkg/cloudbroker/compute/guest_agent_feature_update.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// GuestAgentFeatureUpdateRequest struct to feature update guest agent
+type GuestAgentFeatureUpdateRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+type wrapperGuestAgentFeatureUpdateRequest struct {
+	GuestAgentFeatureUpdateRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Feature update guest agent
+func (c Compute) GuestAgentFeatureUpdate(ctx context.Context, req GuestAgentFeatureUpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
+		GuestAgentFeatureUpdateRequest: req,
+		AsyncMode:                      false,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_feature_update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// GuestAgentFeatureUpdateAsync feature updates guest agent with AsyncMode
+func (c Compute) GuestAgentFeatureUpdateAsync(ctx context.Context, req GuestAgentFeatureUpdateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperGuestAgentFeatureUpdateRequest{
+		GuestAgentFeatureUpdateRequest: req,
+		AsyncMode:                      true,
+	}
+
+	url := "/cloudbroker/compute/guest_agent_feature_update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/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,117 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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 node ID
+	// Required: false
+	NodeID uint64 `url:"node_id,omitempty" json:"node_id,omitempty"`
+
+	// Find by CD image ID
+	// Required: false
+	CDImageID uint64 `url:"cdImageId,omitempty" json:"cdImageId,omitempty"`
+
+	// Find by node name
+	// Required: false
+	NodeName string `url:"nodeName,omitempty" json:"nodeName,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"`
+
+	// Sort by zone id
+	// Default value: 0
+	// Required: false
+	ZoneID uint64 `url:"zone_id,omitempty" json:"zone_id,omitempty"`
+
+	// 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/v15/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) (*ListDeletedComputes, 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 := ListDeletedComputes{}
+
+	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/v15/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/v15/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,75 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMassDeleteRequest struct {
+	MassDeleteRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperMassDeleteRequest{
+		MassDeleteRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/massDelete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MassDeleteAsync starts jobs to delete several computes with AsyncMode
+func (c Compute) MassDeleteAsync(ctx context.Context, req MassDeleteRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMassDeleteRequest{
+		MassDeleteRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/massDelete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/mass_reboot.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMassRebootRequest struct {
+	MassRebootRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperMassRebootRequest{
+		MassRebootRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/massReboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MassRebootAsync starts jobs to reboot several computes with AsyncMode
+func (c Compute) MassRebootAsync(ctx context.Context, req MassRebootRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMassRebootRequest{
+		MassRebootRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/massReboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/mass_start.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMassStartRequest struct {
+	MassStartRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperMassStartRequest{
+		MassStartRequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudbroker/compute/massStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MassStartAsync starts jobs to start several computes with AsyncMode
+func (c Compute) MassStartAsync(ctx context.Context, req MassStartRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMassStartRequest{
+		MassStartRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudbroker/compute/massStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/mass_stop.go

@@ -0,0 +1,75 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMassStopRequest struct {
+	MassStopRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperMassStopRequest{
+		MassStopRequest: req,
+		AsyncMode:       false,
+	}
+
+	url := "/cloudbroker/compute/massStop"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MassStopAsync starts jobs to stop several computes with AsyncMode
+func (c Compute) MassStopAsync(ctx context.Context, req MassStopRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMassStopRequest{
+		MassStopRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudbroker/compute/massStop"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/migrate.go

@@ -0,0 +1,76 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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 Node ID to migrate this compute to
+	// Required: false
+	TargetNodeID uint64 `url:"targetNodeId,omitempty" json:"targetNodeId,omitempty"`
+}
+
+type AsyncWrapperMigrateRequest struct {
+	MigrateRequest
+	SyncMode bool `url:"sync"`
+}
+
+// Migrate migrates compute to another node
+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"
+
+	syncReq := AsyncWrapperMigrateRequest{MigrateRequest: req, SyncMode: true}
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, syncReq)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// AsyncMigrate migrates compute to another node in async mode
+func (c Compute) AsyncMigrate(ctx context.Context, req MigrateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrate"
+
+	asyncReq := AsyncWrapperMigrateRequest{MigrateRequest: req, SyncMode: false}
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, asyncReq)
+	if err != nil {
+		return " ", err
+	}
+
+	var taskID string
+
+	err = json.Unmarshal(res, &taskID)
+	if err != nil {
+		return "", err
+	}
+
+	return taskID, nil
+}

pkg/cloudbroker/compute/migrate_abort.go

@@ -0,0 +1,68 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// MigrateAbortRequest struct to abort migration
+type MigrateAbortRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+type wrapperMigrateAbortRequest struct {
+	MigrateAbortRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// MigrateAbort aborts compute migration
+func (c Compute) MigrateAbort(ctx context.Context, req MigrateAbortRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateAbortRequest{
+		MigrateAbortRequest: req,
+		AsyncMode:           false,
+	}
+
+	url := "/cloudbroker/compute/migrate_abort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}
+
+// MigrateAbortAsync aborts compute migration with AsyncMode
+func (c Compute) MigrateAbortAsync(ctx context.Context, req MigrateAbortRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateAbortRequest{
+		MigrateAbortRequest: req,
+		AsyncMode:           true,
+	}
+
+	url := "/cloudbroker/compute/migrate_abort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), 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/v15/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 node ID
+	// Required: true
+	NodeID uint64 `url:"node_id" json:"node_id" 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 node, 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,76 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMigrateStorageAbortRequest struct {
+	MigrateStorageAbortRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// MigrateStorageAbort aborts complex compute migration job
+func (c Compute) MigrateStorageAbort(ctx context.Context, req MigrateStorageAbortRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateStorageAbortRequest{
+		MigrateStorageAbortRequest: req,
+		AsyncMode:                  false,
+	}
+
+	url := "/cloudbroker/compute/migrateStorageAbort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MigrateStorageAbortAsync aborts complex compute migration job with AsyncMode
+func (c Compute) MigrateStorageAbortAsync(ctx context.Context, req MigrateStorageAbortRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateStorageAbortRequest{
+		MigrateStorageAbortRequest: req,
+		AsyncMode:                  true,
+	}
+
+	url := "/cloudbroker/compute/migrateStorageAbort"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/migrate_storage_clean_up.go

@@ -0,0 +1,73 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMigrateStorageCleanUpRequest struct {
+	MigrateStorageCleanUpRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateStorageCleanUpRequest{
+		MigrateStorageCleanUpRequest: req,
+		AsyncMode:                    false,
+	}
+
+	url := "/cloudbroker/compute/migrateStorageCleanup"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MigrateStorageCleanUpAsync cleanup resources after finished migration with AsyncMode
+func (c Compute) MigrateStorageCleanUpAsync(ctx context.Context, req MigrateStorageCleanUpRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateStorageCleanUpRequest{
+		MigrateStorageCleanUpRequest: req,
+		AsyncMode:                    true,
+	}
+
+	url := "/cloudbroker/compute/migrateStorageCleanup"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), 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/v15/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/migrate_storage_list.go

@@ -0,0 +1,55 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// MigrateStorageListRequest struct to get list of jobs
+type MigrateStorageListRequest struct {
+	// Find by job ID
+	// Required: false
+	MigrationJobID uint64 `url:"migration_job_id,omitempty" json:"migration_job_id,omitempty"`
+
+	// If True then return completed jobs
+	// Required: false
+	Completed interface{} `url:"completed,omitempty" json:"completed,omitempty" validate:"omitempty,isBool"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sort_by,omitempty" json:"sort_by,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"`
+}
+
+// MigrateStorageList gets list of the jobs.
+func (c Compute) MigrateStorageList(ctx context.Context, req MigrateStorageListRequest) (*ListMigrateStorage, error) {
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudbroker/compute/migrate_storage_list"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListMigrateStorage{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudbroker/compute/migrate_to_zone.go

@@ -0,0 +1,75 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// MigrateToZone struct to move compute to another zone
+type MigrateToZoneRequest struct {
+	// ID of the compute instance to move
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the zone to move
+	// Required: true
+	ZoneID uint64 `url:"zoneId" json:"zoneId" validate:"required"`
+}
+
+type wrapperMigrateToZoneRequest struct {
+	MigrateToZoneRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// MigrateToZone moves compute to new zone
+func (c Compute) MigrateToZone(ctx context.Context, req MigrateToZoneRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateToZoneRequest{
+		MigrateToZoneRequest: req,
+		AsyncMode:            false,
+	}
+
+	url := "/cloudbroker/compute/migrateToZone"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MigrateToZoneAsync moves compute to new zone with AsyncMode
+func (c Compute) MigrateToZoneAsync(ctx context.Context, req MigrateToZoneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateToZoneRequest{
+		MigrateToZoneRequest: req,
+		AsyncMode:            true,
+	}
+
+	url := "/cloudbroker/compute/migrateToZone"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/move_to_rg.go

@@ -0,0 +1,90 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperMoveToRGRequest struct {
+	MoveToRGRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// MoveToRG moves compute instance to new resource group
+func (c Compute) MoveToRG(ctx context.Context, req MoveToRGRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMoveToRGRequest{
+		MoveToRGRequest: req,
+		AsyncMode:       false,
+	}
+
+	url := "/cloudbroker/compute/moveToRg"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// MoveToRGAsync moves compute instance to new resource group with AsyncMode
+func (c Compute) MoveToRGAsync(ctx context.Context, req MoveToRGRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMoveToRGRequest{
+		MoveToRGRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudbroker/compute/moveToRg"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/net_attach.go

@@ -0,0 +1,141 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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
+	// `EMPTY` for connect empty network
+	// `SDN` for connect to SDN
+	// `TRUNK` for connect to TRUNK
+	// 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"`
+
+	// MAC address
+	// Required: false
+	MACAddr string `url:"mac_addr,omitempty" json:"mac_addr,omitempty"`
+
+	// Used for EXTNET, TRUNK and DPDK
+	// Must be 1500-9216
+	// Required: false
+	MTU uint64 `url:"mtu,omitempty" json:"mtu,omitempty" validate:"omitempty,mtu"`
+
+	// Net mask
+	// Used only to DPDK or VFNIC net type
+	// Required: false
+	NetMask uint64 `url:"netMask,omitempty" json:"netMask,omitempty"`
+
+	// SDN Segment ID
+	// Required: false
+	SDNSegmentID string `url:"sdn_segment_id,omitempty" json:"sdn_segment_id,omitempty"`
+
+	// SDN Object Group IDs
+	// Required: false
+	SDNObjectGroupIDs []string `url:"sdn_object_group_ids,omitempty" json:"sdn_object_group_ids,omitempty"`
+
+	// SDN Logical Port Display Name
+	// Required: false
+	SDNLogicalPortDisplayName string `url:"sdn_logical_port_display_name,omitempty" json:"sdn_logical_port_display_name,omitempty"`
+
+	// SDN Logical Port Description
+	// Required: false
+	SDNLogicalPortDescription string `url:"sdn_logical_port_description,omitempty" json:"sdn_logical_port_description,omitempty"`
+
+	// Unique identifier of logical port on SDN side
+	// Required: false
+	SDNInterfaceID string `url:"sdn_interface_id,omitempty" json:"sdn_interface_id,omitempty" validate:"omitempty"`
+
+	// List of security group IDs to assign to this interface
+	// Required: false
+	SecGroups []uint64 `url:"security_groups,omitempty" json:"security_groups,omitempty"`
+
+	// Flag indicating whether security groups are enabled for this interface
+	// Not applicable to netType VFNIC, TRUNK, or SDN
+	// Required: false
+	EnableSecGroups bool `url:"enable_secgroups,omitempty" json:"enable_secgroups,omitempty"`
+
+	// Flag indicating whether this interface is enabled (only for VINS, EXTNET, DPDK, SDN, TRUNK)
+	// Required: false
+	Enabled interface{} `url:"enabled,omitempty" json:"enabled,omitempty" validate:"omitempty,isBool"`
+}
+
+type wrapperNetAttachRequest struct {
+	NetAttachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// NetAttach attaches network to compute and gets info about network
+func (c Compute) NetAttach(ctx context.Context, req NetAttachRequest) (*RecordNetAttach, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetAttachRequest{
+		NetAttachRequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudbroker/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordNetAttach{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// NetAttachAsync attaches network to compute with AsyncMode
+func (c Compute) NetAttachAsync(ctx context.Context, req NetAttachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetAttachRequest{
+		NetAttachRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudbroker/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/net_detach.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperNetDetachRequest struct {
+	NetDetachRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// NetDetach detaches network from compute
+func (c Compute) NetDetach(ctx context.Context, req NetDetachRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetDetachRequest{
+		NetDetachRequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudbroker/compute/netDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// NetDetachAsync detaches network from compute with AsyncMode
+func (c Compute) NetDetachAsync(ctx context.Context, req NetDetachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetDetachRequest{
+		NetDetachRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudbroker/compute/netDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/net_qos.go

@@ -0,0 +1,94 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperNetQOSRequest struct {
+	NetQOSRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperNetQOSRequest{
+		NetQOSRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudbroker/compute/netQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// NetQOSAsync updates compute interfaces QOS with AsyncMode
+func (c Compute) NetQOSAsync(ctx context.Context, req NetQOSRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperNetQOSRequest{
+		NetQOSRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudbroker/compute/netQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/pause.go

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

pkg/cloudbroker/compute/pfw_add.go

@@ -0,0 +1,91 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperPFWAddRequest struct {
+	PFWAddRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// 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))
+	}
+
+	reqWrapped := wrapperPFWAddRequest{
+		PFWAddRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudbroker/compute/pfwAdd"
+
+	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
+}
+
+// PFWAddAsync adds port forward rule with AsyncMode
+func (c Compute) PFWAddAsync(ctx context.Context, req PFWAddRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWAddRequest{
+		PFWAddRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudbroker/compute/pfwAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/pfw_del.go

@@ -0,0 +1,94 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperPFWDelRequest struct {
+	PFWDelRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PFWDel deletes port forward rule
+func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWDelRequest{
+		PFWDelRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudbroker/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// PFWDelAsync deletes port forward rule with AsyncMode
+func (c Compute) PFWDelAsync(ctx context.Context, req PFWDelRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWDelRequest{
+		PFWDelRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudbroker/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), 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/v15/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_node.go

@@ -0,0 +1,84 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// PinToNodeRequest struct to pin compute to node
+type PinToNodeRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Node ID to pin to
+	// Required: false
+	TargetNodeID uint64 `url:"targetNodeId" json:"targetNodeId"`
+
+	// Try to migrate or not if compute in running states
+	// Required: false
+	Force bool `url:"force" json:"force"`
+
+	// Auto start when node restarted
+	// Required: false
+	// Default: false
+	AutoStart bool `url:"autoStart" json:"autoStart"`
+}
+
+type wrapperPinToNodeRequest struct {
+	PinToNodeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PinToNode pins compute to current node
+func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudbroker/compute/pin_to_node"
+
+	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
+}
+
+// PinToNodeAsync pins compute to current node with AsyncMode
+func (c Compute) PinToNodeAsync(ctx context.Context, req PinToNodeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudbroker/compute/pin_to_node"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/power_cycle.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+}
+
+type wrapperPowerCycleRequest struct {
+	PowerCycleRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PowerCycle makes force stop and start compute
+func (c Compute) PowerCycle(ctx context.Context, req PowerCycleRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPowerCycleRequest{
+		PowerCycleRequest: req,
+		AsyncMode:         false,
+	}
+
+	url := "/cloudbroker/compute/powerCycle"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// PowerCycleAsync makes force stop and start compute with AsyncMode
+func (c Compute) PowerCycleAsync(ctx context.Context, req PowerCycleRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPowerCycleRequest{
+		PowerCycleRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudbroker/compute/powerCycle"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/raise_down.go

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

pkg/cloudbroker/compute/reboot.go

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

pkg/cloudbroker/compute/redeploy.go

@@ -0,0 +1,103 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+
+	// The OS version that will be installed on the virtual machine
+	// Required: false
+	OSVersion string `url:"os_version,omitempty" json:"os_version,omitempty"`
+
+	// Storage policy id of compute. The rules of the specified storage policy will be used.
+	// Required: false
+	StoragePolicyID uint64 `url:"storage_policy_id,omitempty" json:"storage_policy_id,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"`
+}
+
+type wrapperRedeployRequest struct {
+	RedeployRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Redeploy redeploys compute
+func (c Compute) Redeploy(ctx context.Context, req RedeployRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRedeployRequest{
+		RedeployRequest: req,
+		AsyncMode:       false,
+	}
+
+	url := "/cloudbroker/compute/redeploy"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// RedeployAsync redeploys compute with AsyncMode
+func (c Compute) RedeployAsync(ctx context.Context, req RedeployRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRedeployRequest{
+		RedeployRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudbroker/compute/redeploy"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/reset.go

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

pkg/cloudbroker/compute/resize.go

@@ -0,0 +1,99 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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"`
+
+	// Recommended isolated CPUs. Field is ignored if compute.cpupin=False or compute.pinned=False
+	// Required: false
+	PreferredCPU []int64 `url:"preferredCpu,omitempty" json:"preferredCpu,omitempty" validate:"omitempty,preferredCPU"`
+}
+
+// GetRAM returns RAM field values
+func (r ResizeRequest) GetRAM() map[string]uint64 {
+
+	res := make(map[string]uint64, 1)
+
+	res["RAM"] = r.RAM
+
+	return res
+}
+
+type wrapperResizeRequest struct {
+	ResizeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Resize resizes compute instance
+func (c Compute) Resize(ctx context.Context, req ResizeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperResizeRequest{
+		ResizeRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudbroker/compute/resize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// ResizeAsync resizes compute instance with AsyncMode
+func (c Compute) ResizeAsync(ctx context.Context, req ResizeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperResizeRequest{
+		ResizeRequest: req,
+		AsyncMode:     true,
+	}
+
+	url := "/cloudbroker/compute/resize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/restore.go

@@ -0,0 +1,71 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// RestoreRequest struct to restore compute
+type RestoreRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+type wrapperRestoreRequest struct {
+	RestoreRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// Restore restores compute from recycle bin
+func (c Compute) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRestoreRequest{
+		RestoreRequest: req,
+		AsyncMode:      false,
+	}
+
+	url := "/cloudbroker/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// RestoreAsync restores compute from recycle bin with AsyncMode
+func (c Compute) RestoreAsync(ctx context.Context, req RestoreRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRestoreRequest{
+		RestoreRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudbroker/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudbroker/compute/resume.go

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

pkg/cloudbroker/compute/serialize.go

@@ -0,0 +1,43 @@
+package compute
+
+import (
+	"encoding/json"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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_cpu_alignment_profile.go

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

pkg/cloudbroker/compute/set_custom_fields.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/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
+}