git test

pkg/cloudapi/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 := "/cloudapi/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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/compute/affinityGroupCheckStart"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/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 to clear affinity label for compute
+type AffinityLabelRemoveRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// 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 := "/cloudapi/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/cloudapi/compute/affinity_label_set.go

@@ -0,0 +1,42 @@
+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 {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
+}
+
+// AffinityLabelSet set 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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/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/cloudapi/compute/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"
+)
+
+// AffinityRuleAddRequest struct to add affinity rule
+type AffinityRuleAddRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// 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"`
+}
+
+// AffinityRuleAdd add 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 := "/cloudapi/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/cloudapi/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 {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// 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 := "/cloudapi/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/cloudapi/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 {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// AffinityRulesClear clear 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 := "/cloudapi/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/cloudapi/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 {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// 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 add 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 := "/cloudapi/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/cloudapi/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 {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// 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 remove 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 := "/cloudapi/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/cloudapi/compute/anti_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"
+)
+
+// AntiAffinityRulesClearRequest struct to clear anti affinity rules
+type AntiAffinityRulesClearRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// 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 := "/cloudapi/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/cloudapi/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 attach 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 := "/cloudapi/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/cloudapi/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 attach 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 := "/cloudapi/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/cloudapi/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) (*ListAudits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/audits"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, 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/cloudapi/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 := "/cloudapi/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/cloudapi/compute/boot_order_get.go

@@ -0,0 +1,39 @@
+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 {
+	// Compute ID
+	// 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 := "/cloudapi/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/cloudapi/compute/boot_order_set.go

@@ -0,0 +1,47 @@
+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 := "/cloudapi/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/cloudapi/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 eject 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 := "/cloudapi/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, nil
+}
+
+// CDEjectAsync ejects CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDEjectAsync(ctx context.Context, req CDEjectRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDEjectRequest{
+		CDEjectRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/cd_insert.go

