v9.0.0

pkg/cloudapi/account.go

@@ -0,0 +1,10 @@
+package cloudapi
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudapi/account"
+)
+
+// Accessing the Account method group
+func (ca *CloudAPI) Account() *account.Account {
+	return account.New(ca.client)
+}

pkg/cloudapi/account/account.go

@@ -0,0 +1,18 @@
+// API Actor API for managing account
+package account
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/interfaces"
+)
+
+// Structure for creating request to account
+type Account struct {
+	client interfaces.Caller
+}
+
+// Builder for account endpoints
+func New(client interfaces.Caller) *Account {
+	return &Account{
+		client,
+	}
+}

pkg/cloudapi/account/add_user.go

@@ -0,0 +1,49 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AddUserRequest struct to add permission to access account for a user
+type AddUserRequest struct {
+	// ID of account to add to
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Name of the user to be given rights
+	// Required: true
+	UserID string `url:"userId" json:"userId" validate:"required"`
+
+	// Account permission types:
+	//	- 'R' for read only access
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype" json:"accesstype" validate:"required,accessType"`
+}
+
+// AddUser gives a user access rights.
+func (a Account) AddUser(ctx context.Context, req AddUserRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/addUser"
+
+	res, err := a.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/account/audits.go

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

pkg/cloudapi/account/create.go

@@ -0,0 +1,75 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CreateRequest struct for creating account
+type CreateRequest struct {
+	// Display name
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// Name of the account
+	// Required: true
+	Username string `url:"username" json:"username" validate:"required"`
+
+	// Email
+	// Required: false
+	EmailAddress string `url:"emailaddress,omitempty" json:"emailaddress,omitempty" validate:"omitempty,email"`
+
+	// Max size of memory in MB
+	// Required: false
+	MaxMemoryCapacity int64 `url:"maxMemoryCapacity,omitempty" json:"maxMemoryCapacity,omitempty"`
+
+	// Max size of aggregated vdisks in GB
+	// Required: false
+	MaxVDiskCapacity int64 `url:"maxVDiskCapacity,omitempty" json:"maxVDiskCapacity,omitempty"`
+
+	// Max number of CPU cores
+	// Required: false
+	MaxCPUCapacity int64 `url:"maxCPUCapacity,omitempty" json:"maxCPUCapacity,omitempty"`
+
+	// Max sent/received network transfer peering
+	// Required: false
+	MaxNetworkPeerTransfer int64 `url:"maxNetworkPeerTransfer,omitempty" json:"maxNetworkPeerTransfer,omitempty"`
+
+	// Max number of assigned public IPs
+	// Required: false
+	MaxNumPublicIP int64 `url:"maxNumPublicIP,omitempty" json:"maxNumPublicIP,omitempty"`
+
+	// If true send emails when a user is granted access to resources
+	// Required: false
+	SendAccessEmails bool `url:"sendAccessEmails" json:"sendAccessEmails"`
+
+	// Limit (positive) or disable (0) GPU resources
+	// Required: false
+	GPUUnits int64 `url:"gpu_units,omitempty" json:"gpu_units,omitempty"`
+}
+
+// Create creates account
+// Setting a cloud unit maximum to -1 or empty will not put any restrictions on the resource
+func (a Account) Create(ctx context.Context, req CreateRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/create"
+
+	res, err := a.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/account/delete.go

@@ -0,0 +1,36 @@
+package account
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteRequest struct to delete account
+type DeleteRequest struct {
+	// ID of account to delete
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Whether to completely delete the account
+	// Required: false
+	Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
+}
+
+// Delete completes delete an account from the system Returns true if account is deleted or was already deleted or never existed
+func (a Account) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/delete"
+
+	_, err = a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}

pkg/cloudapi/account/delete_user.go

@@ -0,0 +1,42 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteUserRequest struct to revoke access to account
+type DeleteUserRequest struct {
+	// ID of the account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// ID or emailaddress of the user to remove
+	// Required: true
+	UserID string `url:"userId" json:"userId" validate:"required"`
+}
+
+// DeleteUser revokes user access from the account
+func (a Account) DeleteUser(ctx context.Context, req DeleteUserRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/deleteUser"
+
+	res, err := a.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/account/disable_enable.go

@@ -0,0 +1,60 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DisableEnableRequest struct to change status of account
+type DisableEnableRequest struct {
+	// ID of account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+}
+
+// Disable disables an account
+func (a Account) Disable(ctx context.Context, req DisableEnableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/disable"
+
+	res, err := a.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
+}
+
+// Enable enables an account
+func (a Account) Enable(ctx context.Context, req DisableEnableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/enable"
+
+	res, err := a.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/account/filter.go

@@ -0,0 +1,70 @@
+package account
+
+// FilterByID returns ListAccounts with specified ID.
+func (la ListAccounts) FilterByID(id uint64) ListAccounts {
+	predicate := func(ia ItemAccount) bool {
+		return ia.ID == id
+	}
+
+	return la.FilterFunc(predicate)
+}
+
+// FilterByName returns ListAccounts with specified Name.
+func (la ListAccounts) FilterByName(name string) ListAccounts {
+	predicate := func(ia ItemAccount) bool {
+		return ia.Name == name
+	}
+
+	return la.FilterFunc(predicate)
+}
+
+// FilterByStatus returns ListAccounts with specified Status.
+func (la ListAccounts) FilterByStatus(status string) ListAccounts {
+	predicate := func(ia ItemAccount) bool {
+		return ia.Status == status
+	}
+
+	return la.FilterFunc(predicate)
+}
+
+// FilterByUserGroupID returns ListAccounts with specified UserGroupID.
+func (la ListAccounts) FilterByUserGroupID(userGroupID string) ListAccounts {
+	predicate := func(ia ItemAccount) bool {
+		acl := ia.ACL
+
+		for _, item := range acl {
+			if item.UgroupID == userGroupID {
+				return true
+			}
+		}
+
+		return false
+	}
+
+	return la.FilterFunc(predicate)
+}
+
+// FilterFunc allows filtering ListAccounts based on a user-specified predicate.
+func (la ListAccounts) FilterFunc(predicate func(ItemAccount) bool) ListAccounts {
+	var result ListAccounts
+
+	for _, acc := range la.Data {
+		if predicate(acc) {
+			result.Data = append(result.Data, acc)
+		}
+	}
+
+	result.EntryCount = uint64(len(result.Data))
+
+	return result
+}
+
+// FindOne returns first found ItemAccount.
+// If none was found, returns an empty struct.
+func (la ListAccounts) FindOne() ItemAccount {
+	if len(la.Data) == 0 {
+		return ItemAccount{}
+	}
+
+	return la.Data[0]
+}

pkg/cloudapi/account/filter_test.go

@@ -0,0 +1,149 @@
+package account
+
+import (
+	"testing"
+)
+
+var accounts = ListAccounts{
+	Data: []ItemAccount{
+		{
+			ACL: []RecordACL{
+				{
+					IsExplicit: true,
+					GUID:       "",
+					Rights:     "CXDRAU",
+					Status:     "CONFIRMED",
+					Type:       "U",
+					UgroupID:   "timofey_tkachev_1@decs3o",
+				},
+			},
+			CreatedTime: 1676645275,
+			DeletedTime: 0,
+			ID:          132846,
+			Name:        "std",
+			Status:      "CONFIRMED",
+			UpdatedTime: 1676645275,
+		},
+		{
+			ACL: []RecordACL{
+				{
+					IsExplicit: true,
+					GUID:       "",
+					Rights:     "CXDRAU",
+					Status:     "CONFIRMED",
+					Type:       "U",
+					UgroupID:   "not_really_timofey_tkachev_1@decs3o",
+				},
+			},
+			CreatedTime: 1676878820,
+			DeletedTime: 0,
+			ID:          132847,
+			Name:        "std_2",
+			Status:      "CONFIRMED",
+			UpdatedTime: 1676645275,
+		},
+		{
+			ACL: []RecordACL{
+				{
+					IsExplicit: true,
+					GUID:       "",
+					Rights:     "CXDRAU",
+					Status:     "CONFIRMED",
+					Type:       "U",
+					UgroupID:   "timofey_tkachev_1@decs3o",
+				},
+				{
+					IsExplicit: true,
+					GUID:       "",
+					Rights:     "CXDRAU",
+					Status:     "CONFIRMED",
+					Type:       "U",
+					UgroupID:   "second_account@decs3o",
+				},
+			},
+			CreatedTime: 1676883850,
+			DeletedTime: 1676883899,
+			ID:          132848,
+			Name:        "std_broker",
+			Status:      "DELETED",
+			UpdatedTime: 1676878820,
+		},
+	},
+	EntryCount: 3,
+}
+
+func TestFilterByID(t *testing.T) {
+	actual := accounts.FilterByID(132846).FindOne()
+
+	if actual.ID != 132846 {
+		t.Fatal("actual: ", actual.ID, " > expected: 132846")
+	}
+}
+
+func TestFilterByUserGroupId(t *testing.T) {
+	actual := accounts.FilterByUserGroupID("second_account@decs3o").FindOne()
+
+	for _, item := range actual.ACL {
+		if item.UgroupID == "second_account@decs3o" {
+			return
+		}
+	}
+
+	t.Fatal("second_account@decs3o has not been found. expected 1 found")
+}
+
+func TestFilterByName(t *testing.T) {
+	actual := accounts.FilterByName("std_broker").FindOne()
+
+	if actual.Name != "std_broker" {
+		t.Fatal("actual: ", actual.Name, " >> expected: std_broker")
+	}
+}
+
+func TestFilterByStatus(t *testing.T) {
+	actual := accounts.FilterByStatus("CONFIRMED")
+
+	if len(actual.Data) != 2 {
+		t.Fatal("Expected 2 elements in slice, found: ", len(actual.Data))
+	}
+
+	for _, item := range actual.Data {
+		if item.Status != "CONFIRMED" {
+			t.Fatal("expected CONFIRMED, found: ", item.Status)
+		}
+	}
+}
+
+func TestFilterFunc(t *testing.T) {
+	actual := accounts.FilterFunc(func(ia ItemAccount) bool {
+		return ia.DeletedTime == 0
+	})
+
+	for _, item := range actual.Data {
+		if item.DeletedTime != 0 {
+			t.Fatal("Expected DeletedTime = 0, found: ", item.DeletedTime)
+		}
+	}
+}
+
+func TestSortingByCreatedTime(t *testing.T) {
+	actual := accounts.SortByCreatedTime(false)
+
+	if actual.Data[0].Name != "std" {
+		t.Fatal("Expected account std as earliest, found: ", actual.Data[0].Name)
+	}
+
+	actual = accounts.SortByCreatedTime(true)
+
+	if actual.Data[0].Name != "std_broker" {
+		t.Fatal("Expected account std_broker as latest, found: ", actual.Data[0].Name)
+	}
+}
+
+func TestFilterEmpty(t *testing.T) {
+	actual := accounts.FilterByID(0)
+
+	if len(actual.Data) != 0 {
+		t.Fatal("Expected 0 found, actual: ", len(actual.Data))
+	}
+}

pkg/cloudapi/account/get.go

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

pkg/cloudapi/account/get_consumed_account_units.go

@@ -0,0 +1,46 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetConsumedAccountUnitsRequest struct to calculate the currently consumed units for all cloudspaces and resource groups in the account
+type GetConsumedAccountUnitsRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+}
+
+// GetConsumedAccountUnits calculates the currently consumed units for all cloudspaces and resource groups in the account.
+// Calculated cloud units are returned in a dict which includes:
+//   - CU_M: consumed memory in MB
+//   - CU_C: number of cpu cores
+//   - CU_D: consumed vdisk storage in GB
+//   - CU_DM: consumed max vdisk storage in GB
+//   - CU_I: number of public IPs
+func (a Account) GetConsumedAccountUnits(ctx context.Context, req GetConsumedAccountUnitsRequest) (*ResourceLimits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/getConsumedAccountUnits"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := ResourceLimits{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudapi/account/get_consumed_cloud_units_by_type.go

@@ -0,0 +1,54 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetConsumedCloudUnitsByTypeRequest struct to calculate the currently consumed cloud units of the specified type for all cloudspaces and resource groups in the account
+type GetConsumedCloudUnitsByTypeRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Cloud unit resource type
+	// Required: true
+	CUType string `url:"cutype" json:"cutype" validate:"required,accountCUType"`
+}
+
+// GetConsumedCloudUnitsByType calculates the currently consumed cloud units of the specified type for all cloudspaces
+// and resource groups in the account.
+// Possible types of cloud units are include:
+//
+//   - CU_M: returns consumed memory in MB
+//   - CU_C: returns number of virtual cpu cores
+//   - CU_D: returns consumed virtual disk storage in GB
+//   - CU_DM: returns consumed max virtual disk storage in GB
+//   - CU_S: returns consumed primary storage (NAS) in TB
+//   - CU_A: returns consumed secondary storage (Archive) in TB
+//   - CU_NO: returns sent/received network transfer in operator in GB
+//   - CU_NP: returns sent/received network transfer peering in GB
+//   - CU_I: returns number of public IPs
+func (a Account) GetConsumedCloudUnitsByType(ctx context.Context, req GetConsumedCloudUnitsByTypeRequest) (float64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/getConsumedCloudUnitsByType"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := strconv.ParseFloat(string(res), 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/account/get_reserved_account_units.go

@@ -0,0 +1,47 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetReservedAccountUnitsRequest struct to calculate the reserved units for all cloudspaces and resource groups in the account
+type GetReservedAccountUnitsRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+}
+
+// GetReservedAccountUnits calculates the reserved units for all cloudspaces and resource groups in the account.
+// Calculated cloud units are returned in a dict which includes:
+//
+//   - CU_M: reserved memory in MB
+//   - CU_C: number of cpu cores
+//   - CU_D: reserved vdisk storage in GB
+//   - CU_DM: reserved max vdisk storage in GB
+//   - CU_I: number of public IPs
+func (a Account) GetReservedAccountUnits(ctx context.Context, req GetReservedAccountUnitsRequest) (*ResourceLimits, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/getReservedAccountUnits"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := ResourceLimits{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudapi/account/get_resource_consumption.go

@@ -0,0 +1,40 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetResourceConsumptionRequest struct to get resource consumption
+type GetResourceConsumptionRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+}
+
+// GetResourceConsumption show amount of consumed and reserved resources (cpu, ram, disk) by specific account
+func (a Account) GetResourceConsumption(ctx context.Context, req GetResourceConsumptionRequest) (*RecordResourceConsumption, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/getResourceConsumption"
+
+	info := RecordResourceConsumption{}
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudapi/account/ids.go

@@ -0,0 +1,73 @@
+package account
+
+// IDs gets array of AccountIDs from ListAccounts struct
+func (la ListAccounts) IDs() []uint64 {
+	res := make([]uint64, 0, len(la.Data))
+	for _, acc := range la.Data {
+		res = append(res, acc.ID)
+	}
+	return res
+}
+
+// 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.ComputeID)
+	}
+	return res
+}
+
+// IDs gets array of DiskIDs from ListDisks struct
+func (ld ListDisks) IDs() []uint64 {
+	res := make([]uint64, 0, len(ld.Data))
+	for _, d := range ld.Data {
+		res = append(res, d.ID)
+	}
+	return res
+}
+
+// IDs gets array of FLIPGroupIDs from ListFLIPGroups struct
+func (fg ListFLIPGroups) IDs() []uint64 {
+	res := make([]uint64, 0, len(fg.Data))
+	for _, g := range fg.Data {
+		res = append(res, g.ID)
+	}
+	return res
+}
+
+// IDs gets array of AccountIDs from ListResourceConsumption struct
+func (rc ListResourceConsumption) IDs() []uint64 {
+	res := make([]uint64, 0, len(rc.Data))
+	for _, r := range rc.Data {
+		res = append(res, r.AccountID)
+	}
+	return res
+}
+
+// IDs gets array of RGIDs from ListRG struct
+func (rg ListRG) IDs() []uint64 {
+	res := make([]uint64, 0, len(rg.Data))
+	for _, g := range rg.Data {
+		res = append(res, g.RGID)
+	}
+	return res
+}
+
+// IDs gets array of TemplateIDs from ListTemplates struct
+func (lt ListTemplates) IDs() []uint64 {
+	res := make([]uint64, 0, len(lt.Data))
+	for _, t := range lt.Data {
+		res = append(res, t.ID)
+	}
+	return res
+}
+
+// IDs gets array of VINSIDs from ListVINS struct
+func (lv ListVINS) IDs() []uint64 {
+	res := make([]uint64, 0, len(lv.Data))
+	for _, v := range lv.Data {
+		res = append(res, v.ID)
+	}
+	return res
+}

pkg/cloudapi/account/list.go

@@ -0,0 +1,71 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListRequest struct to get list of accounts
+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 access control list
+	// Required: false
+	ACL string `url:"acl,omitempty" json:"acl,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"`
+}
+
+// List gets a list of all accounts the user has access to a ListAccounts struct
+func (a Account) List(ctx context.Context, req ListRequest) (*ListAccounts, error) {
+
+	res, err := a.ListRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListAccounts{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}
+
+// ListRaw gets a list of all accounts the user has access to as an array of bytes
+func (a Account) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/list"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/account/list_computes.go

@@ -0,0 +1,85 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListComputesRequest struct to get a list of compute instances
+type ListComputesRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Find by compute id
+	// Required: false
+	ComputeID uint64 `url:"computeId,omitempty" json:"computeId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,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"`
+}
+
+// ListComputes gets list all compute instances under specified account, accessible by the user
+func (a Account) ListComputes(ctx context.Context, req ListComputesRequest) (*ListComputes, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listComputes"
+
+	res, err := a.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/account/list_deleted.go

@@ -0,0 +1,61 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListDeletedRequest struct to get a list of deleted accounts
+type ListDeletedRequest struct {
+	// 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 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 access control list
+	// Required: false
+	ACL string `url:"acl,omitempty" json:"acl,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+}
+
+// ListDeleted gets list of all deleted accounts the user has access to
+func (a Account) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListAccounts, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listDeleted"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListAccounts{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/list_disks.go

@@ -0,0 +1,69 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListDisksRequest struct to get a list of deleted disks
+type ListDisksRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Find by disk id
+	// Required: false
+	DiskID uint64 `url:"diskId,omitempty" json:"diskId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by max size disk
+	// Required: false
+	DiskMaxSize uint64 `url:"diskMaxSize,omitempty" json:"diskMaxSize,omitempty"`
+
+	// Type of the disks
+	// Required: false
+	Type string `url:"type,omitempty" json:"type,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"`
+}
+
+// ListDisks gets list all currently unattached disks under specified account
+func (a Account) ListDisks(ctx context.Context, req ListDisksRequest) (*ListDisks, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listDisks"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListDisks{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/list_flipgroups.go

@@ -0,0 +1,77 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListFLIPGroupsRequest struct to get a list of FLIPGroups
+type ListFLIPGroupsRequest struct {
+	// ID of the account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by vinsId
+	// Required: false
+	VINSID uint64 `url:"vinsId,omitempty" json:"vinsId,omitempty"`
+
+	// Find by VINS name
+	// Required: false
+	VINSName string `url:"vinsName,omitempty" json:"vinsName,omitempty"`
+
+	// Find by external network id
+	// Required: false
+	ExtNetID uint64 `url:"extnetId,omitempty" json:"extnetId,omitempty"`
+
+	// Find by IP
+	// Required: false
+	ByIP string `url:"byIp,omitempty" json:"byIp,omitempty"`
+
+	// Find by flipGroup Id
+	// Required: false
+	FLIPGroupID uint64 `url:"flipGroupId,omitempty" json:"flipGroupId,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"`
+}
+
+// ListFLIPGroups gets list all FLIPGroups under specified account, accessible by the user
+func (a Account) ListFLIPGroups(ctx context.Context, req ListFLIPGroupsRequest) (*ListFLIPGroups, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listFlipGroups"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListFLIPGroups{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/list_resource_consumption.go

@@ -0,0 +1,26 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+)
+
+// ListResourceConsumption show data list amount of consumed and reserved resources (cpu, ram, disk) by specific accounts
+func (a Account) ListResourceConsumption(ctx context.Context) (*ListResourceConsumption, error) {
+	url := "/cloudapi/account/listResourceConsumption"
+
+	info := ListResourceConsumption{}
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudapi/account/list_rg.go

@@ -0,0 +1,73 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListRGRequest struct to get a list of resource groups
+type ListRGRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// 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 resource group id
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by vinsId
+	// Required: false
+	VINSID uint64 `url:"vinsId,omitempty" json:"vinsId,omitempty"`
+
+	// Find by VM ID
+	// Required: false
+	VMID uint64 `url:"vmId,omitempty" json:"vmId,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"`
+}
+
+// ListRG gets list of all resource groups under specified account, accessible by the user
+func (a Account) ListRG(ctx context.Context, req ListRGRequest) (*ListRG, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listRG"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListRG{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/list_templates.go

@@ -0,0 +1,69 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListTemplatesRequest struct to get a list of templates
+type ListTemplatesRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Include deleted images
+	// Required: false
+	IncludeDeleted bool `url:"includedeleted,omitempty" json:"includedeleted,omitempty"`
+
+	// Find by image id
+	// Required: false
+	ImageID uint64 `url:"imageId,omitempty" json:"imageId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by type
+	// Required: false
+	Type string `url:"type,omitempty" json:"type,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"`
+}
+
+// ListTemplates gets list of templates which can be managed by this account
+func (a Account) ListTemplates(ctx context.Context, req ListTemplatesRequest) (*ListTemplates, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listTemplates"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListTemplates{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/list_vins.go

@@ -0,0 +1,69 @@
+package account
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListVINSRequest struct to get a list of VINS
+type ListVINSRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Find by VINS ID
+	// Required: false
+	VINSID uint64 `url:"vins,omitempty" json:"vinsId,omitempty"`
+
+	// Find by name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Find by resource group id
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,omitempty"`
+
+	// Find by external network ip
+	// Required: false
+	ExtIP string `url:"extIp,omitempty" json:"extIp,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"`
+}
+
+// ListVINS gets list of all ViNSes under specified account, accessible by the user
+func (a Account) ListVINS(ctx context.Context, req ListVINSRequest) (*ListVINS, error) {
+
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/listVins"
+
+	res, err := a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListVINS{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/account/models.go

@@ -0,0 +1,661 @@
+package account
+
+// Access Control List
+type RecordACL struct {
+	// Whether access is explicitly specified
+	IsExplicit bool `json:"explicit"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// Access rights
+	Rights string `json:"right"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Account Type
+	Type string `json:"type"`
+
+	// Account owner ID
+	UgroupID string `json:"userGroupId"`
+
+	// Is it possible to remove
+	CanBeDeleted bool `json:"canBeDeleted"`
+}
+
+// Resource limits
+type ResourceLimits struct {
+	// Number of cores
+	CUC float64 `json:"CU_C"`
+
+	// Disk size, GB
+	CUD float64 `json:"CU_D"`
+
+	// Max disk size, GB
+	CUDM float64 `json:"CU_DM"`
+
+	// Number of public IP addresses
+	CUI float64 `json:"CU_I"`
+
+	// RAM size, MB
+	CUM float64 `json:"CU_M"`
+
+	// Traffic volume, GB
+	CUNP float64 `json:"CU_NP"`
+
+	// Number of graphics cores
+	GPUUnits float64 `json:"gpu_units"`
+}
+
+// Main information in one of if the list of accounts
+type ItemAccount struct {
+	// Access Control List
+	ACL []RecordACL `json:"acl"`
+
+	// Compute Features
+	ComputeFeatures []string `json:"computeFeatures"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+}
+
+// List of accounts
+type ListAccounts struct {
+	Data []ItemAccount `json:"data"`
+
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Resources used
+type Resource struct {
+	// Number of cores
+	CPU int64 `json:"cpu"`
+
+	// Disk size
+	DiskSize float64 `json:"disksize"`
+
+	// Max disk size
+	DiskSizeMax float64 `json:"disksizemax"`
+
+	// Number of External IPs
+	ExtIPs int64 `json:"extips"`
+
+	// External traffic
+	ExtTraffic int64 `json:"exttraffic"`
+
+	// Number of grafic cores
+	GPU int64 `json:"gpu"`
+
+	// Number of RAM
+	RAM int64 `json:"ram"`
+
+	// SEPs
+	SEPs map[string]map[string]DiskUsage `json:"seps"`
+}
+
+// Disk usage
+type DiskUsage struct {
+	// Disk size
+	DiskSize float64 `json:"disksize"`
+
+	// Disk size max
+	DiskSizeMax float64 `json:"disksizemax"`
+}
+
+// Information about resource consumption
+type RecordResourceConsumption struct {
+	ItemResourceConsumption
+
+	// Resource limits
+	ResourceLimits ResourceLimits `json:"resourceLimits"`
+}
+
+// Information about resources
+type ItemResourceConsumption struct {
+	// Current information about resources
+	Consumed Resource `json:"consumed"`
+
+	// Reserved information about resources
+	Reserved Resource `json:"reserved"`
+
+	// Account ID
+	AccountID uint64 `json:"id"`
+}
+
+type ListResourceConsumption struct {
+	Data []ItemResourceConsumption `json:"data"`
+
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Information about computes
+type Computes struct {
+	// Number of started computes
+	Started uint64 `json:"started"`
+
+	// Number of stopped computes
+	Stopped uint64 `json:"stopped"`
+}
+
+// Information about machines
+type Machines struct {
+	// Number of running machines
+	Running uint64 `json:"running"`
+
+	// Number of halted machines
+	Halted uint64 `json:"halted"`
+}
+
+// Main information about account
+type RecordAccount struct {
+	// DCLocation
+	DCLocation string `json:"DCLocation"`
+
+	// CKey
+	CKey string `json:"_ckey"`
+
+	// Access control list
+	ACL []RecordACL `json:"acl"`
+
+	// Company
+	Company string `json:"company"`
+
+	// Company URL
+	CompanyURL string `json:"companyurl"`
+
+	// Compute Features
+	ComputeFeatures []string `json:"computeFeatures"`
+
+	// Computes
+	Computes Computes `json:"computes"`
+
+	// CPU allocation parameter
+	CPUAllocationParameter string `json:"cpu_allocation_parameter"`
+
+	// CPU allocation ratio
+	CPUAllocationRatio float64 `json:"cpu_allocation_ratio"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deactivation time
+	DeactivationTime float64 `json:"deactivationTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Display name
+	DisplayName string `json:"displayname"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Machines
+	Machines Machines `json:"machines"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Resource limits
+	ResourceLimits ResourceLimits `json:"resourceLimits"`
+
+	// Resource types
+	ResTypes []string `json:"resourceTypes"`
+
+	// Send access emails
+	SendAccessEmails bool `json:"sendAccessEmails"`
+
+	// Status
+	Status string `json:"status"`
+
+	// UniqPools
+	UniqPools []interface{} `json:"uniqPools"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// Version
+	Version uint64 `json:"version"`
+
+	// VINS
+	VINS []uint64 `json:"vins"`
+
+	// VINSes
+	VINSes uint64 `json:"vinses"`
+}
+
+// Main information about compute
+type ItemCompute struct {
+	// ID an account
+	AccountID uint64 `json:"accountId"`
+
+	// Account name
+	AccountName string `json:"accountName"`
+
+	// Number of CPU
+	CPUs uint64 `json:"cpus"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// ID compute
+	ComputeID uint64 `json:"id"`
+
+	// Compute name
+	ComputeName string `json:"name"`
+
+	// Number of RAM
+	RAM uint64 `json:"ram"`
+
+	// Registered or not
+	Registered bool `json:"registered"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group Name
+	RGName string `json:"rgName"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Tech status
+	TechStatus string `json:"techStatus"`
+
+	// Total disks size
+	TotalDisksSize uint64 `json:"totalDisksSize"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// User controlled or not
+	UserManaged bool `json:"userManaged"`
+
+	// Number of connected VINS
+	VINSConnected uint64 `json:"vinsConnected"`
+}
+
+// List of computes
+type ListComputes struct {
+	// Data
+	Data []ItemCompute `json:"data"`
+
+	// Entry count
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main information about disk
+type ItemDisk struct {
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Pool
+	Pool string `json:"pool"`
+
+	// ID SEP
+	SEPID uint64 `json:"sepId"`
+
+	// Shareable
+	Shareable bool `json:"shareable"`
+
+	// Max size
+	SizeMax uint64 `json:"sizeMax"`
+
+	// Disk type
+	Type string `json:"type"`
+}
+
+// List of disks
+type ListDisks struct {
+	// Data
+	Data []ItemDisk `json:"data"`
+
+	// Entry count
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main information about VINS
+type ItemVINS struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Name of account
+	AccountName string `json:"accountName"`
+
+	// Number of computes
+	Computes uint64 `json:"computes"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// External IP
+	ExternalIP string `json:"externalIP"`
+
+	// Extnet ID
+	ExtnetId uint64 `json:"extnetId"`
+
+	// Free IPs
+	FreeIPs int64 `json:"freeIPs"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Network
+	Network string `json:"network"`
+
+	// NNFDev ID
+	PriVNFDevID uint64 `json:"priVnfDevId"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group name
+	RGName string `json:"rgName"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+}
+
+// List of VINS
+type ListVINS struct {
+	// Data
+	Data []ItemVINS `json:"data"`
+
+	// Entry count
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main info about audit
+type ItemAudit struct {
+	// Call
+	Call string `json:"call"`
+
+	// Response time
+	ResponseTime float64 `json:"responsetime"`
+
+	// Status code
+	StatusCode uint64 `json:"statuscode"`
+
+	// Timestamp
+	Timestamp float64 `json:"timestamp"`
+
+	// User
+	User string `json:"user"`
+}
+
+// List of audits
+type ListAudits []ItemAudit
+
+// Information compute in resource group
+type RGComputes struct {
+	// Number of started computes
+	Started uint64 `json:"Started"`
+
+	// Number of stopped computes
+	Stopped uint64 `json:"Stopped"`
+}
+
+// Resources of Resource group
+type RGResources struct {
+	// Consumed
+	Consumed Resource `json:"Consumed"`
+
+	// Limits
+	Limits LimitsRG `json:"Limits"`
+
+	// Reserved
+	Reserved Resource `json:"Reserved"`
+}
+
+// Resources used
+type LimitsRG struct {
+	// Number of cores
+	CPU int64 `json:"cpu"`
+
+	// Disk size
+	DiskSize int64 `json:"disksize"`
+
+	// Max disk size
+	DiskSizeMax int64 `json:"disksizemax"`
+
+	// Number of External IPs
+	ExtIPs int64 `json:"extips"`
+
+	// External traffic
+	ExtTraffic int64 `json:"exttraffic"`
+
+	// Number of grafic cores
+	GPU int64 `json:"gpu"`
+
+	// Number of RAM
+	RAM int64 `json:"ram"`
+
+	// SEPs
+	SEPs uint64 `json:"seps"`
+}
+
+// Main information about resource group
+type ItemRG struct {
+	// Computes
+	Computes RGComputes `json:"Computes"`
+
+	// Resources
+	Resources RGResources `json:"Resources"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Resource group ID
+	RGID uint64 `json:"id"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Resource group name
+	RGName string `json:"name"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// Number of VINS
+	VINSes uint64 `json:"vinses"`
+}
+
+// List of Resource groups
+type ListRG struct {
+	// Data
+	Data []ItemRG `json:"data"`
+
+	// Enrtry count
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main information about template
+type ItemTemplate struct {
+	// UNCPath
+	UNCPath string `json:"UNCPath"`
+
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Description
+	Description string `json:"desc"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Public or not
+	Public bool `json:"public"`
+
+	// Size
+	Size uint64 `json:"size"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Type
+	Type string `json:"type"`
+
+	// Username
+	Username string `json:"username"`
+}
+
+// List of templates
+type ListTemplates struct {
+	// Data
+	Data []ItemTemplate `json:"data"`
+
+	// Entry count
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main information about FLIPGroup
+type ItemFLIPGroup struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Client type
+	ClientType string `json:"clientType"`
+
+	// Connection type
+	ConnType string `json:"connType"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Default GW
+	DefaultGW string `json:"defaultGW"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Description
+	Description string `json:"desc"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// IP
+	IP string `json:"ip"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Network ID
+	NetID uint64 `json:"netId"`
+
+	// Network type
+	NetType string `json:"netType"`
+
+	// Network mask
+	NetMask uint64 `json:"netmask"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+}
+
+// List of FLIPGroups
+type ListFLIPGroups struct {
+	// Data
+	Data []ItemFLIPGroup `json:"data"`
+
+	// Entry count
+	EntryCount uint64 `json:"entryCount"`
+}

pkg/cloudapi/account/restore.go

@@ -0,0 +1,32 @@
+package account
+
+import (
+	"context"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RestoreRequest struct to restore a deleted account
+type RestoreRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+}
+
+// Restore restores a deleted account
+func (a Account) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/restore"
+
+	_, err = a.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	return true, nil
+}

pkg/cloudapi/account/serialize.go

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

pkg/cloudapi/account/sorting.go

@@ -0,0 +1,60 @@
+package account
+
+import "sort"
+
+// SortByCreatedTime sorts ListAccounts by the CreatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (la ListAccounts) SortByCreatedTime(inverse bool) ListAccounts {
+	if len(la.Data) < 2 {
+		return la
+	}
+
+	sort.Slice(la.Data, func(i, j int) bool {
+		if inverse {
+			return la.Data[i].CreatedTime > la.Data[j].CreatedTime
+		}
+
+		return la.Data[i].CreatedTime < la.Data[j].CreatedTime
+	})
+
+	return la
+}
+
+// SortByUpdatedTime sorts ListAccounts by the UpdatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (la ListAccounts) SortByUpdatedTime(inverse bool) ListAccounts {
+	if len(la.Data) < 2 {
+		return la
+	}
+
+	sort.Slice(la.Data, func(i, j int) bool {
+		if inverse {
+			return la.Data[i].UpdatedTime > la.Data[j].UpdatedTime
+		}
+
+		return la.Data[i].UpdatedTime < la.Data[j].UpdatedTime
+	})
+
+	return la
+}
+
+// SortByDeletedTime sorts ListAccounts by the DeletedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (la ListAccounts) SortByDeletedTime(inverse bool) ListAccounts {
+	if len(la.Data) < 2 {
+		return la
+	}
+
+	sort.Slice(la.Data, func(i, j int) bool {
+		if inverse {
+			return la.Data[i].DeletedTime > la.Data[j].DeletedTime
+		}
+
+		return la.Data[i].DeletedTime < la.Data[j].DeletedTime
+	})
+
+	return la
+}

pkg/cloudapi/account/update.go

@@ -0,0 +1,75 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UpdateRequest struct to update account
+type UpdateRequest struct {
+	// ID an account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Name of the account
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Max size of memory in MB
+	// Required: false
+	MaxMemoryCapacity int64 `url:"maxMemoryCapacity,omitempty" json:"maxMemoryCapacity,omitempty"`
+
+	// Max size of aggregated vdisks in GB
+	// Required: false
+	MaxVDiskCapacity int64 `url:"maxVDiskCapacity,omitempty" json:"maxVDiskCapacity,omitempty"`
+
+	// Max number of CPU cores
+	// Required: false
+	MaxCPUCapacity int64 `url:"maxCPUCapacity,omitempty" json:"maxCPUCapacity,omitempty"`
+
+	// Max sent/received network transfer peering
+	// Required: false
+	MaxNetworkPeerTransfer int64 `url:"maxNetworkPeerTransfer,omitempty" json:"maxNetworkPeerTransfer,omitempty"`
+
+	// Max number of assigned public IPs
+	// Required: false
+	MaxNumPublicIP int64 `url:"maxNumPublicIP,omitempty" json:"maxNumPublicIP,omitempty"`
+
+	// If true send emails when a user is granted access to resources
+	// Required: false
+	SendAccessEmails bool `url:"sendAccessEmails" json:"sendAccessEmails"`
+
+	// Limit (positive) or disable (0) GPU resources
+	// Required: false
+	GPUUnits int64 `url:"gpu_units,omitempty" json:"gpu_units,omitempty"`
+
+	// List of strings with pools
+	// i.e.: ["sep1_poolName1", "sep2_poolName2", etc]
+	// Required: false
+	UniqPools []string `url:"uniqPools,omitempty" json:"uniqPools,omitempty"`
+}
+
+// Update updates an account name and resource types and limits
+func (a Account) Update(ctx context.Context, req UpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/update"
+
+	res, err := a.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/account/update_user.go

@@ -0,0 +1,49 @@
+package account
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// UpdateUserRequest struct to update user access rights
+type UpdateUserRequest struct {
+	// ID of the account
+	// Required: true
+	AccountID uint64 `url:"accountId" json:"accountId" validate:"required"`
+
+	// Userid/Email for registered users or emailaddress for unregistered users
+	// Required: true
+	UserID string `url:"userId" json:"userId" validate:"required"`
+
+	// Account permission types:
+	//	- 'R' for read only access
+	//	- 'RCX' for Write
+	//	- 'ARCXDU' for Admin
+	// Required: true
+	AccessType string `url:"accesstype" json:"accesstype" validate:"required,accessType"`
+}
+
+// UpdateUser updates user access rights
+func (a Account) UpdateUser(ctx context.Context, req UpdateUserRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/account/updateUser"
+
+	res, err := a.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/audit.go

@@ -0,0 +1,10 @@
+package cloudapi
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudapi/audit"
+)
+
+// Accessing the Stack method group
+func (ca *CloudAPI) Audit() *audit.Audit {
+	return audit.New(ca.client)
+}

pkg/cloudapi/audit/audit.go

@@ -0,0 +1,15 @@
+package audit
+
+import "repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/interfaces"
+
+// Structure for creating request to audit
+type Audit struct {
+	client interfaces.Caller
+}
+
+// Builder for audit endpoint
+func New(client interfaces.Caller) *Audit {
+	return &Audit{
+		client: client,
+	}
+}

pkg/cloudapi/audit/get.go

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

pkg/cloudapi/audit/models.go

@@ -0,0 +1,41 @@
+package audit
+
+// Main info about audit
+type RecordAudit struct {
+
+	// Arguments
+	Arguments string `json:"args"`
+
+	// Call
+	Call string `json:"call"`
+
+	// GUID
+	GUID string `json:"guid"`
+
+	// Kwargs
+	Kwargs string `json:"kwargs"`
+
+	// RemoteAddr
+	RemoteAddr string `json:"remote_addr"`
+
+	// Response time
+	ResponseTime float64 `json:"responsetime"`
+
+	// Result
+	Result string `json:"result"`
+
+	// Status code
+	StatusCode uint64 `json:"statuscode"`
+
+	// Tags
+	Tags string `json:"tags"`
+
+	// Timestamp
+	Timestamp float64 `json:"timestamp"`
+
+	// TimestampEnd
+	TimestampEnd float64 `json:"timestampEnd"`
+
+	// User
+	User string `json:"user"`
+}

pkg/cloudapi/bservice.go

@@ -0,0 +1,8 @@
+package cloudapi
+
+import "repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudapi/bservice"
+
+// Accessing the BService method group
+func (ca *CloudAPI) BService() *bservice.BService {
+	return bservice.New(ca.client)
+}

pkg/cloudapi/bservice/bservice.go

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

pkg/cloudapi/bservice/create.go

@@ -0,0 +1,50 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CreateRequest struct for BasicService
+type CreateRequest struct {
+	// Name of the service
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// ID of the Resource Group where this service will be placed
+	// Required: true
+	RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
+
+	// Name of the user to deploy SSH key for. Pass empty string if no SSH key deployment is required
+	// Required: false
+	SSHUser string `url:"sshUser,omitempty" json:"sshUser,omitempty"`
+
+	// SSH key to deploy for the specified user. Same key will be deployed to all computes of the service
+	// Required: false
+	SSHKey string `url:"sshKey,omitempty" json:"sshKey,omitempty"`
+}
+
+// Create creates blank BasicService instance
+func (b BService) Create(ctx context.Context, req CreateRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/create"
+
+	res, err := b.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/bservice/delete.go

@@ -0,0 +1,42 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteRequest struct to delete basic service
+type DeleteRequest struct {
+	// ID of the BasicService to be delete
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// If set to False, Basic service will be deleted to recycle bin. Otherwise destroyed immediately
+	// Required: false
+	Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
+}
+
+// Delete deletes BasicService instance
+func (b BService) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/delete"
+
+	res, err := b.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/bservice/disable.go

@@ -0,0 +1,40 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DisableRequest struct for disable service
+type DisableRequest struct {
+	// ID of the service to disable
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Disable disables service.
+// Disabling a service technically means setting model status
+// of all computes and service itself to DISABLED and stopping all computes.
+func (b BService) Disable(ctx context.Context, req DisableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/disable"
+
+	res, err := b.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/bservice/enable.go

@@ -0,0 +1,41 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// EnableRequest struct to disable service
+type EnableRequest struct {
+	// ID of the service to enable
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Enable enables service.
+// Enabling a service technically means setting model status of
+// all computes and service itself to ENABLED.
+// It does not start computes.
+func (b BService) Enable(ctx context.Context, req EnableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/enable"
+
+	res, err := b.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/bservice/filter.go

@@ -0,0 +1,71 @@
+package bservice
+
+// FilterByID returns ListBasicServices with specified ID.
+func (lbs ListBasicServices) FilterByID(id uint64) ListBasicServices {
+	predicate := func(ibs ItemBasicService) bool {
+		return ibs.ID == id
+	}
+
+	return lbs.FilterFunc(predicate)
+}
+
+// FilterByName returns ListBasicServices with specified Name.
+func (lbs ListBasicServices) FilterByName(name string) ListBasicServices {
+	predicate := func(ibs ItemBasicService) bool {
+		return ibs.Name == name
+	}
+
+	return lbs.FilterFunc(predicate)
+}
+
+// FilterByRGID returns ListBasicServices with specified RGID.
+func (lbs ListBasicServices) FilterByRGID(rgID uint64) ListBasicServices {
+	predicate := func(ibs ItemBasicService) bool {
+		return ibs.RGID == rgID
+	}
+
+	return lbs.FilterFunc(predicate)
+}
+
+// FilterByStatus returns ListBasicServices with specified Status.
+func (lbs ListBasicServices) FilterByStatus(status string) ListBasicServices {
+	predicate := func(ibs ItemBasicService) bool {
+		return ibs.Status == status
+	}
+
+	return lbs.FilterFunc(predicate)
+}
+
+// FilterByTechStatus returns ListBasicServices with specified TechStatus.
+func (lbs ListBasicServices) FilterByTechStatus(techStatus string) ListBasicServices {
+	predicate := func(ibs ItemBasicService) bool {
+		return ibs.TechStatus == techStatus
+	}
+
+	return lbs.FilterFunc(predicate)
+}
+
+// FilterFunc allows filtering ListResourceGroups based on a user-specified predicate.
+func (lbs ListBasicServices) FilterFunc(predicate func(ItemBasicService) bool) ListBasicServices {
+	var result ListBasicServices
+
+	for _, item := range lbs.Data {
+		if predicate(item) {
+			result.Data = append(result.Data, item)
+		}
+	}
+
+	result.EntryCount = uint64(len(lbs.Data))
+
+	return result
+}
+
+// FindOne returns first found ItemBasicService
+// If none was found, returns an empty struct.
+func (lbs ListBasicServices) FindOne() ItemBasicService {
+	if lbs.EntryCount == 0 {
+		return ItemBasicService{}
+	}
+
+	return lbs.Data[0]
+}

pkg/cloudapi/bservice/filter_test.go

@@ -0,0 +1,155 @@
+package bservice
+
+import "testing"
+
+var bservices = ListBasicServices{
+	Data: []ItemBasicService{
+		{
+			AccountID:     1,
+			AccountName:   "std_1",
+			BaseDomain:    "",
+			CreatedBy:     "sample_user_1@decs3o",
+			CreatedTime:   1677743675,
+			DeletedBy:     "",
+			DeletedTime:   0,
+			GID:           212,
+			Groups:        []uint64{},
+			GUID:          1,
+			ID:            1,
+			Name:          "bservice_1",
+			ParentSrvID:   0,
+			ParentSrvType: "",
+			RGID:          7971,
+			RGName:        "rg_1",
+			SSHUser:       "",
+			Status:        "CREATED",
+			TechStatus:    "STOPPED",
+			UpdatedBy:     "",
+			UpdatedTime:   0,
+			UserManaged:   true,
+		},
+		{
+			AccountID:     2,
+			AccountName:   "std_2",
+			BaseDomain:    "",
+			CreatedBy:     "sample_user_1@decs3o",
+			CreatedTime:   1677743736,
+			DeletedBy:     "",
+			DeletedTime:   0,
+			GID:           212,
+			Groups:        []uint64{},
+			GUID:          2,
+			ID:            2,
+			Name:          "bservice_2",
+			ParentSrvID:   0,
+			ParentSrvType: "",
+			RGID:          7972,
+			RGName:        "rg_2",
+			SSHUser:       "",
+			Status:        "CREATED",
+			TechStatus:    "STOPPED",
+			UpdatedBy:     "",
+			UpdatedTime:   0,
+			UserManaged:   true,
+		},
+		{
+			AccountID:     3,
+			AccountName:   "std_3",
+			BaseDomain:    "",
+			CreatedBy:     "sample_user_2@decs3o",
+			CreatedTime:   1677743830,
+			DeletedBy:     "",
+			DeletedTime:   0,
+			GID:           212,
+			Groups:        []uint64{},
+			GUID:          3,
+			ID:            3,
+			Name:          "bservice_3",
+			ParentSrvID:   0,
+			ParentSrvType: "",
+			RGID:          7973,
+			RGName:        "rg_3",
+			SSHUser:       "",
+			Status:        "ENABLED",
+			TechStatus:    "STARTED",
+			UpdatedBy:     "",
+			UpdatedTime:   0,
+			UserManaged:   true,
+		},
+	},
+	EntryCount: 3,
+}
+
+func TestFilterByID(t *testing.T) {
+	actual := bservices.FilterByID(1).FindOne()
+
+	if actual.ID != 1 {
+		t.Fatal("expected ID 1, found: ", actual.ID)
+	}
+}
+
+func TestFilterByName(t *testing.T) {
+	actual := bservices.FilterByName("bservice_3").FindOne()
+
+	if actual.Name != "bservice_3" {
+		t.Fatal("expected Name 'bservice_3', found: ", actual.Name)
+	}
+}
+
+func TestFilterByRGID(t *testing.T) {
+	actual := bservices.FilterByRGID(7971).FindOne()
+
+	if actual.RGID != 7971 {
+		t.Fatal("expected RGID 7971, found: ", actual.RGID)
+	}
+}
+
+func TestFilterByStatus(t *testing.T) {
+	actual := bservices.FilterByStatus("CREATED")
+
+	if len(actual.Data) != 2 {
+		t.Fatal("expected 2 found, actual: ", len(actual.Data))
+	}
+
+	for _, item := range actual.Data {
+		if item.Status != "CREATED" {
+			t.Fatal("expected Status 'CREATED', found: ", item.Status)
+		}
+	}
+}
+
+func TestFilterByTechStatus(t *testing.T) {
+	actual := bservices.FilterByTechStatus("STOPPED")
+
+	if len(actual.Data) != 2 {
+		t.Fatal("expected 2 found, actual: ", len(actual.Data))
+	}
+
+	for _, item := range actual.Data {
+		if item.TechStatus != "STOPPED" {
+			t.Fatal("expected TechStatus 'STOPPED', found: ", item.TechStatus)
+		}
+	}
+}
+
+func TestFilterFunc(t *testing.T) {
+	actual := bservices.FilterFunc(func(ibs ItemBasicService) bool {
+		return ibs.CreatedBy == "sample_user_2@decs3o"
+	})
+
+	if len(actual.Data) > 1 {
+		t.Fatal("expected 1 found, actual: ", len(actual.Data))
+	}
+
+	if actual.FindOne().CreatedBy != "sample_user_2@decs3o" {
+		t.Fatal("expected 'sample_user_2@decs3o', found: ", actual.FindOne().CreatedBy)
+	}
+}
+
+func TestSortByCreatedTime(t *testing.T) {
+	actual := bservices.SortByCreatedTime(true)
+
+	if actual.Data[0].CreatedTime != 1677743830 || actual.Data[2].CreatedTime != 1677743675 {
+		t.Fatal("expected descending order, found ascending")
+	}
+}

pkg/cloudapi/bservice/get.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GetRequest struct to get detailed information about service
+type GetRequest struct {
+	// ID of the service to query information
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Get gets detailed specifications for the BasicService as a RecordBasicService struct
+func (b BService) Get(ctx context.Context, req GetRequest) (*RecordBasicService, error) {
+	res, err := b.GetRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordBasicService{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}
+
+// GetRaw gets detailed specifications for the BasicService as an array of bytes
+func (b BService) GetRaw(ctx context.Context, req GetRequest) ([]byte, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/get"
+
+	res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/bservice/group_add.go

@@ -0,0 +1,108 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupAddRequest struct to create new compute group within BasicService
+type GroupAddRequest struct {
+	// ID of the Basic Service to add a group to
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// Name of the Compute Group to add
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// Computes number. Defines how many computes must be there in the group
+	// Required: true
+	Count uint64 `url:"count" json:"count" validate:"required"`
+
+	// Compute CPU number. All computes in the group have the same CPU count
+	// Required: true
+	CPU uint64 `url:"cpu" json:"cpu" validate:"required"`
+
+	// Compute RAM volume in MB. All computes in the group have the same RAM volume
+	// Required: true
+	RAM uint64 `url:"ram" json:"ram" validate:"required"`
+
+	// Compute boot disk size in GB
+	// Required: true
+	Disk uint64 `url:"disk" json:"disk" validate:"required"`
+
+	// OS image ID to create computes from
+	// Required: true
+	ImageID uint64 `url:"imageId" json:"imageId" validate:"required"`
+
+	// Compute driver
+	// should be one of:
+	//	- KVM_X86
+	// Required: true
+	Driver string `url:"driver" json:"driver" validate:"driver"`
+
+	// Storage endpoint provider ID
+	// Required: false
+	SEPID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
+
+	// Pool to use if sepId is set, can be also empty if needed to be chosen by system
+	// Required: false
+	SEPPool string `url:"sepPool,omitempty" json:"sepPool,omitempty"`
+
+	// Group role tag. Can be empty string, does not have to be unique
+	// Required: false
+	Role string `url:"role,omitempty" json:"role,omitempty"`
+
+	// List of ViNSes to connect computes to
+	// Required: false
+	VINSes []uint64 `url:"vinses,omitempty" json:"vinses,omitempty"`
+
+	// List of external networks to connect computes to
+	// Required: false
+	ExtNets []uint64 `url:"extnets,omitempty" json:"extnets,omitempty"`
+
+	// Time of Compute Group readiness
+	// Required: false
+	TimeoutStart uint64 `url:"timeoutStart,omitempty" json:"timeoutStart,omitempty"`
+
+	// Meta data for working group computes, format YAML "user_data": 1111
+	// Required: false
+	UserData string `url:"userData,omitempty" json:"userData,omitempty"`
+}
+
+// GetRAM returns RAM field values
+func (r GroupAddRequest) GetRAM() map[string]uint64 {
+
+	res := make(map[string]uint64, 1)
+
+	res["RAM"] = r.RAM
+
+	return res
+}
+
+// GroupAdd creates new Compute Group within BasicService.
+// Compute Group is NOT started automatically,
+// so you need to explicitly start it
+func (b BService) GroupAdd(ctx context.Context, req GroupAddRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupAdd"
+
+	res, err := b.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/bservice/group_compute_remove.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupComputeRemoveRequest struct to remove group compute
+type GroupComputeRemoveRequest struct {
+	// ID of the Basic Service
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute GROUP
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// ID of the Compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// GroupComputeRemove makes group compute remove of the Basic Service
+func (b BService) GroupComputeRemove(ctx context.Context, req GroupComputeRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupComputeRemove"
+
+	res, err := b.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/bservice/group_get.go

@@ -0,0 +1,44 @@
+package bservice
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupGetRequest struct to get detailed information about Compute Group
+type GroupGetRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+}
+
+// GroupGet gets detailed specifications for the Compute Group
+func (b BService) GroupGet(ctx context.Context, req GroupGetRequest) (*RecordGroup, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupGet"
+
+	res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	info := RecordGroup{}
+
+	err = json.Unmarshal(res, &info)
+	if err != nil {
+		return nil, err
+	}
+
+	return &info, nil
+}

pkg/cloudapi/bservice/group_parent_add.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupParentAddRequest struct to add parent Compute Group relation to the specified Compute Group
+type GroupParentAddRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// ID of the parent Compute Group to register with the current Compute Group
+	// Required: true
+	ParentID uint64 `url:"parentId" json:"parentId" validate:"required"`
+}
+
+// GroupParentAdd add parent Compute Group relation to the specified Compute Group
+func (b BService) GroupParentAdd(ctx context.Context, req GroupParentAddRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupParentAdd"
+
+	res, err := b.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/bservice/group_parent_remove.go

@@ -0,0 +1,48 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupParentRemoveRequest struct to remove parent Compute Group
+// relation from the specified Compute Group
+type GroupParentRemoveRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// ID of the parent Compute Group
+	// to remove from the current Compute Group
+	// Required: true
+	ParentID uint64 `url:"parentId" json:"parentId" validate:"required"`
+}
+
+// GroupParentRemove removes parent Compute Group relation to the specified Compute Group
+func (b BService) GroupParentRemove(ctx context.Context, req GroupParentRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupParentRemove"
+
+	res, err := b.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/bservice/group_remove.go

@@ -0,0 +1,43 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupRemoveRequest struct for destroy the specified Compute Group
+type GroupRemoveRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+}
+
+// GroupRemove destroy the specified Compute Group
+func (b BService) GroupRemove(ctx context.Context, req GroupRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupRemove"
+
+	res, err := b.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/bservice/group_resize.go

@@ -0,0 +1,53 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupResizeRequest struct to resize the group
+type GroupResizeRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group to resize
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// Either delta or absolute value of computes
+	// Required: true
+	Count int64 `url:"count" json:"count" validate:"required"`
+
+	// Either delta or absolute value of computes
+	// Should be one of:
+	//	- ABSOLUTE
+	//	- RELATIVE
+	// Required: true
+	Mode string `url:"mode" json:"mode" validate:"bserviceMode"`
+}
+
+// GroupResize resize the group by changing the number of computes
+func (b BService) GroupResize(ctx context.Context, req GroupResizeRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupResize"
+
+	res, err := b.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/bservice/group_start.go

@@ -0,0 +1,42 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupStartRequest struct to start the specified Compute Group
+type GroupStartRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group to start
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+}
+
+// GroupStart starts the specified Compute Group within BasicService
+func (b BService) GroupStart(ctx context.Context, req GroupStartRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupStart"
+
+	res, err := b.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/bservice/group_stop.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupStopRequest struct to stop the specified Compute Group
+type GroupStopRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group to stop
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// Force stop Compute Group
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+}
+
+// GroupStop stops the specified Compute Group within BasicService
+func (b BService) GroupStop(ctx context.Context, req GroupStopRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupStop"
+
+	res, err := b.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/bservice/group_update.go

@@ -0,0 +1,76 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupUpdateRequest struct to update existing Compute group
+type GroupUpdateRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// Specify non-empty string to update Compute Group name
+	// Required: false
+	Name string `url:"name,omitempty" json:"name,omitempty"`
+
+	// Specify non-empty string to update group role
+	// Required: false
+	Role string `url:"role,omitempty" json:"role,omitempty"`
+
+	// Specify positive value to set new compute CPU count
+	// Required: false
+	CPU uint64 `url:"cpu,omitempty" json:"cpu,omitempty"`
+
+	// Specify positive value to set new compute RAM volume in MB
+	// Required: false
+	RAM uint64 `url:"ram,omitempty" json:"ram,omitempty"`
+
+	// Specify new compute boot disk size in GB
+	// Required: false
+	Disk uint64 `url:"disk,omitempty" json:"disk,omitempty"`
+
+	// Force resize Compute Group
+	// Required: false
+	Force bool `url:"force,omitempty" json:"force,omitempty"`
+}
+
+// GetRAM returns RAM field values
+func (r GroupUpdateRequest) GetRAM() map[string]uint64 {
+
+	res := make(map[string]uint64, 1)
+
+	res["RAM"] = r.RAM
+
+	return res
+}
+
+// GroupUpdate updates existing Compute group within Basic Service and apply new settings to its computes as necessary
+func (b BService) GroupUpdate(ctx context.Context, req GroupUpdateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupUpdate"
+
+	res, err := b.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/bservice/group_update_extnet.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupUpdateExtNetRequest struct to update External Network settings
+type GroupUpdateExtNetRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// List of Extnets to connect computes
+	// Required: false
+	ExtNets []uint64 `url:"extnets,omitempty" json:"extnets,omitempty"`
+}
+
+// GroupUpdateExtNet updates External Network settings for the group according to the new list
+func (b BService) GroupUpdateExtNet(ctx context.Context, req GroupUpdateExtNetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupUpdateExtnet"
+
+	res, err := b.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/bservice/group_update_vins.go

@@ -0,0 +1,46 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// GroupUpdateVINSRequest struct to update VINS settings
+type GroupUpdateVINSRequest struct {
+	// ID of the Basic Service of Compute Group
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// ID of the Compute Group
+	// Required: true
+	CompGroupID uint64 `url:"compgroupId" json:"compgroupId" validate:"required"`
+
+	// List of ViNSes to connect computes
+	// Required: false
+	VINSes []uint64 `url:"vinses,omitempty" json:"vinses,omitempty"`
+}
+
+// GroupUpdateVINS update ViNS settings for the group according to the new list
+func (b BService) GroupUpdateVINS(ctx context.Context, req GroupUpdateVINSRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/groupUpdateVins"
+
+	res, err := b.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/bservice/ids.go

@@ -0,0 +1,37 @@
+package bservice
+
+// IDs gets array of BasicServiceIDs from ListBasicServices struct
+func (lbs ListBasicServices) IDs() []uint64 {
+	res := make([]uint64, 0, len(lbs.Data))
+	for _, bs := range lbs.Data {
+		res = append(res, bs.ID)
+	}
+	return res
+}
+
+// IDs gets array of ComputeIDs from ListComputes struct
+func (lc ListComputes) IDs() []uint64 {
+	res := make([]uint64, 0, len(lc))
+	for _, c := range lc {
+		res = append(res, c.ID)
+	}
+	return res
+}
+
+// IDs gets array of GroupIDs from ListGroups struct
+func (lg ListGroups) IDs() []uint64 {
+	res := make([]uint64, 0, len(lg))
+	for _, g := range lg {
+		res = append(res, g.ID)
+	}
+	return res
+}
+
+// IDs gets array of GroupComputeIDs from ListGroupComputes struct
+func (lgc ListGroupComputes) IDs() []uint64 {
+	res := make([]uint64, 0, len(lgc))
+	for _, gc := range lgc {
+		res = append(res, gc.ID)
+	}
+	return res
+}

pkg/cloudapi/bservice/list.go

@@ -0,0 +1,87 @@
+package bservice
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListRequest struct to get list of BasicService instances
+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"`
+
+	// ID of the account to query for BasicService instances
+	// 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"`
+
+	// ID of the resource group to query for BasicService instances
+	// 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 account name
+	// Required: false
+	AccountName string `url:"accountName,omitempty" json:"accountName,omitempty"`
+
+	// Sort by one of supported fields, format +|-(field)
+	// Required: false
+	SortBy string `url:"sortBy,omitempty" json:"sortBy,omitempty" validate:"omitempty,sortBy"`
+
+	// Page number
+	// Required: false
+	Page uint64 `url:"page,omitempty" json:"page,omitempty"`
+
+	// Page size
+	// Required: false
+	Size uint64 `url:"size,omitempty" json:"size,omitempty"`
+}
+
+// List gets list of BasicService instances associated with the specified Resource Group as a ListBasicServices struct
+func (b BService) List(ctx context.Context, req ListRequest) (*ListBasicServices, error) {
+
+	res, err := b.ListRaw(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListBasicServices{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}
+
+// ListRaw gets list of BasicService instances associated with the specified Resource Group as an array of bytes
+func (b BService) ListRaw(ctx context.Context, req ListRequest) ([]byte, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/list"
+
+	res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	return res, err
+}

pkg/cloudapi/bservice/list_deleted.go

@@ -0,0 +1,56 @@
+package bservice
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// ListDeletedRequest struct to get list of deleted BasicService instances
+type ListDeletedRequest struct {
+	// ID of the account to query for BasicService instances
+	// Required: false
+	AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
+
+	// ID of the resource group to query for BasicService instances
+	// Required: false
+	RGID uint64 `url:"rgId,omitempty" json:"rgId,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 of deleted BasicService instances associated with the specified Resource Group
+func (b BService) ListDeleted(ctx context.Context, req ListDeletedRequest) (*ListBasicServices, error) {
+
+	if err := validators.ValidateRequest(req); err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/listDeleted"
+
+	res, err := b.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListBasicServices{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return &list, nil
+}

pkg/cloudapi/bservice/models.go

@@ -0,0 +1,389 @@
+package bservice
+
+// Detailed info about BasicService
+type RecordBasicService struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Account name
+	AccountName string `json:"accountName"`
+
+	// Base domain
+	BaseDomain string `json:"baseDomain"`
+
+	// List Computes
+	Computes ListComputes `json:"computes"`
+
+	// Number of cores
+	CPUTotal uint64 `json:"cpuTotal"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Amount of disk space used, GB
+	DiskTotal uint64 `json:"diskTotal"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// List of Service Compute Groups
+	Groups ListGroups `json:"groups"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Parent service ID
+	ParentSrvID uint64 `json:"parentSrvId"`
+
+	// Parent service type
+	ParentSrvType string `json:"parentSrvType"`
+
+	// Total amount of RAM, MB
+	RAMTotal uint64 `json:"ramTotal"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group name
+	RGName string `json:"rgName"`
+
+	// List of snapshots
+	Snapshots ListSnapshots `json:"snapshots"`
+
+	// SSH key for connection
+	SSHKey string `json:"sshKey"`
+
+	// Username for SSH connection
+	SSHUser string `json:"sshUser"`
+
+	// status
+	Status string `json:"status"`
+
+	// TechStatus
+	TechStatus string `json:"techStatus"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// Whether user controlled
+	UserManaged bool `json:"userManaged"`
+}
+
+// Main information about Compute
+type ItemCompute struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Architecture
+	Architecture string `json:"arch"`
+
+	// Compute group ID
+	CompGroupID uint64 `json:"compgroupId"`
+
+	// Compute group name
+	CompGroupName string `json:"compgroupName"`
+
+	// compute group role
+	CompGroupRole string `json:"compgroupRole"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// StackID
+	StackID uint64 `json:"stackId"`
+
+	// Status
+	Status string `json:"status"`
+
+	// Tech status
+	TechStatus string `json:"techStatus"`
+}
+
+// List of Computes
+type ListComputes []ItemCompute
+
+// Main information about Group
+type ItemGroup struct {
+	// Amount of computes
+	Computes uint64 `json:"computes"`
+
+	// Consistency
+	Consistency bool `json:"consistency"`
+
+	// Group ID
+	ID uint64 `json:"id"`
+
+	// Group name
+	Name string `json:"name"`
+
+	// Status
+	Status string `json:"status"`
+
+	// TechStatus
+	TechStatus string `json:"techStatus"`
+}
+
+// List of Groups
+type ListGroups []ItemGroup
+
+// Main information about Snapshot
+type ItemSnapshot struct {
+	// GUID
+	GUID string `json:"guid"`
+
+	// Label
+	Label string `json:"label"`
+
+	// Timestamp
+	Timestamp uint64 `json:"timestamp"`
+
+	// Valid or not
+	Valid bool `json:"valid"`
+}
+
+// List of Snapshot
+type ListSnapshots []ItemSnapshot
+
+// List of Snapshots
+type ListInfoSnapshots struct {
+	// Data
+	Data ListSnapshots `json:"data"`
+
+	// EntryCount
+	EntryCount uint64 `json:"entryCount"`
+}
+
+// Main information about Group
+type RecordGroup struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Account Name
+	AccountName string `json:"accountName"`
+
+	// List of Computes
+	Computes ListGroupComputes `json:"computes"`
+
+	// Consistency or not
+	Consistency bool `json:"consistency"`
+
+	// Number of CPU
+	CPU uint64 `json:"cpu"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Amount of disk
+	Disk uint64 `json:"disk"`
+
+	// Driver
+	Driver string `json:"driver"`
+
+	// list of External Network IDs
+	ExtNets []uint64 `json:"extnets"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Image ID
+	ImageID uint64 `json:"imageId"`
+
+	// Milestones
+	Milestones uint64 `json:"milestones"`
+
+	// Name
+	Name string `json:"name"`
+
+	// List of Parent IDs
+	Parents []uint64 `json:"parents"`
+
+	// Pool name
+	PoolName string `json:"poolName"`
+
+	// Number of RAM, MB
+	RAM uint64 `json:"ram"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group name
+	RGName string `json:"rgName"`
+
+	// Role
+	Role string `json:"role"`
+
+	// SEPID
+	SEPID uint64 `json:"sepId"`
+
+	// Sequence number
+	SeqNo uint64 `json:"seqNo"`
+
+	// Service ID
+	ServiceID uint64 `json:"serviceId"`
+
+	// Status
+	Status string `json:"status"`
+
+	// TechStatus
+	TechStatus string `json:"techStatus"`
+
+	// Timeout Start
+	TimeoutStart uint64 `json:"timeoutStart"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// List of VINS IDs
+	VINSes []uint64 `json:"vinses"`
+}
+
+// Main information about Group Compute
+type ItemGroupCompute struct {
+	// ID
+	ID uint64 `json:"id"`
+
+	// IP Addresses
+	IPAddresses []string `json:"ipAddresses"`
+
+	// Name
+	Name string `json:"name"`
+
+	// List of information about OS Users
+	OSUsers ListOSUsers `json:"osUsers"`
+}
+
+// List of Group Computes
+type ListGroupComputes []ItemGroupCompute
+
+// Main information about OS User
+type ItemOSUser struct {
+	// Login
+	Login string `json:"login"`
+
+	// Password
+	Password string `json:"password"`
+}
+
+// List of information about OS Users
+type ListOSUsers []ItemOSUser
+
+// Main information about BasicService
+type ItemBasicService struct {
+	// Account ID
+	AccountID uint64 `json:"accountId"`
+
+	// Account name
+	AccountName string `json:"accountName"`
+
+	// Base domain
+	BaseDomain string `json:"baseDomain"`
+
+	// Created by
+	CreatedBy string `json:"createdBy"`
+
+	// Created time
+	CreatedTime uint64 `json:"createdTime"`
+
+	// Deleted by
+	DeletedBy string `json:"deletedBy"`
+
+	// Deleted time
+	DeletedTime uint64 `json:"deletedTime"`
+
+	// Grid ID
+	GID uint64 `json:"gid"`
+
+	// List of group IDs
+	Groups []uint64 `json:"groups"`
+
+	// GUID
+	GUID uint64 `json:"guid"`
+
+	// ID
+	ID uint64 `json:"id"`
+
+	// Name
+	Name string `json:"name"`
+
+	// Parent service ID
+	ParentSrvID uint64 `json:"parentSrvId"`
+
+	// Parent service type
+	ParentSrvType string `json:"parentSrvType"`
+
+	// Resource group ID
+	RGID uint64 `json:"rgId"`
+
+	// Resource group name
+	RGName string `json:"rgName"`
+
+	// SSH user
+	SSHUser string `json:"sshUser"`
+
+	// Status
+	Status string `json:"status"`
+
+	// TechStatus
+	TechStatus string `json:"techStatus"`
+
+	// Updated by
+	UpdatedBy string `json:"updatedBy"`
+
+	// Updated time
+	UpdatedTime uint64 `json:"updatedTime"`
+
+	// User Managed or not
+	UserManaged bool `json:"userManaged"`
+}
+
+// List of BasicServices
+type ListBasicServices struct {
+	Data []ItemBasicService `json:"data"`
+
+	EntryCount uint64 `json:"entryCount"`
+}

pkg/cloudapi/bservice/restore.go

@@ -0,0 +1,38 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// RestoreRequest struct to restore BasicService instance
+type RestoreRequest struct {
+	// ID of the BasicService to be restored
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Restore restores BasicService instance
+func (b BService) Restore(ctx context.Context, req RestoreRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/restore"
+
+	res, err := b.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/bservice/serialize.go

@@ -0,0 +1,43 @@
+package bservice
+
+import (
+	"encoding/json"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/serialization"
+)
+
+// Serialize returns JSON-serialized []byte. Used as a wrapper over json.Marshal and json.MarshalIndent functions.
+//
+// In order to serialize with indent make sure to follow these guidelines:
+//   - First argument -> prefix
+//   - Second argument -> indent
+func (lbs ListBasicServices) Serialize(params ...string) (serialization.Serialized, error) {
+	if lbs.EntryCount == 0 {
+		return []byte{}, nil
+	}
+
+	if len(params) > 1 {
+		prefix := params[0]
+		indent := params[1]
+
+		return json.MarshalIndent(lbs, prefix, indent)
+	}
+
+	return json.Marshal(lbs)
+}
+
+// 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 (ibs ItemBasicService) Serialize(params ...string) (serialization.Serialized, error) {
+	if len(params) > 1 {
+		prefix := params[0]
+		indent := params[1]
+
+		return json.MarshalIndent(ibs, prefix, indent)
+	}
+
+	return json.Marshal(ibs)
+}

pkg/cloudapi/bservice/snapshot_create.go

@@ -0,0 +1,42 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotCreateRequest struct to create snapshot
+type SnapshotCreateRequest struct {
+	// ID of the Basic Service
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// Label of the snapshot
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+// SnapshotCreate create snapshot of the Basic Service
+func (b BService) SnapshotCreate(ctx context.Context, req SnapshotCreateRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/snapshotCreate"
+
+	res, err := b.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/bservice/snapshot_delete.go

@@ -0,0 +1,42 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotDeleteRequest struct to delete snapshot
+type SnapshotDeleteRequest struct {
+	// ID of the Basic Service
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// Label of the snapshot
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+// SnapshotDelete delete snapshot of the Basic Service
+func (b BService) SnapshotDelete(ctx context.Context, req SnapshotDeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/snapshotDelete"
+
+	res, err := b.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/bservice/snapshot_list.go

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

pkg/cloudapi/bservice/snapshot_rollback.go

@@ -0,0 +1,42 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// SnapshotRollbackRequest struct to rollback snapshot
+type SnapshotRollbackRequest struct {
+	// ID of the Basic Service
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+
+	// Label of the snapshot
+	// Required: true
+	Label string `url:"label" json:"label" validate:"required"`
+}
+
+// SnapshotRollback rollback snapshot of the Basic Service
+func (b BService) SnapshotRollback(ctx context.Context, req SnapshotRollbackRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/snapshotRollback"
+
+	res, err := b.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/bservice/sorting.go

@@ -0,0 +1,60 @@
+package bservice
+
+import "sort"
+
+// SortByCreatedTime sorts ListBasicServices by the CreatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lbs ListBasicServices) SortByCreatedTime(inverse bool) ListBasicServices {
+	if lbs.EntryCount < 2 {
+		return lbs
+	}
+
+	sort.Slice(lbs.Data, func(i, j int) bool {
+		if inverse {
+			return lbs.Data[i].CreatedTime > lbs.Data[j].CreatedTime
+		}
+
+		return lbs.Data[i].CreatedTime < lbs.Data[j].CreatedTime
+	})
+
+	return lbs
+}
+
+// SortByUpdatedTime sorts ListBasicServices by the UpdatedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lbs ListBasicServices) SortByUpdatedTime(inverse bool) ListBasicServices {
+	if lbs.EntryCount < 2 {
+		return lbs
+	}
+
+	sort.Slice(lbs.Data, func(i, j int) bool {
+		if inverse {
+			return lbs.Data[i].UpdatedTime > lbs.Data[j].UpdatedTime
+		}
+
+		return lbs.Data[i].UpdatedTime < lbs.Data[j].UpdatedTime
+	})
+
+	return lbs
+}
+
+// SortByDeletedTime sorts ListBasicServices by the DeletedTime field in ascending order.
+//
+// If inverse param is set to true, the order is reversed.
+func (lbs ListBasicServices) SortByDeletedTime(inverse bool) ListBasicServices {
+	if lbs.EntryCount < 2 {
+		return lbs
+	}
+
+	sort.Slice(lbs.Data, func(i, j int) bool {
+		if inverse {
+			return lbs.Data[i].DeletedTime > lbs.Data[j].DeletedTime
+		}
+
+		return lbs.Data[i].DeletedTime < lbs.Data[j].DeletedTime
+	})
+
+	return lbs
+}

pkg/cloudapi/bservice/start.go

@@ -0,0 +1,40 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// StartRequest struct to start service
+type StartRequest struct {
+	// ID of the service to start
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Start starts service.
+// Starting a service technically means starting computes from all
+// service groups according to group relations
+func (b BService) Start(ctx context.Context, req StartRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/start"
+
+	res, err := b.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/bservice/stop.go

@@ -0,0 +1,40 @@
+package bservice
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// StopRequest struct to stop service
+type StopRequest struct {
+	// ID of the service to stop
+	// Required: true
+	ServiceID uint64 `url:"serviceId" json:"serviceId" validate:"required"`
+}
+
+// Stop stops service.
+// Stopping a service technically means stopping computes from
+// all service groups
+func (b BService) Stop(ctx context.Context, req StopRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/bservice/stop"
+
+	res, err := b.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/cloudapi.go

@@ -0,0 +1,18 @@
+// List of method groups for the user
+package cloudapi
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/interfaces"
+)
+
+// Structure for creating request to CloudAPI groups
+type CloudAPI struct {
+	client interfaces.Caller
+}
+
+// Builder to get access to  CloudAPI
+func New(client interfaces.Caller) *CloudAPI {
+	return &CloudAPI{
+		client: client,
+	}
+}

pkg/cloudapi/compute.go

@@ -0,0 +1,10 @@
+package cloudapi
+
+import (
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/pkg/cloudapi/compute"
+)
+
+// Accessing the Compute method group
+func (ca *CloudAPI) Compute() *compute.Compute {
+	return compute.New(ca.client)
+}

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/v9/internal/validators"
+)
+
+// AffinityGroupCheckStartRequest struct to check all computes with current affinity label can start
+type AffinityGroupCheckStartRequest struct {
+	// ID of the resource group
+	// Required: true
+	RGID uint64 `url:"rgId" json:"rgId" validate:"required"`
+
+	// Affinity group label
+	// Required: true
+	AffinityLabel string `url:"affinityLabel" json:"affinityLabel" validate:"required"`
+}
+
+// AffinityGroupCheckStart check all computes with current affinity label can start
+func (c Compute) AffinityGroupCheckStart(ctx context.Context, req AffinityGroupCheckStartRequest) (string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return "", validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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/v9/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/v9/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/v9/internal/validators"
+)
+
+// AffinityRelationsRequest struct to get dict of computes
+type AffinityRelationsRequest struct {
+	// ID of the compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// AffinityRelations gets dict of computes divided by affinity and anti affinity rules
+func (c Compute) AffinityRelations(ctx context.Context, req AffinityRelationsRequest) (*RecordAffinityRelations, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRuleAddRequest struct to add affinity rule
+type AffinityRuleAddRequest struct {
+	// 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: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// 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,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AffinityRuleRemoveRequest struct to remove affinity rule
+type AffinityRuleRemoveRequest struct {
+	// 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: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// AffinityRuleRemove remove affinity rule
+func (c Compute) AffinityRuleRemove(ctx context.Context, req AffinityRuleRemoveRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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/v9/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,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AntiAffinityRuleAddRequest struct to add anti affinity rule
+type AntiAffinityRuleAddRequest struct {
+	// 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: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// 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,66 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AntiAffinityRuleRemoveRequest struct to remove anti affinity rule
+type AntiAffinityRuleRemoveRequest struct {
+	// 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: false
+	// Not required on purpose: despite required tag on platform, empty string is allowed
+	Value string `url:"value" json:"value"`
+}
+
+// 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/v9/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/v9/internal/validators"
+)
+
+// AttachGPURequest struct to attach GPU for compute
+type AttachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Identifier vGPU
+	// Required: true
+	VGPUID uint64 `url:"vgpuId" json:"vgpuId" validate:"required"`
+}
+
+// AttachGPU 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/v9/internal/validators"
+)
+
+// AttachPCIDeviceRequest struct to attach PCI device
+type AttachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// PCI device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
+}
+
+// AttachPCIDevice 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,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// AuditsRequest struct to get audit records
+type AuditsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Audits gets audit records for the specified compute object
+func (c Compute) Audits(ctx context.Context, req AuditsRequest) (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.MethodPost, url, req)
+	if err != nil {
+		return nil, err
+	}
+
+	list := ListAudits{}
+
+	err = json.Unmarshal(res, &list)
+	if err != nil {
+		return nil, err
+	}
+
+	return list, nil
+}

pkg/cloudapi/compute/boot_disk_set.go

@@ -0,0 +1,42 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootDiskSetRequest struct to set boot disk for compute
+type BootDiskSetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of the disk to set as boot
+	// Required: true
+	DiskID uint64 `url:"diskId" json:"diskId" validate:"required"`
+}
+
+// BootDiskSet sets boot disk for compute
+func (c Compute) BootDiskSet(ctx context.Context, req BootDiskSetRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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,40 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootOrderGetRequest struct to get boot order
+type BootOrderGetRequest struct {
+	// 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,48 @@
+package compute
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// BootOrderSetRequest struct to set boot order
+type BootOrderSetRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// List of boot devices
+	// Should be one of:
+	//	- cdrom
+	//	- network
+	//	- hd
+	// Required: true
+	Order []string `url:"order" json:"order" validate:"min=1,computeOrder"`
+}
+
+// BootOrderSet sets compute boot order
+func (c Compute) BootOrderSet(ctx context.Context, req BootOrderSetRequest) ([]string, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return nil, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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,37 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CDEjectRequest struct to eject CD image
+type CDEjectRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// CDEject 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))
+	}
+
+	url := "/cloudapi/compute/cdEject"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+	return result, nil
+}

pkg/cloudapi/compute/cd_insert.go

@@ -0,0 +1,41 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// CDInsertRequest struct to insert new CD image
+type CDInsertRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// ID of CD-ROM image
+	// Required: true
+	CDROMID uint64 `url:"cdromId" json:"cdromId" validate:"required"`
+}
+
+// CDInsert 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))
+	}
+
+	url := "/cloudapi/compute/cdInsert"
+
+	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_ip.go

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

pkg/cloudapi/compute/change_link_state.go

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

pkg/cloudapi/compute/clone.go

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

pkg/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/v9/interfaces"
+)
+
+// Structure for creating request to compute
+type Compute struct {
+	client interfaces.Caller
+}
+
+// Builder for compute endpoints
+func New(client interfaces.Caller) *Compute {
+	return &Compute{
+		client,
+	}
+}

pkg/cloudapi/compute/create_template.go

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

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/v9/internal/validators"
+)
+
+// CreateTemplateFromBlankRequest struct to create template from boot disk of current compute
+type CreateTemplateFromBlankRequest struct {
+	// ID of the compute to create template from
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Name of the rescue disk
+	// Required: true
+	Name string `url:"name" json:"name" validate:"required"`
+
+	// Boot type of image BIOS or UEFI
+	// Required: true
+	BootType string `url:"boottype" json:"boottype" validate:"imageBootType"`
+
+	// Image type linux, windows or other
+	// Required: true
+	ImageType string `url:"imagetype" json:"imagetype" validate:"imageType"`
+
+	// Username for the image
+	// Required: false
+	Username string `url:"username,omitempty" json:"username,omitempty"`
+
+	// Password for the image
+	// Required: false
+	Password string `url:"password,omitempty" json:"password,omitempty"`
+
+	// Account ID to make the image exclusive
+	// Required: false
+	AccountID uint64 `url:"accountId,omitempty" json:"accountId,omitempty"`
+
+	// SEP ID
+	// Required: false
+	SepID uint64 `url:"sepId,omitempty" json:"sepId,omitempty"`
+
+	// Pool for image create
+	// Required: false
+	PoolName string `url:"poolName,omitempty" json:"poolName,omitempty"`
+
+	// Does this machine supports hot resize
+	// Default: false
+	// Required: false
+	HotResize bool `url:"hotresize" json:"hotresize"`
+}
+
+type wrapperCreateTemplateFromBlankRequest struct {
+	CreateTemplateFromBlankRequest
+	AsyncMode bool `url:"asyncMode"`
+}
+
+// CreateTemplateFromBlank creates template from boot disk of current compute in sync mode.
+// It returns id of created compute and error.
+func (c Compute) CreateTemplateFromBlank(ctx context.Context, req CreateTemplateFromBlankRequest) (uint64, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return 0, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	reqWrapped := wrapperCreateTemplateFromBlankRequest{
+		CreateTemplateFromBlankRequest: req,
+		AsyncMode:                      false,
+	}
+
+	url := "/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,46 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteRequest struct to delete compute
+type DeleteRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Delete permanently
+	// Required: false
+	Permanently bool `url:"permanently,omitempty" json:"permanently,omitempty"`
+
+	// Set True if you want to detach data disks (if any) from the compute before its deletion
+	// Required: false
+	DetachDisks bool `url:"detachDisks,omitempty" json:"detachDisks,omitempty"`
+}
+
+// Delete deletes compute
+func (c Compute) Delete(ctx context.Context, req DeleteRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/delete"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

pkg/cloudapi/compute/delete_custom_fields.go

@@ -0,0 +1,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DeleteCustomFieldsRequest struct to delete compute's custom fields
+type DeleteCustomFieldsRequest struct {
+	// ID of the compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// DeleteCustomFields deletes computes custom fields
+func (c Compute) DeleteCustomFields(ctx context.Context, req DeleteCustomFieldsRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/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/v9/internal/validators"
+)
+
+// DetachGPURequest struct to detach vgpu for compute
+type DetachGPURequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Identifier virtual GPU
+	// Required: false
+	VGPUID int64 `url:"vgpuId,omitempty" json:"vgpuId,omitempty"`
+}
+
+// DetachGPU 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/v9/internal/validators"
+)
+
+// DetachPCIDeviceRequest struct to detach PCI device
+type DetachPCIDeviceRequest struct {
+	// Identifier compute
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+
+	// Pci device ID
+	// Required: true
+	DeviceID uint64 `url:"deviceId" json:"deviceId" validate:"required"`
+}
+
+// DetachPCIDevice 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,38 @@
+package compute
+
+import (
+	"context"
+	"net/http"
+	"strconv"
+
+	"repository.basistech.ru/BASIS/dynamix-golang-sdk/v9/internal/validators"
+)
+
+// DisableRequest struct to disable compute
+type DisableRequest struct {
+	// ID of compute instance
+	// Required: true
+	ComputeID uint64 `url:"computeId" json:"computeId" validate:"required"`
+}
+
+// Disable disables compute
+func (c Compute) Disable(ctx context.Context, req DisableRequest) (bool, error) {
+	err := validators.ValidateRequest(req)
+	if err != nil {
+		return false, validators.ValidationErrors(validators.GetErrors(err))
+	}
+
+	url := "/cloudapi/compute/disable"
+
+	res, err := c.client.DecortApiCall(ctx, http.MethodPost, url, req)
+	if err != nil {
+		return false, err
+	}
+
+	result, err := strconv.ParseBool(string(res))
+	if err != nil {
+		return false, err
+	}
+
+	return result, nil
+}