@@ -0,0 +1,75 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"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 insert 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 := "/cloudapi/compute/cdInsert"
+
+	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
+}
+
+// CDInsertAsync inserts new CD image to compute's CD-ROM with AsyncMode
+func (c Compute) CDInsertAsync(ctx context.Context, req CDInsertRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCDInsertRequest{
+		CDInsertRequest: req,
+		AsyncMode:       true,
+	}
+
+	url := "/cloudapi/compute/cdInsert"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_ip.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/changeIp"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_link_state.go

@@ -0,0 +1,80 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// ChangeLinkStateRequest struct to change 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 := "/cloudapi/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 := "/cloudapi/compute/changeLinkState"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/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 := "/cloudapi/compute/change_mtu"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/change_secutity_group.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/change_security_groups"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/clone.go

@@ -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,omitempty" json:"snapshotTimestamp,omitempty"`
+
+	// Name of the parent's snapshot to create clone from
+	// Required: false
+	SnapshotName string `url:"snapshotName,omitempty" json:"snapshotName,omitempty"`
+
+	// 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 := "/cloudapi/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 := "/cloudapi/compute/clone"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/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) (ListCloneAbort, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/clone_abort"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return nil, err
+	}
+
+	var result ListCloneAbort
+
+	err = json.Unmarshal(res, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/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 uint64 `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 := "/cloudapi/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/cloudapi/compute/compute.go

@@ -0,0 +1,18 @@
+// API Actor for managing Compute. This actor is a final API for endusers 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,
+	}
+}

pkg/cloudapi/compute/create_template.go

@@ -0,0 +1,45 @@
+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))
+	}
+
+	url := "/cloudapi/compute/createTemplate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudapi/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 disk. 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 := "/cloudapi/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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/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 := "/cloudapi/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/delete_cpu_alignment_profile.go

@@ -0,0 +1,39 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/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 := "/cloudapi/compute/delete_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/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 := "/cloudapi/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/cloudapi/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 detach vgpu for compute.
+// If param vgpuid 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 := "/cloudapi/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/cloudapi/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 detach 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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/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 := "/cloudapi/compute/disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_add.go

@@ -0,0 +1,113 @@
+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 policy id of disk. The rules of the specified storage policy will be used.
+	// Required: true
+	StoragePolicyID uint64 `url:"storage_policy_id" json:"storage_policy_id" validate:"required"`
+
+	// Storage endpoint provider ID
+	// By default the same with boot disk
+	// Required: false
+	SepID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
+
+	// 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"`
+
+	// 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 := "/cloudapi/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 := "/cloudapi/compute/diskAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_attach.go

@@ -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 := "/cloudapi/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 attaches disk to compute with AsyncMode
+func (c Compute) DiskAttachAsync(ctx context.Context, req DiskAttachRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskAttachRequest{
+		DiskAttachRequest: req,
+		AsyncMode:         true,
+	}
+
+	url := "/cloudapi/compute/diskAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_del.go

@@ -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 delete disk and detach 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 := "/cloudapi/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 from compute with AsyncMode
+func (c Compute) DiskDelAsync(ctx context.Context, req DiskDelRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperDiskDelRequest{
+		DiskDelRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/diskDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_detach.go

@@ -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 detach 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 := "/cloudapi/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 := "/cloudapi/compute/diskDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_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 := "/cloudapi/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/cloudapi/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 change 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 := "/cloudapi/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 := "/cloudapi/compute/diskQos"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_resize.go

@@ -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 change 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 := "/cloudapi/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 := "/cloudapi/compute/diskResize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/disk_switch_to_replication.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/diskSwitchToReplication"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/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 := "/cloudapi/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/cloudapi/compute/filter.go

@@ -0,0 +1,170 @@
+package compute
+
+import (
+	"context"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/interfaces"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/pkg/cloudapi/k8s"
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/pkg/cloudapi/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 returns 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
+	}
+
+	res := lc.FilterFunc(predicate)
+
+	return &res, 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 returns 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
+	}
+
+	res := lc.FilterFunc(predicate)
+
+	return &res, nil
+}
+
+// FilterFunc allows filtering ListComputes based on a user-specified predicate.
+func (lc ListComputes) FilterFunc(predicate func(ItemCompute) bool) ListComputes {
+	var result ListComputes
+
+	for _, item := range lc.Data {
+		if predicate(item) {
+			result.Data = append(result.Data, item)
+		}
+	}
+
+	result.EntryCount = uint64(len(result.Data))
+
+	return result
+}
+
+// FindOne returns first found ItemCompute
+// If none was found, returns an empty struct.
+func (lc ListComputes) FindOne() ItemCompute {
+	if len(lc.Data) == 0 {
+		return ItemCompute{}
+	}
+
+	return lc.Data[0]
+}

pkg/cloudapi/compute/filter_test.go

@@ -0,0 +1,240 @@
+package compute
+
+import "testing"
+
+var computes = ListComputes{
+	Data: []ItemCompute{
+		{
+			ACL:           ListACL{},
+			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",
+				},
+			},
+			Architecture: "X86_64",
+			BootOrder: []string{
+				"hd", "cdrom",
+			},
+			BootDiskSize:   0,
+			CloneReference: 0,
+			Clones:         []uint64{},
+			ComputeCIID:    0,
+			CPU:            4,
+			CreatedBy:      "timofey_tkachev_1@decs3o",
+			CreatedTime:    1676975175,
+			CustomFields:   map[string]interface{}{},
+			DeletedBy:      "",
+			DeletedTime:    0,
+			Description:    "",
+			Devices:        nil,
+			Disks: []InfoDisk{
+				{
+					ID: 65191,
+				},
+			},
+			Driver:           "KVM_X86",
+			GID:              212,
+			GUID:             48500,
+			ID:               48500,
+			Interfaces:       []ItemVNFInterface{},
+			LockStatus:       "UNLOCKED",
+			ManagerID:        0,
+			ManagerType:      "",
+			MigrationJob:     0,
+			Milestones:       363500,
+			Name:             "test",
+			PinnedToNode:     true,
+			RAM:              4096,
+			ReferenceID:      "c7cb19ac-af4a-4067-852f-c5572949207e",
+			Registered:       true,
+			ResName:          "compute-48500",
+			RGID:             79724,
+			RGName:           "std_broker2",
+			SnapSets:         []ItemSnapSet{},
+			StatelessSepID:   0,
+			StatelessSepType: "",
+			Status:           "ENABLED",
+			Tags:             map[string]string{},
+			TechStatus:       "STOPPED",
+			TotalDiskSize:    2,
+			UpdatedBy:        "",
+			UpdatedTime:      1677058904,
+			UserManaged:      true,
+			VGPUs:            []uint64{},
+			VINSConnected:    0,
+			ZoneID:           1,
+		},
+		{
+			ACL:               ListACL{},
+			AccountID:         132848,
+			AccountName:       "std_broker",
+			AffinityLabel:     "",
+			AffinityRules:     []ItemRule{},
+			AffinityWeight:    0,
+			AntiAffinityRules: []ItemRule{},
+			Architecture:      "X86_64",
+			BootOrder: []string{
+				"hd", "cdrom",
+			},
+			BootDiskSize:   0,
+			CloneReference: 0,
+			Clones:         []uint64{},
+			ComputeCIID:    0,
+			CPU:            6,
+			CreatedBy:      "timofey_tkachev_1@decs3o",
+			CreatedTime:    1677579436,
+			CustomFields:   map[string]interface{}{},
+			DeletedBy:      "",
+			DeletedTime:    0,
+			Description:    "",
+			Devices:        nil,
+			Disks: []InfoDisk{
+				{
+					ID: 65248,
+				},
+			},
+			Driver:           "KVM_X86",
+			GID:              212,
+			GUID:             48556,
+			ID:               48556,
+			Interfaces:       []ItemVNFInterface{},
+			LockStatus:       "UNLOCKED",
+			ManagerID:        0,
+			ManagerType:      "",
+			MigrationJob:     0,
+			Milestones:       363853,
+			Name:             "compute_2",
+			RAM:              4096,
+			ReferenceID:      "a542c449-5b1c-4f90-88c5-7bb5f8ae68ff",
+			Registered:       true,
+			PinnedToNode:     true,
+			ResName:          "compute-48556",
+			RGID:             79727,
+			RGName:           "sdk_negative_fields_test",
+			SnapSets:         []ItemSnapSet{},
+			StatelessSepID:   0,
+			StatelessSepType: "",
+			Status:           "ENABLED",
+			Tags:             map[string]string{},
+			TechStatus:       "STARTED",
+			TotalDiskSize:    1,
+			UpdatedBy:        "",
+			UpdatedTime:      1677579436,
+			UserManaged:      true,
+			VGPUs:            []uint64{},
+			VINSConnected:    0,
+			ZoneID:           5,
+		},
+	},
+	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("test").FindOne()
+
+	if actual.Name != "test" {
+		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].CPU != 4 {
+		t.Fatal("expected 4 CPU cores, found: ", actual.Data[0].CPU)
+	}
+
+	actual = computes.SortByCPU(true)
+
+	if actual.Data[0].CPU != 6 {
+		t.Fatal("expected 6 CPU cores, found: ", actual.Data[0].CPU)
+	}
+}

pkg/cloudapi/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 struct 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 := "/cloudapi/compute/get"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/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) (ListShortAudits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/getAudits"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListShortAudits{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudapi/compute/get_console_url.go

@@ -0,0 +1,35 @@
+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 := "/cloudapi/compute/getConsoleUrl"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}

pkg/cloudapi/compute/get_cpu_alignment_profile.go

@@ -0,0 +1,46 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/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 := "/cloudapi/compute/get_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	return res, err
+}

pkg/cloudapi/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 := "/cloudapi/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/cloudapi/compute/get_log.go

@@ -0,0 +1,53 @@
+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 := "/cloudapi/compute/getLog"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}
+
+// GetLogGet gets compute's log file by path
+func (c Compute) GetLogGet(ctx context.Context, req GetLogRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/getLog"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/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 := "/cloudapi/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 := "/cloudapi/compute/guest_agent_disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_enable.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/guest_agent_enable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_execute.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/guest_agent_execute"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/guest_agent_feature_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 := "/cloudapi/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/cloudapi/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 := "/cloudapi/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 := "/cloudapi/compute/guest_agent_feature_update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/ids.go

@@ -0,0 +1,37 @@
+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 (li ListInfoDisks) IDs() []uint64 {
+	res := make([]uint64, 0, len(li))
+	for _, i := range li {
+		res = append(res, i.ID)
+	}
+	return res
+}
+
+// IDs gets array of PFWsIDs from ListPFWs struct
+func (lp ListPFWs) 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 ListComputeDisks struct
+func (lcd ListComputeDisks) IDs() []uint64 {
+	res := make([]uint64, 0, len(lcd))
+	for _, cd := range lcd {
+		res = append(res, cd.ID)
+	}
+	return res
+}

pkg/cloudapi/compute/list.go

@@ -0,0 +1,105 @@
+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 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.
+// 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.
+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 := "/cloudapi/compute/list"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/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) (*ListComputes, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/listDeleted"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListComputes{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/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 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 := "/cloudapi/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/cloudapi/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 vGPU list
+type ListVGPURequest struct {
+	// Identifier compute
+	// 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 vGPU
+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 := "/cloudapi/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/cloudapi/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"
+)
+
+// MigrateToRGZone 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"`
+}
+
+// MoveToRG moves compute instance to new resource group
+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 := "/cloudapi/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 another zone with AsyncMode
+func (c Compute) MigrateToZoneAsync(ctx context.Context, req MigrateToZoneRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperMigrateToZoneRequest{
+		MigrateToZoneRequest: req,
+		AsyncMode:            true,
+	}
+
+	url := "/cloudapi/compute/migrateToZone"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/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 := "/cloudapi/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 := "/cloudapi/compute/moveToRg"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/net_attach.go

@@ -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: false
+	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 := "/cloudapi/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 := "/cloudapi/compute/netAttach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/net_detach.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/netDetach"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pause.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/pause"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pfw_add.go

@@ -0,0 +1,89 @@
+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
+	// either "tcp" or "udp"
+	// Required: true
+	Proto string `url:"proto" json:"proto" validate:"proto"`
+}
+
+type wrapperPFWAddRequest struct {
+	PFWAddRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PFWAdd add port forward rule
+func (c Compute) PFWAdd(ctx context.Context, req PFWAddRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWAddRequest{
+		PFWAddRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudapi/compute/pfwAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, 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 := "/cloudapi/compute/pfwAdd"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/pfw_del.go

@@ -0,0 +1,92 @@
+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
+	PFWID 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
+	// either "tcp" or "udp"
+	// Required: false
+	Proto string `url:"proto,omitempty" json:"proto,omitempty"`
+}
+
+type wrapperPFWDelRequest struct {
+	PFWDelRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PFWDel deletes port forward rule
+func (c Compute) PFWDel(ctx context.Context, req PFWDelRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPFWDelRequest{
+		PFWDelRequest: req,
+		AsyncMode:     false,
+	}
+
+	url := "/cloudapi/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, 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 := "/cloudapi/compute/pfwDel"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/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) (*ListPFWs, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/pfwList"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListPFWs{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/compute/pin_to_node.go

@@ -0,0 +1,76 @@
+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"`
+
+	// Auto start when node restarted
+	// Required: false
+	// Default: false
+	AutoStart bool `url:"autoStart" json:"autoStart"`
+}
+
+type wrapperPinToNodeRequest struct {
+	PinToNodeRequest
+
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// PinToNode pin compute to current node
+func (c Compute) PinToNode(ctx context.Context, req PinToNodeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        false,
+	}
+
+	url := "/cloudapi/compute/pin_to_node"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// PinToNodeAsync pins compute to current node with AsyncMode
+func (c Compute) PinToNodeAsync(ctx context.Context, req PinToNodeRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperPinToNodeRequest{
+		PinToNodeRequest: req,
+		AsyncMode:        true,
+	}
+
+	url := "/cloudapi/compute/pin_to_node"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/power_cycle.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/powerCycle"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/reboot.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/reboot"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/redeploy.go

@@ -0,0 +1,100 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// RedeployRequest struct to redeploy
+type RedeployRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// 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"`
+
+	// 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"`
+
+	// 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,
+	// KEEP, DETACH, DESTROY
+	// Required: false
+	DataDisks string `url:"dataDisks,omitempty" json:"dataDisks,omitempty"`
+
+	// Should 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 := "/cloudapi/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 := "/cloudapi/compute/redeploy"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/reset.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/reset"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/resize.go

@@ -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 := "/cloudapi/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 := "/cloudapi/compute/resize"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/restore.go

@@ -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 := "/cloudapi/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}
+
+// RestoreAsync restores compute from recycle bin with AsyncMode
+func (c Compute) RestoreAsync(ctx context.Context, req RestoreRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperRestoreRequest{
+		RestoreRequest: req,
+		AsyncMode:      true,
+	}
+
+	url := "/cloudapi/compute/restore"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/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 resume 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 := "/cloudapi/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 := "/cloudapi/compute/resume"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/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 lc.EntryCount == 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/cloudapi/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 := "/cloudapi/compute/set_cpu_alignment_profile"
+
+	res, err := c.client.DecortApiCallCtype(ctx, http.MethodPost, url, constants.MIMEJSON, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/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 to set 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 := "/cloudapi/compute/setCustomFields"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/shared_snapshot_merge_status.go

@@ -0,0 +1,33 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// SharedSnapshotMergeStatusRequest struct to get shared snapshot merge status
+type SharedSnapshotMergeStatusRequest struct {
+	// ID of compute instance to get log for
+	// Required: true
+	ComputeID uint64 `url:"compute_id" json:"compute_id" validate:"required"`
+}
+
+// SharedSnapshotMergeStatus shared snapshots merge status
+// returns a string representing either the current status or the progress percentage
+func (c Compute) SharedSnapshotMergeStatus(ctx context.Context, req SharedSnapshotMergeStatusRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/shared_snapshot_merge_status"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodGet, url, req)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/snapshot_create.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// SnapshotCreateRequest struct to create snapshot
+type SnapshotCreateRequest struct {
+	// ID of the compute instance to create snapshot for
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Text label for snapshot.
+	// Must be unique among this compute snapshots
+	// Allowed characters: a-z, 0-9, spaces, punctuation except '<' and '>'
+	// Maximum length: 36 characters
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required,max=36,excludesall=<>"`
+
+	// Create snapshot with memory dump
+	// Required: false
+	// Default: false
+	WithMemory bool `url:"with_memory" json:"with_memory"`
+}
+
+type wrapperSnapshotCreateRequest struct {
+	SnapshotCreateRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// SnapshotCreate creates compute snapshot
+func (c Compute) SnapshotCreate(ctx context.Context, req SnapshotCreateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotCreateRequest{
+		SnapshotCreateRequest: req,
+		AsyncMode:             false,
+	}
+
+	url := "/cloudapi/compute/snapshotCreate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	result := strings.ReplaceAll(string(res), "\"", "")
+
+	return result, nil
+}
+
+// SnapshotCreateAsync creates compute snapshot in async mode
+func (c Compute) SnapshotCreateAsync(ctx context.Context, req SnapshotCreateRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotCreateRequest{
+		SnapshotCreateRequest: req,
+		AsyncMode:             true,
+	}
+
+	url := "/cloudapi/compute/snapshotCreate"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/snapshot_delete.go

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

pkg/cloudapi/compute/snapshot_list.go

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

pkg/cloudapi/compute/snapshot_rollback.go

@@ -0,0 +1,79 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// SnapshotRollbackRequest struct for rollback
+type SnapshotRollbackRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Text label of snapshot to rollback
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+
+	// Rollback with memory dump restore
+	// Required: false
+	// Default: true
+	WithMemory interface{} `url:"with_memory,omitempty" json:"with_memory,omitempty" validate:"omitempty,isBool"`
+}
+
+type wrapperSnapshotRollbackRequest struct {
+	SnapshotRollbackRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// SnapshotRollback rollbacks specified compute snapshot
+func (c Compute) SnapshotRollback(ctx context.Context, req SnapshotRollbackRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotRollbackRequest{
+		SnapshotRollbackRequest: req,
+		AsyncMode:               false,
+	}
+
+	url := "/cloudapi/compute/snapshotRollback"
+
+	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
+}
+
+// SnapshotRollbackAsync rollbacks specified compute snapshot in async mode
+func (c Compute) SnapshotRollbackAsync(ctx context.Context, req SnapshotRollbackRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperSnapshotRollbackRequest{
+		SnapshotRollbackRequest: req,
+		AsyncMode:               true,
+	}
+
+	url := "/cloudapi/compute/snapshotRollback"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, reqWrapped)
+	if err != nil {
+		return "", err
+	}
+
+	return string(res), nil
+}

pkg/cloudapi/compute/snapshot_usage.go

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

pkg/cloudapi/compute/sorting.go

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

pkg/cloudapi/compute/start.go

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

pkg/cloudapi/compute/stop.go

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

pkg/cloudapi/compute/tag_add.go

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

pkg/cloudapi/compute/tag_remove.go

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

pkg/cloudapi/compute/unpin_from_node.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// UnpinFromNodeRequest struct for unpin from node
+type UnpinFromNodeRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// UnpinFromNode unpins compute from current node
+func (c Compute) UnpinFromNode(ctx context.Context, req UnpinFromNodeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/unpin_from_node"
+
+	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/cloudapi/compute/update.go

@@ -0,0 +1,99 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// UpdateRequest struct to update compute
+type UpdateRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// New name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// New description
+	// Required: false
+	Description string `url:"desc,omitempty" json:"desc,omitempty"`
+
+	// Rule for VM placement with NUMA affinity.
+	// Possible values - none (placement without NUMA affinity),
+	// strict (strictly with NUMA affinity, if not possible - do not start VM),
+	// loose (use NUMA affinity if possible)
+	// Required: false
+	// Default: none
+	NumaAffinity string `url:"numaAffinity,omitempty" json:"numaAffinity,omitempty" validate:"omitempty,numaAffinity"`
+
+	// Run VM on dedicated CPUs. To use this feature, the system must be pre-configured by allocating CPUs on the physical node, true or false
+	// Required: false
+	CPUPin interface{} `url:"cpupin,omitempty" json:"cpupin,omitempty" validate:"omitempty,isBool"`
+
+	// Type of the emulated system, Q35 or i440fx
+	// Required: false
+	Chipset string `url:"chipset,omitempty" json:"chipset,omitempty" validate:"omitempty,chipset"`
+
+	// Use Huge Pages to allocate RAM of the virtual machine. The system must be pre-configured by allocating Huge Pages on the physical node, true or false
+	// Required: false
+	HPBacked interface{} `url:"hpBacked,omitempty" json:"hpBacked,omitempty" validate:"omitempty,isBool"`
+
+	// Auto start when node restarted, true or false
+	// Required: false
+	AutoStart interface{} `url:"autoStart,omitempty" json:"autoStart,omitempty" validate:"omitempty,isBool"`
+
+	// 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"`
+
+	// VM type linux, windows or unknown
+	// Required: false
+	LoaderType string `url:"loaderType,omitempty" json:"loaderType,omitempty" validate:"omitempty,loaderType"`
+
+	// Boot type of image bios or uefi
+	// Required: false
+	BootType string `url:"bootType,omitempty" json:"bootType,omitempty" validate:"omitempty,imageBootType"`
+
+	// Select a network interface naming pattern for your Linux machine. eth - onboard, ens - pci slot naming.
+	// Required: false
+	NetworkInterfaceNaming string `url:"networkInterfaceNaming,omitempty" json:"networkInterfaceNaming,omitempty" validate:"omitempty,networkInterfaceNaming"`
+
+	// Does this machine supports hot resize, true or false
+	// Required: false
+	HotResize interface{} `url:"hotResize,omitempty" json:"hotResize,omitempty" validate:"omitempty,isBool"`
+
+	// The OS version that will be installed on the virtual machine
+	// Required: false
+	OSVersion string `url:"os_version,omitempty" json:"os_version,omitempty"`
+
+	// Clock type for the VM
+	// Required: false
+	// Default: null
+	Clock string `url:"clock,omitempty" json:"clock,omitempty"`
+}
+
+// Update updates some properties of the compute
+func (c Compute) Update(ctx context.Context, req UpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/update"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/user_grant.go

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

pkg/cloudapi/compute/user_list.go

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

pkg/cloudapi/compute/user_revoke.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// UserRevokeRequest struct to revoke user access
+type UserRevokeRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the user to remove
+	// Required: true
+	Username string `url:"userName" json:"userName" validate:"required"`
+}
+
+// UserRevoke revokes user access to the compute
+func (c Compute) UserRevoke(ctx context.Context, req UserRevokeRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/userRevoke"
+
+	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/cloudapi/compute/user_update.go

@@ -0,0 +1,50 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v15/internal/validators"
+)
+
+// UserUpdateRequest struct to update user access
+type UserUpdateRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the user to update
+	// Required: true
+	Username string `url:"userName" json:"userName" validate:"required"`
+
+	// Access type
+	// Should be one of:
+	//	- 'R' for Read only
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype" json:"accesstype" validate:"accessType"`
+}
+
+// UserUpdate updates user access to the compute
+func (c Compute) UserUpdate(ctx context.Context, req UserUpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/userUpdate"
+
+	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
+}