From 78e8783b385ce1a72304f24e8e2e6a95bd32fcae Mon Sep 17 00:00:00 2001
From: Bill Gale <bill@gale.dev>
Date: Thu, 27 Jun 2024 13:59:29 +0100
Subject: [PATCH] chore: ship generated mocks for next client

---
 go.mod                     |    1 +
 go.sum                     |    2 +
 next/client.go             |    3 +
 next/core/mock/core.go     | 8510 ++++++++++++++++++++++++++++++++++++
 next/public/mock/public.go |  424 ++
 5 files changed, 8940 insertions(+)
 create mode 100644 next/core/mock/core.go
 create mode 100644 next/public/mock/public.go

diff --git a/go.mod b/go.mod
index 4da3188..b42fc65 100644
--- a/go.mod
+++ b/go.mod
@@ -13,6 +13,7 @@ require (
 	github.com/oapi-codegen/oapi-codegen/v2 v2.3.0
 	github.com/oapi-codegen/runtime v1.1.1
 	github.com/stretchr/testify v1.9.0
+	go.uber.org/mock v0.4.0
 	golang.org/x/text v0.15.0
 	gopkg.in/yaml.v3 v3.0.1
 	mvdan.cc/gofumpt v0.4.0
diff --git a/go.sum b/go.sum
index e1a4795..7762c4d 100644
--- a/go.sum
+++ b/go.sum
@@ -78,6 +78,8 @@ github.com/xdg-go/stringprep v1.0.3/go.mod h1:W3f5j4i+9rC0kuIEJL0ky1VpHXQU3ocBgk
 github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
 go.mongodb.org/mongo-driver v1.11.2 h1:+1v2rDQUWNcGW7/7E0Jvdz51V38XXxJfhzbV17aNHCw=
 go.mongodb.org/mongo-driver v1.11.2/go.mod h1:s7p5vEtfbeR1gYi6pnj3c3/urpbLv2T5Sfd6Rp2HBB8=
+go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
+go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
 golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
 golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
diff --git a/next/client.go b/next/client.go
index 4606a0a..c275abc 100644
--- a/next/client.go
+++ b/next/client.go
@@ -1,5 +1,8 @@
 package next
 
+//go:generate go run go.uber.org/mock/mockgen@v0.4.0 -source=./public/public.go -destination=./public/mock/public.go
+//go:generate go run go.uber.org/mock/mockgen@v0.4.0 -source=./core/core.go -destination=./core/mock/core.go
+
 import (
 	"fmt"
 
diff --git a/next/core/mock/core.go b/next/core/mock/core.go
new file mode 100644
index 0000000..0b9be94
--- /dev/null
+++ b/next/core/mock/core.go
@@ -0,0 +1,8510 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: ./core/core.go
+//
+// Generated by this command:
+//
+//	mockgen -source=./core/core.go -destination=./core/mock/core.go
+//
+
+// Package mock_core is a generated GoMock package.
+package mock_core
+
+import (
+	context "context"
+	io "io"
+	http "net/http"
+	reflect "reflect"
+
+	core "github.com/krystal/go-katapult/next/core"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockDNSRecordContentArgumentsForSOA is a mock of DNSRecordContentArgumentsForSOA interface.
+type MockDNSRecordContentArgumentsForSOA struct {
+	ctrl     *gomock.Controller
+	recorder *MockDNSRecordContentArgumentsForSOAMockRecorder
+}
+
+// MockDNSRecordContentArgumentsForSOAMockRecorder is the mock recorder for MockDNSRecordContentArgumentsForSOA.
+type MockDNSRecordContentArgumentsForSOAMockRecorder struct {
+	mock *MockDNSRecordContentArgumentsForSOA
+}
+
+// NewMockDNSRecordContentArgumentsForSOA creates a new mock instance.
+func NewMockDNSRecordContentArgumentsForSOA(ctrl *gomock.Controller) *MockDNSRecordContentArgumentsForSOA {
+	mock := &MockDNSRecordContentArgumentsForSOA{ctrl: ctrl}
+	mock.recorder = &MockDNSRecordContentArgumentsForSOAMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDNSRecordContentArgumentsForSOA) EXPECT() *MockDNSRecordContentArgumentsForSOAMockRecorder {
+	return m.recorder
+}
+
+// MockPostInvalidateLinkedWebSessionJSONBody is a mock of PostInvalidateLinkedWebSessionJSONBody interface.
+type MockPostInvalidateLinkedWebSessionJSONBody struct {
+	ctrl     *gomock.Controller
+	recorder *MockPostInvalidateLinkedWebSessionJSONBodyMockRecorder
+}
+
+// MockPostInvalidateLinkedWebSessionJSONBodyMockRecorder is the mock recorder for MockPostInvalidateLinkedWebSessionJSONBody.
+type MockPostInvalidateLinkedWebSessionJSONBodyMockRecorder struct {
+	mock *MockPostInvalidateLinkedWebSessionJSONBody
+}
+
+// NewMockPostInvalidateLinkedWebSessionJSONBody creates a new mock instance.
+func NewMockPostInvalidateLinkedWebSessionJSONBody(ctrl *gomock.Controller) *MockPostInvalidateLinkedWebSessionJSONBody {
+	mock := &MockPostInvalidateLinkedWebSessionJSONBody{ctrl: ctrl}
+	mock.recorder = &MockPostInvalidateLinkedWebSessionJSONBodyMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPostInvalidateLinkedWebSessionJSONBody) EXPECT() *MockPostInvalidateLinkedWebSessionJSONBodyMockRecorder {
+	return m.recorder
+}
+
+// MockHttpRequestDoer is a mock of HttpRequestDoer interface.
+type MockHttpRequestDoer struct {
+	ctrl     *gomock.Controller
+	recorder *MockHttpRequestDoerMockRecorder
+}
+
+// MockHttpRequestDoerMockRecorder is the mock recorder for MockHttpRequestDoer.
+type MockHttpRequestDoerMockRecorder struct {
+	mock *MockHttpRequestDoer
+}
+
+// NewMockHttpRequestDoer creates a new mock instance.
+func NewMockHttpRequestDoer(ctrl *gomock.Controller) *MockHttpRequestDoer {
+	mock := &MockHttpRequestDoer{ctrl: ctrl}
+	mock.recorder = &MockHttpRequestDoerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockHttpRequestDoer) EXPECT() *MockHttpRequestDoerMockRecorder {
+	return m.recorder
+}
+
+// Do mocks base method.
+func (m *MockHttpRequestDoer) Do(req *http.Request) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Do", req)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Do indicates an expected call of Do.
+func (mr *MockHttpRequestDoerMockRecorder) Do(req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHttpRequestDoer)(nil).Do), req)
+}
+
+// MockClientInterface is a mock of ClientInterface interface.
+type MockClientInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientInterfaceMockRecorder
+}
+
+// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
+type MockClientInterfaceMockRecorder struct {
+	mock *MockClientInterface
+}
+
+// NewMockClientInterface creates a new mock instance.
+func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
+	mock := &MockClientInterface{ctrl: ctrl}
+	mock.recorder = &MockClientInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
+	return m.recorder
+}
+
+// DeleteAddressList mocks base method.
+func (m *MockClientInterface) DeleteAddressList(ctx context.Context, body core.DeleteAddressListJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressList", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressList indicates an expected call of DeleteAddressList.
+func (mr *MockClientInterfaceMockRecorder) DeleteAddressList(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressList", reflect.TypeOf((*MockClientInterface)(nil).DeleteAddressList), varargs...)
+}
+
+// DeleteAddressListEntry mocks base method.
+func (m *MockClientInterface) DeleteAddressListEntry(ctx context.Context, body core.DeleteAddressListEntryJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListEntry", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListEntry indicates an expected call of DeleteAddressListEntry.
+func (mr *MockClientInterfaceMockRecorder) DeleteAddressListEntry(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListEntry", reflect.TypeOf((*MockClientInterface)(nil).DeleteAddressListEntry), varargs...)
+}
+
+// DeleteAddressListEntryWithBody mocks base method.
+func (m *MockClientInterface) DeleteAddressListEntryWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListEntryWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListEntryWithBody indicates an expected call of DeleteAddressListEntryWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteAddressListEntryWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListEntryWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteAddressListEntryWithBody), varargs...)
+}
+
+// DeleteAddressListWithBody mocks base method.
+func (m *MockClientInterface) DeleteAddressListWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListWithBody indicates an expected call of DeleteAddressListWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteAddressListWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteAddressListWithBody), varargs...)
+}
+
+// DeleteDiskBackupPolicy mocks base method.
+func (m *MockClientInterface) DeleteDiskBackupPolicy(ctx context.Context, body core.DeleteDiskBackupPolicyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicy", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicy indicates an expected call of DeleteDiskBackupPolicy.
+func (mr *MockClientInterfaceMockRecorder) DeleteDiskBackupPolicy(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicy", reflect.TypeOf((*MockClientInterface)(nil).DeleteDiskBackupPolicy), varargs...)
+}
+
+// DeleteDiskBackupPolicySchedule mocks base method.
+func (m *MockClientInterface) DeleteDiskBackupPolicySchedule(ctx context.Context, body core.DeleteDiskBackupPolicyScheduleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicySchedule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicySchedule indicates an expected call of DeleteDiskBackupPolicySchedule.
+func (mr *MockClientInterfaceMockRecorder) DeleteDiskBackupPolicySchedule(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicySchedule", reflect.TypeOf((*MockClientInterface)(nil).DeleteDiskBackupPolicySchedule), varargs...)
+}
+
+// DeleteDiskBackupPolicyScheduleWithBody mocks base method.
+func (m *MockClientInterface) DeleteDiskBackupPolicyScheduleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyScheduleWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyScheduleWithBody indicates an expected call of DeleteDiskBackupPolicyScheduleWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteDiskBackupPolicyScheduleWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyScheduleWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteDiskBackupPolicyScheduleWithBody), varargs...)
+}
+
+// DeleteDiskBackupPolicyWithBody mocks base method.
+func (m *MockClientInterface) DeleteDiskBackupPolicyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyWithBody indicates an expected call of DeleteDiskBackupPolicyWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteDiskBackupPolicyWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteDiskBackupPolicyWithBody), varargs...)
+}
+
+// DeleteDnsRecord mocks base method.
+func (m *MockClientInterface) DeleteDnsRecord(ctx context.Context, body core.DeleteDnsRecordJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsRecord", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsRecord indicates an expected call of DeleteDnsRecord.
+func (mr *MockClientInterfaceMockRecorder) DeleteDnsRecord(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsRecord", reflect.TypeOf((*MockClientInterface)(nil).DeleteDnsRecord), varargs...)
+}
+
+// DeleteDnsRecordWithBody mocks base method.
+func (m *MockClientInterface) DeleteDnsRecordWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsRecordWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsRecordWithBody indicates an expected call of DeleteDnsRecordWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteDnsRecordWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsRecordWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteDnsRecordWithBody), varargs...)
+}
+
+// DeleteDnsZone mocks base method.
+func (m *MockClientInterface) DeleteDnsZone(ctx context.Context, body core.DeleteDnsZoneJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsZone", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsZone indicates an expected call of DeleteDnsZone.
+func (mr *MockClientInterfaceMockRecorder) DeleteDnsZone(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsZone", reflect.TypeOf((*MockClientInterface)(nil).DeleteDnsZone), varargs...)
+}
+
+// DeleteDnsZoneWithBody mocks base method.
+func (m *MockClientInterface) DeleteDnsZoneWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsZoneWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsZoneWithBody indicates an expected call of DeleteDnsZoneWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteDnsZoneWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsZoneWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteDnsZoneWithBody), varargs...)
+}
+
+// DeleteFileStorageVolume mocks base method.
+func (m *MockClientInterface) DeleteFileStorageVolume(ctx context.Context, body core.DeleteFileStorageVolumeJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteFileStorageVolume", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteFileStorageVolume indicates an expected call of DeleteFileStorageVolume.
+func (mr *MockClientInterfaceMockRecorder) DeleteFileStorageVolume(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFileStorageVolume", reflect.TypeOf((*MockClientInterface)(nil).DeleteFileStorageVolume), varargs...)
+}
+
+// DeleteFileStorageVolumeWithBody mocks base method.
+func (m *MockClientInterface) DeleteFileStorageVolumeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteFileStorageVolumeWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteFileStorageVolumeWithBody indicates an expected call of DeleteFileStorageVolumeWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteFileStorageVolumeWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFileStorageVolumeWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteFileStorageVolumeWithBody), varargs...)
+}
+
+// DeleteIpAddress mocks base method.
+func (m *MockClientInterface) DeleteIpAddress(ctx context.Context, body core.DeleteIpAddressJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteIpAddress", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIpAddress indicates an expected call of DeleteIpAddress.
+func (mr *MockClientInterfaceMockRecorder) DeleteIpAddress(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpAddress", reflect.TypeOf((*MockClientInterface)(nil).DeleteIpAddress), varargs...)
+}
+
+// DeleteIpAddressWithBody mocks base method.
+func (m *MockClientInterface) DeleteIpAddressWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteIpAddressWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIpAddressWithBody indicates an expected call of DeleteIpAddressWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteIpAddressWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpAddressWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteIpAddressWithBody), varargs...)
+}
+
+// DeleteLoadBalancer mocks base method.
+func (m *MockClientInterface) DeleteLoadBalancer(ctx context.Context, body core.DeleteLoadBalancerJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
+func (mr *MockClientInterfaceMockRecorder) DeleteLoadBalancer(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockClientInterface)(nil).DeleteLoadBalancer), varargs...)
+}
+
+// DeleteLoadBalancerWithBody mocks base method.
+func (m *MockClientInterface) DeleteLoadBalancerWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancerWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancerWithBody indicates an expected call of DeleteLoadBalancerWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteLoadBalancerWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteLoadBalancerWithBody), varargs...)
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRule mocks base method.
+func (m *MockClientInterface) DeleteLoadBalancersRulesLoadBalancerRule(ctx context.Context, body core.DeleteLoadBalancersRulesLoadBalancerRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancersRulesLoadBalancerRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRule indicates an expected call of DeleteLoadBalancersRulesLoadBalancerRule.
+func (mr *MockClientInterfaceMockRecorder) DeleteLoadBalancersRulesLoadBalancerRule(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancersRulesLoadBalancerRule", reflect.TypeOf((*MockClientInterface)(nil).DeleteLoadBalancersRulesLoadBalancerRule), varargs...)
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithBody mocks base method.
+func (m *MockClientInterface) DeleteLoadBalancersRulesLoadBalancerRuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancersRulesLoadBalancerRuleWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithBody indicates an expected call of DeleteLoadBalancersRulesLoadBalancerRuleWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteLoadBalancersRulesLoadBalancerRuleWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancersRulesLoadBalancerRuleWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteLoadBalancersRulesLoadBalancerRuleWithBody), varargs...)
+}
+
+// DeleteSecurityGroup mocks base method.
+func (m *MockClientInterface) DeleteSecurityGroup(ctx context.Context, body core.DeleteSecurityGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
+func (mr *MockClientInterfaceMockRecorder) DeleteSecurityGroup(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockClientInterface)(nil).DeleteSecurityGroup), varargs...)
+}
+
+// DeleteSecurityGroupWithBody mocks base method.
+func (m *MockClientInterface) DeleteSecurityGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupWithBody indicates an expected call of DeleteSecurityGroupWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteSecurityGroupWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteSecurityGroupWithBody), varargs...)
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRule mocks base method.
+func (m *MockClientInterface) DeleteSecurityGroupsRulesSecurityGroupRule(ctx context.Context, body core.DeleteSecurityGroupsRulesSecurityGroupRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupsRulesSecurityGroupRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRule indicates an expected call of DeleteSecurityGroupsRulesSecurityGroupRule.
+func (mr *MockClientInterfaceMockRecorder) DeleteSecurityGroupsRulesSecurityGroupRule(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupsRulesSecurityGroupRule", reflect.TypeOf((*MockClientInterface)(nil).DeleteSecurityGroupsRulesSecurityGroupRule), varargs...)
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithBody mocks base method.
+func (m *MockClientInterface) DeleteSecurityGroupsRulesSecurityGroupRuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupsRulesSecurityGroupRuleWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithBody indicates an expected call of DeleteSecurityGroupsRulesSecurityGroupRuleWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteSecurityGroupsRulesSecurityGroupRuleWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupsRulesSecurityGroupRuleWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteSecurityGroupsRulesSecurityGroupRuleWithBody), varargs...)
+}
+
+// DeleteSshKey mocks base method.
+func (m *MockClientInterface) DeleteSshKey(ctx context.Context, body core.DeleteSshKeyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSshKey", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSshKey indicates an expected call of DeleteSshKey.
+func (mr *MockClientInterfaceMockRecorder) DeleteSshKey(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSshKey", reflect.TypeOf((*MockClientInterface)(nil).DeleteSshKey), varargs...)
+}
+
+// DeleteSshKeyWithBody mocks base method.
+func (m *MockClientInterface) DeleteSshKeyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSshKeyWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSshKeyWithBody indicates an expected call of DeleteSshKeyWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteSshKeyWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSshKeyWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteSshKeyWithBody), varargs...)
+}
+
+// DeleteTag mocks base method.
+func (m *MockClientInterface) DeleteTag(ctx context.Context, body core.DeleteTagJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTag", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTag indicates an expected call of DeleteTag.
+func (mr *MockClientInterfaceMockRecorder) DeleteTag(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTag", reflect.TypeOf((*MockClientInterface)(nil).DeleteTag), varargs...)
+}
+
+// DeleteTagWithBody mocks base method.
+func (m *MockClientInterface) DeleteTagWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTagWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTagWithBody indicates an expected call of DeleteTagWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteTagWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteTagWithBody), varargs...)
+}
+
+// DeleteTrashObject mocks base method.
+func (m *MockClientInterface) DeleteTrashObject(ctx context.Context, body core.DeleteTrashObjectJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTrashObject", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTrashObject indicates an expected call of DeleteTrashObject.
+func (mr *MockClientInterfaceMockRecorder) DeleteTrashObject(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrashObject", reflect.TypeOf((*MockClientInterface)(nil).DeleteTrashObject), varargs...)
+}
+
+// DeleteTrashObjectWithBody mocks base method.
+func (m *MockClientInterface) DeleteTrashObjectWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTrashObjectWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTrashObjectWithBody indicates an expected call of DeleteTrashObjectWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteTrashObjectWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrashObjectWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteTrashObjectWithBody), varargs...)
+}
+
+// DeleteVirtualMachine mocks base method.
+func (m *MockClientInterface) DeleteVirtualMachine(ctx context.Context, body core.DeleteVirtualMachineJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachine", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachine indicates an expected call of DeleteVirtualMachine.
+func (mr *MockClientInterfaceMockRecorder) DeleteVirtualMachine(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachine", reflect.TypeOf((*MockClientInterface)(nil).DeleteVirtualMachine), varargs...)
+}
+
+// DeleteVirtualMachineGroup mocks base method.
+func (m *MockClientInterface) DeleteVirtualMachineGroup(ctx context.Context, body core.DeleteVirtualMachineGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineGroup indicates an expected call of DeleteVirtualMachineGroup.
+func (mr *MockClientInterfaceMockRecorder) DeleteVirtualMachineGroup(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineGroup", reflect.TypeOf((*MockClientInterface)(nil).DeleteVirtualMachineGroup), varargs...)
+}
+
+// DeleteVirtualMachineGroupWithBody mocks base method.
+func (m *MockClientInterface) DeleteVirtualMachineGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineGroupWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineGroupWithBody indicates an expected call of DeleteVirtualMachineGroupWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteVirtualMachineGroupWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineGroupWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteVirtualMachineGroupWithBody), varargs...)
+}
+
+// DeleteVirtualMachineWithBody mocks base method.
+func (m *MockClientInterface) DeleteVirtualMachineWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineWithBody indicates an expected call of DeleteVirtualMachineWithBody.
+func (mr *MockClientInterfaceMockRecorder) DeleteVirtualMachineWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineWithBody", reflect.TypeOf((*MockClientInterface)(nil).DeleteVirtualMachineWithBody), varargs...)
+}
+
+// GetAddressList mocks base method.
+func (m *MockClientInterface) GetAddressList(ctx context.Context, params *core.GetAddressListParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressList", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressList indicates an expected call of GetAddressList.
+func (mr *MockClientInterfaceMockRecorder) GetAddressList(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressList", reflect.TypeOf((*MockClientInterface)(nil).GetAddressList), varargs...)
+}
+
+// GetAddressListEntries mocks base method.
+func (m *MockClientInterface) GetAddressListEntries(ctx context.Context, params *core.GetAddressListEntriesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListEntries", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListEntries indicates an expected call of GetAddressListEntries.
+func (mr *MockClientInterfaceMockRecorder) GetAddressListEntries(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListEntries", reflect.TypeOf((*MockClientInterface)(nil).GetAddressListEntries), varargs...)
+}
+
+// GetAddressListEntry mocks base method.
+func (m *MockClientInterface) GetAddressListEntry(ctx context.Context, params *core.GetAddressListEntryParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListEntry", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListEntry indicates an expected call of GetAddressListEntry.
+func (mr *MockClientInterfaceMockRecorder) GetAddressListEntry(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListEntry", reflect.TypeOf((*MockClientInterface)(nil).GetAddressListEntry), varargs...)
+}
+
+// GetAddressLists mocks base method.
+func (m *MockClientInterface) GetAddressLists(ctx context.Context, params *core.GetAddressListsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressLists", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressLists indicates an expected call of GetAddressLists.
+func (mr *MockClientInterfaceMockRecorder) GetAddressLists(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressLists", reflect.TypeOf((*MockClientInterface)(nil).GetAddressLists), varargs...)
+}
+
+// GetCertificate mocks base method.
+func (m *MockClientInterface) GetCertificate(ctx context.Context, params *core.GetCertificateParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCertificate", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCertificate indicates an expected call of GetCertificate.
+func (mr *MockClientInterfaceMockRecorder) GetCertificate(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockClientInterface)(nil).GetCertificate), varargs...)
+}
+
+// GetCountries mocks base method.
+func (m *MockClientInterface) GetCountries(ctx context.Context, params *core.GetCountriesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountries", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountries indicates an expected call of GetCountries.
+func (mr *MockClientInterfaceMockRecorder) GetCountries(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountries", reflect.TypeOf((*MockClientInterface)(nil).GetCountries), varargs...)
+}
+
+// GetCountry mocks base method.
+func (m *MockClientInterface) GetCountry(ctx context.Context, params *core.GetCountryParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountry", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountry indicates an expected call of GetCountry.
+func (mr *MockClientInterfaceMockRecorder) GetCountry(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountry", reflect.TypeOf((*MockClientInterface)(nil).GetCountry), varargs...)
+}
+
+// GetCountryCountryStates mocks base method.
+func (m *MockClientInterface) GetCountryCountryStates(ctx context.Context, params *core.GetCountryCountryStatesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountryCountryStates", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountryCountryStates indicates an expected call of GetCountryCountryStates.
+func (mr *MockClientInterfaceMockRecorder) GetCountryCountryStates(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountryCountryStates", reflect.TypeOf((*MockClientInterface)(nil).GetCountryCountryStates), varargs...)
+}
+
+// GetCountryState mocks base method.
+func (m *MockClientInterface) GetCountryState(ctx context.Context, params *core.GetCountryStateParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountryState", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountryState indicates an expected call of GetCountryState.
+func (mr *MockClientInterfaceMockRecorder) GetCountryState(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountryState", reflect.TypeOf((*MockClientInterface)(nil).GetCountryState), varargs...)
+}
+
+// GetCurrencies mocks base method.
+func (m *MockClientInterface) GetCurrencies(ctx context.Context, params *core.GetCurrenciesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCurrencies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrencies indicates an expected call of GetCurrencies.
+func (mr *MockClientInterfaceMockRecorder) GetCurrencies(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrencies", reflect.TypeOf((*MockClientInterface)(nil).GetCurrencies), varargs...)
+}
+
+// GetCurrency mocks base method.
+func (m *MockClientInterface) GetCurrency(ctx context.Context, params *core.GetCurrencyParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCurrency", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrency indicates an expected call of GetCurrency.
+func (mr *MockClientInterfaceMockRecorder) GetCurrency(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrency", reflect.TypeOf((*MockClientInterface)(nil).GetCurrency), varargs...)
+}
+
+// GetDataCenter mocks base method.
+func (m *MockClientInterface) GetDataCenter(ctx context.Context, params *core.GetDataCenterParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenter", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenter indicates an expected call of GetDataCenter.
+func (mr *MockClientInterfaceMockRecorder) GetDataCenter(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenter", reflect.TypeOf((*MockClientInterface)(nil).GetDataCenter), varargs...)
+}
+
+// GetDataCenterDefaultNetwork mocks base method.
+func (m *MockClientInterface) GetDataCenterDefaultNetwork(ctx context.Context, params *core.GetDataCenterDefaultNetworkParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenterDefaultNetwork", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenterDefaultNetwork indicates an expected call of GetDataCenterDefaultNetwork.
+func (mr *MockClientInterfaceMockRecorder) GetDataCenterDefaultNetwork(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenterDefaultNetwork", reflect.TypeOf((*MockClientInterface)(nil).GetDataCenterDefaultNetwork), varargs...)
+}
+
+// GetDataCenterGpuTypes mocks base method.
+func (m *MockClientInterface) GetDataCenterGpuTypes(ctx context.Context, params *core.GetDataCenterGpuTypesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenterGpuTypes", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenterGpuTypes indicates an expected call of GetDataCenterGpuTypes.
+func (mr *MockClientInterfaceMockRecorder) GetDataCenterGpuTypes(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenterGpuTypes", reflect.TypeOf((*MockClientInterface)(nil).GetDataCenterGpuTypes), varargs...)
+}
+
+// GetDataCenters mocks base method.
+func (m *MockClientInterface) GetDataCenters(ctx context.Context, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenters", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenters indicates an expected call of GetDataCenters.
+func (mr *MockClientInterfaceMockRecorder) GetDataCenters(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenters", reflect.TypeOf((*MockClientInterface)(nil).GetDataCenters), varargs...)
+}
+
+// GetDisk mocks base method.
+func (m *MockClientInterface) GetDisk(ctx context.Context, params *core.GetDiskParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDisk", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDisk indicates an expected call of GetDisk.
+func (mr *MockClientInterfaceMockRecorder) GetDisk(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDisk", reflect.TypeOf((*MockClientInterface)(nil).GetDisk), varargs...)
+}
+
+// GetDiskBackupPolicy mocks base method.
+func (m *MockClientInterface) GetDiskBackupPolicy(ctx context.Context, params *core.GetDiskBackupPolicyParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskBackupPolicy", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskBackupPolicy indicates an expected call of GetDiskBackupPolicy.
+func (mr *MockClientInterfaceMockRecorder) GetDiskBackupPolicy(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskBackupPolicy", reflect.TypeOf((*MockClientInterface)(nil).GetDiskBackupPolicy), varargs...)
+}
+
+// GetDiskDiskBackupPolicies mocks base method.
+func (m *MockClientInterface) GetDiskDiskBackupPolicies(ctx context.Context, params *core.GetDiskDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskDiskBackupPolicies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskDiskBackupPolicies indicates an expected call of GetDiskDiskBackupPolicies.
+func (mr *MockClientInterfaceMockRecorder) GetDiskDiskBackupPolicies(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskDiskBackupPolicies", reflect.TypeOf((*MockClientInterface)(nil).GetDiskDiskBackupPolicies), varargs...)
+}
+
+// GetDiskTemplate mocks base method.
+func (m *MockClientInterface) GetDiskTemplate(ctx context.Context, params *core.GetDiskTemplateParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplate", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplate indicates an expected call of GetDiskTemplate.
+func (mr *MockClientInterfaceMockRecorder) GetDiskTemplate(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplate", reflect.TypeOf((*MockClientInterface)(nil).GetDiskTemplate), varargs...)
+}
+
+// GetDiskTemplateVersion mocks base method.
+func (m *MockClientInterface) GetDiskTemplateVersion(ctx context.Context, params *core.GetDiskTemplateVersionParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersion", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersion indicates an expected call of GetDiskTemplateVersion.
+func (mr *MockClientInterfaceMockRecorder) GetDiskTemplateVersion(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersion", reflect.TypeOf((*MockClientInterface)(nil).GetDiskTemplateVersion), varargs...)
+}
+
+// GetDiskTemplateVersionSpec mocks base method.
+func (m *MockClientInterface) GetDiskTemplateVersionSpec(ctx context.Context, params *core.GetDiskTemplateVersionSpecParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersionSpec", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersionSpec indicates an expected call of GetDiskTemplateVersionSpec.
+func (mr *MockClientInterfaceMockRecorder) GetDiskTemplateVersionSpec(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersionSpec", reflect.TypeOf((*MockClientInterface)(nil).GetDiskTemplateVersionSpec), varargs...)
+}
+
+// GetDiskTemplateVersions mocks base method.
+func (m *MockClientInterface) GetDiskTemplateVersions(ctx context.Context, params *core.GetDiskTemplateVersionsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersions", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersions indicates an expected call of GetDiskTemplateVersions.
+func (mr *MockClientInterfaceMockRecorder) GetDiskTemplateVersions(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersions", reflect.TypeOf((*MockClientInterface)(nil).GetDiskTemplateVersions), varargs...)
+}
+
+// GetDnsRecord mocks base method.
+func (m *MockClientInterface) GetDnsRecord(ctx context.Context, params *core.GetDnsRecordParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsRecord", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsRecord indicates an expected call of GetDnsRecord.
+func (mr *MockClientInterfaceMockRecorder) GetDnsRecord(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsRecord", reflect.TypeOf((*MockClientInterface)(nil).GetDnsRecord), varargs...)
+}
+
+// GetDnsZone mocks base method.
+func (m *MockClientInterface) GetDnsZone(ctx context.Context, params *core.GetDnsZoneParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsZone", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsZone indicates an expected call of GetDnsZone.
+func (mr *MockClientInterfaceMockRecorder) GetDnsZone(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsZone", reflect.TypeOf((*MockClientInterface)(nil).GetDnsZone), varargs...)
+}
+
+// GetDnsZoneRecords mocks base method.
+func (m *MockClientInterface) GetDnsZoneRecords(ctx context.Context, params *core.GetDnsZoneRecordsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsZoneRecords", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsZoneRecords indicates an expected call of GetDnsZoneRecords.
+func (mr *MockClientInterfaceMockRecorder) GetDnsZoneRecords(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsZoneRecords", reflect.TypeOf((*MockClientInterface)(nil).GetDnsZoneRecords), varargs...)
+}
+
+// GetFileStorageVolume mocks base method.
+func (m *MockClientInterface) GetFileStorageVolume(ctx context.Context, params *core.GetFileStorageVolumeParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetFileStorageVolume", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileStorageVolume indicates an expected call of GetFileStorageVolume.
+func (mr *MockClientInterfaceMockRecorder) GetFileStorageVolume(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileStorageVolume", reflect.TypeOf((*MockClientInterface)(nil).GetFileStorageVolume), varargs...)
+}
+
+// GetGpuType mocks base method.
+func (m *MockClientInterface) GetGpuType(ctx context.Context, params *core.GetGpuTypeParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGpuType", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGpuType indicates an expected call of GetGpuType.
+func (mr *MockClientInterfaceMockRecorder) GetGpuType(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuType", reflect.TypeOf((*MockClientInterface)(nil).GetGpuType), varargs...)
+}
+
+// GetGpuTypes mocks base method.
+func (m *MockClientInterface) GetGpuTypes(ctx context.Context, params *core.GetGpuTypesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGpuTypes", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGpuTypes indicates an expected call of GetGpuTypes.
+func (mr *MockClientInterfaceMockRecorder) GetGpuTypes(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuTypes", reflect.TypeOf((*MockClientInterface)(nil).GetGpuTypes), varargs...)
+}
+
+// GetIpAddress mocks base method.
+func (m *MockClientInterface) GetIpAddress(ctx context.Context, params *core.GetIpAddressParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetIpAddress", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIpAddress indicates an expected call of GetIpAddress.
+func (mr *MockClientInterfaceMockRecorder) GetIpAddress(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpAddress", reflect.TypeOf((*MockClientInterface)(nil).GetIpAddress), varargs...)
+}
+
+// GetLoadBalancer mocks base method.
+func (m *MockClientInterface) GetLoadBalancer(ctx context.Context, params *core.GetLoadBalancerParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancer indicates an expected call of GetLoadBalancer.
+func (mr *MockClientInterfaceMockRecorder) GetLoadBalancer(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancer", reflect.TypeOf((*MockClientInterface)(nil).GetLoadBalancer), varargs...)
+}
+
+// GetLoadBalancerRules mocks base method.
+func (m *MockClientInterface) GetLoadBalancerRules(ctx context.Context, params *core.GetLoadBalancerRulesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancerRules", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancerRules indicates an expected call of GetLoadBalancerRules.
+func (mr *MockClientInterfaceMockRecorder) GetLoadBalancerRules(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRules", reflect.TypeOf((*MockClientInterface)(nil).GetLoadBalancerRules), varargs...)
+}
+
+// GetLoadBalancersRulesLoadBalancerRule mocks base method.
+func (m *MockClientInterface) GetLoadBalancersRulesLoadBalancerRule(ctx context.Context, params *core.GetLoadBalancersRulesLoadBalancerRuleParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancersRulesLoadBalancerRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancersRulesLoadBalancerRule indicates an expected call of GetLoadBalancersRulesLoadBalancerRule.
+func (mr *MockClientInterfaceMockRecorder) GetLoadBalancersRulesLoadBalancerRule(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancersRulesLoadBalancerRule", reflect.TypeOf((*MockClientInterface)(nil).GetLoadBalancersRulesLoadBalancerRule), varargs...)
+}
+
+// GetNetwork mocks base method.
+func (m *MockClientInterface) GetNetwork(ctx context.Context, params *core.GetNetworkParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetNetwork", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNetwork indicates an expected call of GetNetwork.
+func (mr *MockClientInterfaceMockRecorder) GetNetwork(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetwork", reflect.TypeOf((*MockClientInterface)(nil).GetNetwork), varargs...)
+}
+
+// GetOperatingSystem mocks base method.
+func (m *MockClientInterface) GetOperatingSystem(ctx context.Context, params *core.GetOperatingSystemParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOperatingSystem", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOperatingSystem indicates an expected call of GetOperatingSystem.
+func (mr *MockClientInterfaceMockRecorder) GetOperatingSystem(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatingSystem", reflect.TypeOf((*MockClientInterface)(nil).GetOperatingSystem), varargs...)
+}
+
+// GetOperatingSystems mocks base method.
+func (m *MockClientInterface) GetOperatingSystems(ctx context.Context, params *core.GetOperatingSystemsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOperatingSystems", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOperatingSystems indicates an expected call of GetOperatingSystems.
+func (mr *MockClientInterfaceMockRecorder) GetOperatingSystems(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatingSystems", reflect.TypeOf((*MockClientInterface)(nil).GetOperatingSystems), varargs...)
+}
+
+// GetOrganization mocks base method.
+func (m *MockClientInterface) GetOrganization(ctx context.Context, params *core.GetOrganizationParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganization", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganization indicates an expected call of GetOrganization.
+func (mr *MockClientInterfaceMockRecorder) GetOrganization(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganization", reflect.TypeOf((*MockClientInterface)(nil).GetOrganization), varargs...)
+}
+
+// GetOrganizationAddressLists mocks base method.
+func (m *MockClientInterface) GetOrganizationAddressLists(ctx context.Context, params *core.GetOrganizationAddressListsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationAddressLists", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationAddressLists indicates an expected call of GetOrganizationAddressLists.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationAddressLists(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationAddressLists", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationAddressLists), varargs...)
+}
+
+// GetOrganizationAvailableNetworks mocks base method.
+func (m *MockClientInterface) GetOrganizationAvailableNetworks(ctx context.Context, params *core.GetOrganizationAvailableNetworksParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationAvailableNetworks", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationAvailableNetworks indicates an expected call of GetOrganizationAvailableNetworks.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationAvailableNetworks(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationAvailableNetworks", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationAvailableNetworks), varargs...)
+}
+
+// GetOrganizationCertificates mocks base method.
+func (m *MockClientInterface) GetOrganizationCertificates(ctx context.Context, params *core.GetOrganizationCertificatesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationCertificates", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationCertificates indicates an expected call of GetOrganizationCertificates.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationCertificates(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationCertificates", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationCertificates), varargs...)
+}
+
+// GetOrganizationDiskBackupPolicies mocks base method.
+func (m *MockClientInterface) GetOrganizationDiskBackupPolicies(ctx context.Context, params *core.GetOrganizationDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDiskBackupPolicies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDiskBackupPolicies indicates an expected call of GetOrganizationDiskBackupPolicies.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationDiskBackupPolicies(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDiskBackupPolicies", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationDiskBackupPolicies), varargs...)
+}
+
+// GetOrganizationDiskTemplates mocks base method.
+func (m *MockClientInterface) GetOrganizationDiskTemplates(ctx context.Context, params *core.GetOrganizationDiskTemplatesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDiskTemplates", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDiskTemplates indicates an expected call of GetOrganizationDiskTemplates.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationDiskTemplates(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDiskTemplates", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationDiskTemplates), varargs...)
+}
+
+// GetOrganizationDisks mocks base method.
+func (m *MockClientInterface) GetOrganizationDisks(ctx context.Context, params *core.GetOrganizationDisksParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDisks", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDisks indicates an expected call of GetOrganizationDisks.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationDisks(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDisks", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationDisks), varargs...)
+}
+
+// GetOrganizationDnsZones mocks base method.
+func (m *MockClientInterface) GetOrganizationDnsZones(ctx context.Context, params *core.GetOrganizationDnsZonesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDnsZones", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDnsZones indicates an expected call of GetOrganizationDnsZones.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationDnsZones(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDnsZones", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationDnsZones), varargs...)
+}
+
+// GetOrganizationDnsZonesNameservers mocks base method.
+func (m *MockClientInterface) GetOrganizationDnsZonesNameservers(ctx context.Context, params *core.GetOrganizationDnsZonesNameserversParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDnsZonesNameservers", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDnsZonesNameservers indicates an expected call of GetOrganizationDnsZonesNameservers.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationDnsZonesNameservers(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDnsZonesNameservers", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationDnsZonesNameservers), varargs...)
+}
+
+// GetOrganizationFileStorageVolumes mocks base method.
+func (m *MockClientInterface) GetOrganizationFileStorageVolumes(ctx context.Context, params *core.GetOrganizationFileStorageVolumesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationFileStorageVolumes", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationFileStorageVolumes indicates an expected call of GetOrganizationFileStorageVolumes.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationFileStorageVolumes(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationFileStorageVolumes", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationFileStorageVolumes), varargs...)
+}
+
+// GetOrganizationIpAddresses mocks base method.
+func (m *MockClientInterface) GetOrganizationIpAddresses(ctx context.Context, params *core.GetOrganizationIpAddressesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationIpAddresses", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationIpAddresses indicates an expected call of GetOrganizationIpAddresses.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationIpAddresses(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationIpAddresses", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationIpAddresses), varargs...)
+}
+
+// GetOrganizationLoadBalancers mocks base method.
+func (m *MockClientInterface) GetOrganizationLoadBalancers(ctx context.Context, params *core.GetOrganizationLoadBalancersParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationLoadBalancers", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationLoadBalancers indicates an expected call of GetOrganizationLoadBalancers.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationLoadBalancers(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationLoadBalancers", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationLoadBalancers), varargs...)
+}
+
+// GetOrganizationManaged mocks base method.
+func (m *MockClientInterface) GetOrganizationManaged(ctx context.Context, params *core.GetOrganizationManagedParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationManaged", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationManaged indicates an expected call of GetOrganizationManaged.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationManaged(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationManaged", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationManaged), varargs...)
+}
+
+// GetOrganizationNetworkSpeedProfiles mocks base method.
+func (m *MockClientInterface) GetOrganizationNetworkSpeedProfiles(ctx context.Context, params *core.GetOrganizationNetworkSpeedProfilesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationNetworkSpeedProfiles", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationNetworkSpeedProfiles indicates an expected call of GetOrganizationNetworkSpeedProfiles.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationNetworkSpeedProfiles(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationNetworkSpeedProfiles", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationNetworkSpeedProfiles), varargs...)
+}
+
+// GetOrganizationPolicyLimits mocks base method.
+func (m *MockClientInterface) GetOrganizationPolicyLimits(ctx context.Context, params *core.GetOrganizationPolicyLimitsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationPolicyLimits", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationPolicyLimits indicates an expected call of GetOrganizationPolicyLimits.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationPolicyLimits(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationPolicyLimits", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationPolicyLimits), varargs...)
+}
+
+// GetOrganizationSecurityGroups mocks base method.
+func (m *MockClientInterface) GetOrganizationSecurityGroups(ctx context.Context, params *core.GetOrganizationSecurityGroupsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationSecurityGroups", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationSecurityGroups indicates an expected call of GetOrganizationSecurityGroups.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationSecurityGroups(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationSecurityGroups", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationSecurityGroups), varargs...)
+}
+
+// GetOrganizationSshKeys mocks base method.
+func (m *MockClientInterface) GetOrganizationSshKeys(ctx context.Context, params *core.GetOrganizationSshKeysParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationSshKeys", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationSshKeys indicates an expected call of GetOrganizationSshKeys.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationSshKeys(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationSshKeys", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationSshKeys), varargs...)
+}
+
+// GetOrganizationTags mocks base method.
+func (m *MockClientInterface) GetOrganizationTags(ctx context.Context, params *core.GetOrganizationTagsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationTags", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationTags indicates an expected call of GetOrganizationTags.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationTags(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationTags", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationTags), varargs...)
+}
+
+// GetOrganizationTrashObjects mocks base method.
+func (m *MockClientInterface) GetOrganizationTrashObjects(ctx context.Context, params *core.GetOrganizationTrashObjectsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationTrashObjects", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationTrashObjects indicates an expected call of GetOrganizationTrashObjects.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationTrashObjects(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationTrashObjects", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationTrashObjects), varargs...)
+}
+
+// GetOrganizationUsersWithAccess mocks base method.
+func (m *MockClientInterface) GetOrganizationUsersWithAccess(ctx context.Context, params *core.GetOrganizationUsersWithAccessParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationUsersWithAccess", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationUsersWithAccess indicates an expected call of GetOrganizationUsersWithAccess.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationUsersWithAccess(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationUsersWithAccess", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationUsersWithAccess), varargs...)
+}
+
+// GetOrganizationVirtualMachineGroups mocks base method.
+func (m *MockClientInterface) GetOrganizationVirtualMachineGroups(ctx context.Context, params *core.GetOrganizationVirtualMachineGroupsParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationVirtualMachineGroups", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationVirtualMachineGroups indicates an expected call of GetOrganizationVirtualMachineGroups.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationVirtualMachineGroups(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationVirtualMachineGroups", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationVirtualMachineGroups), varargs...)
+}
+
+// GetOrganizationVirtualMachines mocks base method.
+func (m *MockClientInterface) GetOrganizationVirtualMachines(ctx context.Context, params *core.GetOrganizationVirtualMachinesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationVirtualMachines", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationVirtualMachines indicates an expected call of GetOrganizationVirtualMachines.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizationVirtualMachines(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationVirtualMachines", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizationVirtualMachines), varargs...)
+}
+
+// GetOrganizations mocks base method.
+func (m *MockClientInterface) GetOrganizations(ctx context.Context, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizations", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizations indicates an expected call of GetOrganizations.
+func (mr *MockClientInterfaceMockRecorder) GetOrganizations(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizations", reflect.TypeOf((*MockClientInterface)(nil).GetOrganizations), varargs...)
+}
+
+// GetSecurityGroup mocks base method.
+func (m *MockClientInterface) GetSecurityGroup(ctx context.Context, params *core.GetSecurityGroupParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroup indicates an expected call of GetSecurityGroup.
+func (mr *MockClientInterfaceMockRecorder) GetSecurityGroup(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroup", reflect.TypeOf((*MockClientInterface)(nil).GetSecurityGroup), varargs...)
+}
+
+// GetSecurityGroupRules mocks base method.
+func (m *MockClientInterface) GetSecurityGroupRules(ctx context.Context, params *core.GetSecurityGroupRulesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroupRules", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroupRules indicates an expected call of GetSecurityGroupRules.
+func (mr *MockClientInterfaceMockRecorder) GetSecurityGroupRules(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupRules", reflect.TypeOf((*MockClientInterface)(nil).GetSecurityGroupRules), varargs...)
+}
+
+// GetSecurityGroupsRulesSecurityGroupRule mocks base method.
+func (m *MockClientInterface) GetSecurityGroupsRulesSecurityGroupRule(ctx context.Context, params *core.GetSecurityGroupsRulesSecurityGroupRuleParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroupsRulesSecurityGroupRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroupsRulesSecurityGroupRule indicates an expected call of GetSecurityGroupsRulesSecurityGroupRule.
+func (mr *MockClientInterfaceMockRecorder) GetSecurityGroupsRulesSecurityGroupRule(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsRulesSecurityGroupRule", reflect.TypeOf((*MockClientInterface)(nil).GetSecurityGroupsRulesSecurityGroupRule), varargs...)
+}
+
+// GetTag mocks base method.
+func (m *MockClientInterface) GetTag(ctx context.Context, params *core.GetTagParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTag", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTag indicates an expected call of GetTag.
+func (mr *MockClientInterfaceMockRecorder) GetTag(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTag", reflect.TypeOf((*MockClientInterface)(nil).GetTag), varargs...)
+}
+
+// GetTask mocks base method.
+func (m *MockClientInterface) GetTask(ctx context.Context, params *core.GetTaskParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTask", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTask indicates an expected call of GetTask.
+func (mr *MockClientInterfaceMockRecorder) GetTask(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTask", reflect.TypeOf((*MockClientInterface)(nil).GetTask), varargs...)
+}
+
+// GetTrashObject mocks base method.
+func (m *MockClientInterface) GetTrashObject(ctx context.Context, params *core.GetTrashObjectParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTrashObject", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTrashObject indicates an expected call of GetTrashObject.
+func (mr *MockClientInterfaceMockRecorder) GetTrashObject(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrashObject", reflect.TypeOf((*MockClientInterface)(nil).GetTrashObject), varargs...)
+}
+
+// GetUsersCurrent mocks base method.
+func (m *MockClientInterface) GetUsersCurrent(ctx context.Context, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUsersCurrent", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUsersCurrent indicates an expected call of GetUsersCurrent.
+func (mr *MockClientInterfaceMockRecorder) GetUsersCurrent(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersCurrent", reflect.TypeOf((*MockClientInterface)(nil).GetUsersCurrent), varargs...)
+}
+
+// GetVMNIVMNI mocks base method.
+func (m *MockClientInterface) GetVMNIVMNI(ctx context.Context, params *core.GetVMNIVMNIParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVMNIVMNI", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVMNIVMNI indicates an expected call of GetVMNIVMNI.
+func (mr *MockClientInterfaceMockRecorder) GetVMNIVMNI(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVMNIVMNI", reflect.TypeOf((*MockClientInterface)(nil).GetVMNIVMNI), varargs...)
+}
+
+// GetVirtualMachine mocks base method.
+func (m *MockClientInterface) GetVirtualMachine(ctx context.Context, params *core.GetVirtualMachineParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachine", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachine indicates an expected call of GetVirtualMachine.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachine(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachine", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachine), varargs...)
+}
+
+// GetVirtualMachineAuthorizedKeys mocks base method.
+func (m *MockClientInterface) GetVirtualMachineAuthorizedKeys(ctx context.Context, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineAuthorizedKeys", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineAuthorizedKeys indicates an expected call of GetVirtualMachineAuthorizedKeys.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineAuthorizedKeys(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineAuthorizedKeys", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineAuthorizedKeys), varargs...)
+}
+
+// GetVirtualMachineDiskBackupPolicies mocks base method.
+func (m *MockClientInterface) GetVirtualMachineDiskBackupPolicies(ctx context.Context, params *core.GetVirtualMachineDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineDiskBackupPolicies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineDiskBackupPolicies indicates an expected call of GetVirtualMachineDiskBackupPolicies.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineDiskBackupPolicies(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineDiskBackupPolicies", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineDiskBackupPolicies), varargs...)
+}
+
+// GetVirtualMachineDisks mocks base method.
+func (m *MockClientInterface) GetVirtualMachineDisks(ctx context.Context, params *core.GetVirtualMachineDisksParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineDisks", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineDisks indicates an expected call of GetVirtualMachineDisks.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineDisks(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineDisks", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineDisks), varargs...)
+}
+
+// GetVirtualMachineGroup mocks base method.
+func (m *MockClientInterface) GetVirtualMachineGroup(ctx context.Context, params *core.GetVirtualMachineGroupParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineGroup indicates an expected call of GetVirtualMachineGroup.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineGroup(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineGroup", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineGroup), varargs...)
+}
+
+// GetVirtualMachineNetworkInterface mocks base method.
+func (m *MockClientInterface) GetVirtualMachineNetworkInterface(ctx context.Context, params *core.GetVirtualMachineNetworkInterfaceParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterface", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterface indicates an expected call of GetVirtualMachineNetworkInterface.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineNetworkInterface(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterface", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineNetworkInterface), varargs...)
+}
+
+// GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion mocks base method.
+func (m *MockClientInterface) GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion(ctx context.Context, params *core.GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion indicates an expected call of GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersion), varargs...)
+}
+
+// GetVirtualMachineNetworkInterfaces mocks base method.
+func (m *MockClientInterface) GetVirtualMachineNetworkInterfaces(ctx context.Context, params *core.GetVirtualMachineNetworkInterfacesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterfaces", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterfaces indicates an expected call of GetVirtualMachineNetworkInterfaces.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachineNetworkInterfaces(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterfaces", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachineNetworkInterfaces), varargs...)
+}
+
+// GetVirtualMachinePackage mocks base method.
+func (m *MockClientInterface) GetVirtualMachinePackage(ctx context.Context, params *core.GetVirtualMachinePackageParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackage", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackage indicates an expected call of GetVirtualMachinePackage.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachinePackage(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackage", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachinePackage), varargs...)
+}
+
+// GetVirtualMachinePackages mocks base method.
+func (m *MockClientInterface) GetVirtualMachinePackages(ctx context.Context, params *core.GetVirtualMachinePackagesParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackages", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackages indicates an expected call of GetVirtualMachinePackages.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachinePackages(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackages", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachinePackages), varargs...)
+}
+
+// GetVirtualMachinesBuildsVirtualMachineBuild mocks base method.
+func (m *MockClientInterface) GetVirtualMachinesBuildsVirtualMachineBuild(ctx context.Context, params *core.GetVirtualMachinesBuildsVirtualMachineBuildParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinesBuildsVirtualMachineBuild", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinesBuildsVirtualMachineBuild indicates an expected call of GetVirtualMachinesBuildsVirtualMachineBuild.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachinesBuildsVirtualMachineBuild(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinesBuildsVirtualMachineBuild", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachinesBuildsVirtualMachineBuild), varargs...)
+}
+
+// GetZone mocks base method.
+func (m *MockClientInterface) GetZone(ctx context.Context, params *core.GetZoneParams, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetZone", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetZone indicates an expected call of GetZone.
+func (mr *MockClientInterfaceMockRecorder) GetZone(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZone", reflect.TypeOf((*MockClientInterface)(nil).GetZone), varargs...)
+}
+
+// GetZones mocks base method.
+func (m *MockClientInterface) GetZones(ctx context.Context, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetZones", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetZones indicates an expected call of GetZones.
+func (mr *MockClientInterfaceMockRecorder) GetZones(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZones", reflect.TypeOf((*MockClientInterface)(nil).GetZones), varargs...)
+}
+
+// PatchAddressList mocks base method.
+func (m *MockClientInterface) PatchAddressList(ctx context.Context, body core.PatchAddressListJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressList", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressList indicates an expected call of PatchAddressList.
+func (mr *MockClientInterfaceMockRecorder) PatchAddressList(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressList", reflect.TypeOf((*MockClientInterface)(nil).PatchAddressList), varargs...)
+}
+
+// PatchAddressListEntry mocks base method.
+func (m *MockClientInterface) PatchAddressListEntry(ctx context.Context, body core.PatchAddressListEntryJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListEntry", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListEntry indicates an expected call of PatchAddressListEntry.
+func (mr *MockClientInterfaceMockRecorder) PatchAddressListEntry(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListEntry", reflect.TypeOf((*MockClientInterface)(nil).PatchAddressListEntry), varargs...)
+}
+
+// PatchAddressListEntryWithBody mocks base method.
+func (m *MockClientInterface) PatchAddressListEntryWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListEntryWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListEntryWithBody indicates an expected call of PatchAddressListEntryWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchAddressListEntryWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListEntryWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchAddressListEntryWithBody), varargs...)
+}
+
+// PatchAddressListWithBody mocks base method.
+func (m *MockClientInterface) PatchAddressListWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListWithBody indicates an expected call of PatchAddressListWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchAddressListWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchAddressListWithBody), varargs...)
+}
+
+// PatchDiskBackupPolicy mocks base method.
+func (m *MockClientInterface) PatchDiskBackupPolicy(ctx context.Context, body core.PatchDiskBackupPolicyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDiskBackupPolicy", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDiskBackupPolicy indicates an expected call of PatchDiskBackupPolicy.
+func (mr *MockClientInterfaceMockRecorder) PatchDiskBackupPolicy(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDiskBackupPolicy", reflect.TypeOf((*MockClientInterface)(nil).PatchDiskBackupPolicy), varargs...)
+}
+
+// PatchDiskBackupPolicyWithBody mocks base method.
+func (m *MockClientInterface) PatchDiskBackupPolicyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDiskBackupPolicyWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDiskBackupPolicyWithBody indicates an expected call of PatchDiskBackupPolicyWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchDiskBackupPolicyWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDiskBackupPolicyWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchDiskBackupPolicyWithBody), varargs...)
+}
+
+// PatchDnsRecord mocks base method.
+func (m *MockClientInterface) PatchDnsRecord(ctx context.Context, body core.PatchDnsRecordJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsRecord", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsRecord indicates an expected call of PatchDnsRecord.
+func (mr *MockClientInterfaceMockRecorder) PatchDnsRecord(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsRecord", reflect.TypeOf((*MockClientInterface)(nil).PatchDnsRecord), varargs...)
+}
+
+// PatchDnsRecordWithBody mocks base method.
+func (m *MockClientInterface) PatchDnsRecordWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsRecordWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsRecordWithBody indicates an expected call of PatchDnsRecordWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchDnsRecordWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsRecordWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchDnsRecordWithBody), varargs...)
+}
+
+// PatchDnsZone mocks base method.
+func (m *MockClientInterface) PatchDnsZone(ctx context.Context, body core.PatchDnsZoneJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsZone", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsZone indicates an expected call of PatchDnsZone.
+func (mr *MockClientInterfaceMockRecorder) PatchDnsZone(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsZone", reflect.TypeOf((*MockClientInterface)(nil).PatchDnsZone), varargs...)
+}
+
+// PatchDnsZoneWithBody mocks base method.
+func (m *MockClientInterface) PatchDnsZoneWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsZoneWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsZoneWithBody indicates an expected call of PatchDnsZoneWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchDnsZoneWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsZoneWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchDnsZoneWithBody), varargs...)
+}
+
+// PatchFileStorageVolume mocks base method.
+func (m *MockClientInterface) PatchFileStorageVolume(ctx context.Context, body core.PatchFileStorageVolumeJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchFileStorageVolume", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchFileStorageVolume indicates an expected call of PatchFileStorageVolume.
+func (mr *MockClientInterfaceMockRecorder) PatchFileStorageVolume(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFileStorageVolume", reflect.TypeOf((*MockClientInterface)(nil).PatchFileStorageVolume), varargs...)
+}
+
+// PatchFileStorageVolumeWithBody mocks base method.
+func (m *MockClientInterface) PatchFileStorageVolumeWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchFileStorageVolumeWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchFileStorageVolumeWithBody indicates an expected call of PatchFileStorageVolumeWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchFileStorageVolumeWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFileStorageVolumeWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchFileStorageVolumeWithBody), varargs...)
+}
+
+// PatchIpAddress mocks base method.
+func (m *MockClientInterface) PatchIpAddress(ctx context.Context, body core.PatchIpAddressJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchIpAddress", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchIpAddress indicates an expected call of PatchIpAddress.
+func (mr *MockClientInterfaceMockRecorder) PatchIpAddress(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchIpAddress", reflect.TypeOf((*MockClientInterface)(nil).PatchIpAddress), varargs...)
+}
+
+// PatchIpAddressWithBody mocks base method.
+func (m *MockClientInterface) PatchIpAddressWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchIpAddressWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchIpAddressWithBody indicates an expected call of PatchIpAddressWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchIpAddressWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchIpAddressWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchIpAddressWithBody), varargs...)
+}
+
+// PatchLoadBalancer mocks base method.
+func (m *MockClientInterface) PatchLoadBalancer(ctx context.Context, body core.PatchLoadBalancerJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancer", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancer indicates an expected call of PatchLoadBalancer.
+func (mr *MockClientInterfaceMockRecorder) PatchLoadBalancer(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancer", reflect.TypeOf((*MockClientInterface)(nil).PatchLoadBalancer), varargs...)
+}
+
+// PatchLoadBalancerWithBody mocks base method.
+func (m *MockClientInterface) PatchLoadBalancerWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancerWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancerWithBody indicates an expected call of PatchLoadBalancerWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchLoadBalancerWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancerWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchLoadBalancerWithBody), varargs...)
+}
+
+// PatchLoadBalancersRulesLoadBalancerRule mocks base method.
+func (m *MockClientInterface) PatchLoadBalancersRulesLoadBalancerRule(ctx context.Context, body core.PatchLoadBalancersRulesLoadBalancerRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancersRulesLoadBalancerRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancersRulesLoadBalancerRule indicates an expected call of PatchLoadBalancersRulesLoadBalancerRule.
+func (mr *MockClientInterfaceMockRecorder) PatchLoadBalancersRulesLoadBalancerRule(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancersRulesLoadBalancerRule", reflect.TypeOf((*MockClientInterface)(nil).PatchLoadBalancersRulesLoadBalancerRule), varargs...)
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithBody mocks base method.
+func (m *MockClientInterface) PatchLoadBalancersRulesLoadBalancerRuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancersRulesLoadBalancerRuleWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithBody indicates an expected call of PatchLoadBalancersRulesLoadBalancerRuleWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchLoadBalancersRulesLoadBalancerRuleWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancersRulesLoadBalancerRuleWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchLoadBalancersRulesLoadBalancerRuleWithBody), varargs...)
+}
+
+// PatchSecurityGroup mocks base method.
+func (m *MockClientInterface) PatchSecurityGroup(ctx context.Context, body core.PatchSecurityGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroup indicates an expected call of PatchSecurityGroup.
+func (mr *MockClientInterfaceMockRecorder) PatchSecurityGroup(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroup", reflect.TypeOf((*MockClientInterface)(nil).PatchSecurityGroup), varargs...)
+}
+
+// PatchSecurityGroupWithBody mocks base method.
+func (m *MockClientInterface) PatchSecurityGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupWithBody indicates an expected call of PatchSecurityGroupWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchSecurityGroupWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchSecurityGroupWithBody), varargs...)
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRule mocks base method.
+func (m *MockClientInterface) PatchSecurityGroupsRulesSecurityGroupRule(ctx context.Context, body core.PatchSecurityGroupsRulesSecurityGroupRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupsRulesSecurityGroupRule", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRule indicates an expected call of PatchSecurityGroupsRulesSecurityGroupRule.
+func (mr *MockClientInterfaceMockRecorder) PatchSecurityGroupsRulesSecurityGroupRule(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupsRulesSecurityGroupRule", reflect.TypeOf((*MockClientInterface)(nil).PatchSecurityGroupsRulesSecurityGroupRule), varargs...)
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithBody mocks base method.
+func (m *MockClientInterface) PatchSecurityGroupsRulesSecurityGroupRuleWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupsRulesSecurityGroupRuleWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithBody indicates an expected call of PatchSecurityGroupsRulesSecurityGroupRuleWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchSecurityGroupsRulesSecurityGroupRuleWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupsRulesSecurityGroupRuleWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchSecurityGroupsRulesSecurityGroupRuleWithBody), varargs...)
+}
+
+// PatchTag mocks base method.
+func (m *MockClientInterface) PatchTag(ctx context.Context, body core.PatchTagJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchTag", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchTag indicates an expected call of PatchTag.
+func (mr *MockClientInterfaceMockRecorder) PatchTag(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTag", reflect.TypeOf((*MockClientInterface)(nil).PatchTag), varargs...)
+}
+
+// PatchTagWithBody mocks base method.
+func (m *MockClientInterface) PatchTagWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchTagWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchTagWithBody indicates an expected call of PatchTagWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchTagWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTagWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchTagWithBody), varargs...)
+}
+
+// PatchVirtualMachine mocks base method.
+func (m *MockClientInterface) PatchVirtualMachine(ctx context.Context, body core.PatchVirtualMachineJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachine", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachine indicates an expected call of PatchVirtualMachine.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachine(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachine", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachine), varargs...)
+}
+
+// PatchVirtualMachineGroup mocks base method.
+func (m *MockClientInterface) PatchVirtualMachineGroup(ctx context.Context, body core.PatchVirtualMachineGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineGroup", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineGroup indicates an expected call of PatchVirtualMachineGroup.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachineGroup(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineGroup", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachineGroup), varargs...)
+}
+
+// PatchVirtualMachineGroupWithBody mocks base method.
+func (m *MockClientInterface) PatchVirtualMachineGroupWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineGroupWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineGroupWithBody indicates an expected call of PatchVirtualMachineGroupWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachineGroupWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineGroupWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachineGroupWithBody), varargs...)
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile mocks base method.
+func (m *MockClientInterface) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile(ctx context.Context, body core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile indicates an expected call of PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachineNetworkInterfaceUpdateSpeedProfile), varargs...)
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody mocks base method.
+func (m *MockClientInterface) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody indicates an expected call of PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBody), varargs...)
+}
+
+// PatchVirtualMachineWithBody mocks base method.
+func (m *MockClientInterface) PatchVirtualMachineWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineWithBody indicates an expected call of PatchVirtualMachineWithBody.
+func (mr *MockClientInterfaceMockRecorder) PatchVirtualMachineWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineWithBody", reflect.TypeOf((*MockClientInterface)(nil).PatchVirtualMachineWithBody), varargs...)
+}
+
+// PostAddressListEntries mocks base method.
+func (m *MockClientInterface) PostAddressListEntries(ctx context.Context, body core.PostAddressListEntriesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostAddressListEntries", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostAddressListEntries indicates an expected call of PostAddressListEntries.
+func (mr *MockClientInterfaceMockRecorder) PostAddressListEntries(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAddressListEntries", reflect.TypeOf((*MockClientInterface)(nil).PostAddressListEntries), varargs...)
+}
+
+// PostAddressListEntriesWithBody mocks base method.
+func (m *MockClientInterface) PostAddressListEntriesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostAddressListEntriesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostAddressListEntriesWithBody indicates an expected call of PostAddressListEntriesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostAddressListEntriesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAddressListEntriesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostAddressListEntriesWithBody), varargs...)
+}
+
+// PostDiskDiskBackupPolicies mocks base method.
+func (m *MockClientInterface) PostDiskDiskBackupPolicies(ctx context.Context, body core.PostDiskDiskBackupPoliciesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDiskDiskBackupPolicies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDiskDiskBackupPolicies indicates an expected call of PostDiskDiskBackupPolicies.
+func (mr *MockClientInterfaceMockRecorder) PostDiskDiskBackupPolicies(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDiskDiskBackupPolicies", reflect.TypeOf((*MockClientInterface)(nil).PostDiskDiskBackupPolicies), varargs...)
+}
+
+// PostDiskDiskBackupPoliciesWithBody mocks base method.
+func (m *MockClientInterface) PostDiskDiskBackupPoliciesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDiskDiskBackupPoliciesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDiskDiskBackupPoliciesWithBody indicates an expected call of PostDiskDiskBackupPoliciesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostDiskDiskBackupPoliciesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDiskDiskBackupPoliciesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostDiskDiskBackupPoliciesWithBody), varargs...)
+}
+
+// PostDnsZoneRecords mocks base method.
+func (m *MockClientInterface) PostDnsZoneRecords(ctx context.Context, body core.PostDnsZoneRecordsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneRecords", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneRecords indicates an expected call of PostDnsZoneRecords.
+func (mr *MockClientInterfaceMockRecorder) PostDnsZoneRecords(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneRecords", reflect.TypeOf((*MockClientInterface)(nil).PostDnsZoneRecords), varargs...)
+}
+
+// PostDnsZoneRecordsWithBody mocks base method.
+func (m *MockClientInterface) PostDnsZoneRecordsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneRecordsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneRecordsWithBody indicates an expected call of PostDnsZoneRecordsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostDnsZoneRecordsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneRecordsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostDnsZoneRecordsWithBody), varargs...)
+}
+
+// PostDnsZoneVerify mocks base method.
+func (m *MockClientInterface) PostDnsZoneVerify(ctx context.Context, body core.PostDnsZoneVerifyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneVerify", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneVerify indicates an expected call of PostDnsZoneVerify.
+func (mr *MockClientInterfaceMockRecorder) PostDnsZoneVerify(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneVerify", reflect.TypeOf((*MockClientInterface)(nil).PostDnsZoneVerify), varargs...)
+}
+
+// PostDnsZoneVerifyWithBody mocks base method.
+func (m *MockClientInterface) PostDnsZoneVerifyWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneVerifyWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneVerifyWithBody indicates an expected call of PostDnsZoneVerifyWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostDnsZoneVerifyWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneVerifyWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostDnsZoneVerifyWithBody), varargs...)
+}
+
+// PostInvalidateLinkedWebSession mocks base method.
+func (m *MockClientInterface) PostInvalidateLinkedWebSession(ctx context.Context, body core.PostInvalidateLinkedWebSessionJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostInvalidateLinkedWebSession", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostInvalidateLinkedWebSession indicates an expected call of PostInvalidateLinkedWebSession.
+func (mr *MockClientInterfaceMockRecorder) PostInvalidateLinkedWebSession(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInvalidateLinkedWebSession", reflect.TypeOf((*MockClientInterface)(nil).PostInvalidateLinkedWebSession), varargs...)
+}
+
+// PostInvalidateLinkedWebSessionWithBody mocks base method.
+func (m *MockClientInterface) PostInvalidateLinkedWebSessionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostInvalidateLinkedWebSessionWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostInvalidateLinkedWebSessionWithBody indicates an expected call of PostInvalidateLinkedWebSessionWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostInvalidateLinkedWebSessionWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInvalidateLinkedWebSessionWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostInvalidateLinkedWebSessionWithBody), varargs...)
+}
+
+// PostIpAddressUnallocate mocks base method.
+func (m *MockClientInterface) PostIpAddressUnallocate(ctx context.Context, body core.PostIpAddressUnallocateJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostIpAddressUnallocate", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostIpAddressUnallocate indicates an expected call of PostIpAddressUnallocate.
+func (mr *MockClientInterfaceMockRecorder) PostIpAddressUnallocate(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostIpAddressUnallocate", reflect.TypeOf((*MockClientInterface)(nil).PostIpAddressUnallocate), varargs...)
+}
+
+// PostIpAddressUnallocateWithBody mocks base method.
+func (m *MockClientInterface) PostIpAddressUnallocateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostIpAddressUnallocateWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostIpAddressUnallocateWithBody indicates an expected call of PostIpAddressUnallocateWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostIpAddressUnallocateWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostIpAddressUnallocateWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostIpAddressUnallocateWithBody), varargs...)
+}
+
+// PostLoadBalancerRules mocks base method.
+func (m *MockClientInterface) PostLoadBalancerRules(ctx context.Context, body core.PostLoadBalancerRulesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostLoadBalancerRules", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostLoadBalancerRules indicates an expected call of PostLoadBalancerRules.
+func (mr *MockClientInterfaceMockRecorder) PostLoadBalancerRules(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLoadBalancerRules", reflect.TypeOf((*MockClientInterface)(nil).PostLoadBalancerRules), varargs...)
+}
+
+// PostLoadBalancerRulesWithBody mocks base method.
+func (m *MockClientInterface) PostLoadBalancerRulesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostLoadBalancerRulesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostLoadBalancerRulesWithBody indicates an expected call of PostLoadBalancerRulesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostLoadBalancerRulesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLoadBalancerRulesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostLoadBalancerRulesWithBody), varargs...)
+}
+
+// PostOrganizationAddressLists mocks base method.
+func (m *MockClientInterface) PostOrganizationAddressLists(ctx context.Context, body core.PostOrganizationAddressListsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationAddressLists", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationAddressLists indicates an expected call of PostOrganizationAddressLists.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationAddressLists(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationAddressLists", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationAddressLists), varargs...)
+}
+
+// PostOrganizationAddressListsWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationAddressListsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationAddressListsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationAddressListsWithBody indicates an expected call of PostOrganizationAddressListsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationAddressListsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationAddressListsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationAddressListsWithBody), varargs...)
+}
+
+// PostOrganizationDnsZones mocks base method.
+func (m *MockClientInterface) PostOrganizationDnsZones(ctx context.Context, body core.PostOrganizationDnsZonesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationDnsZones", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationDnsZones indicates an expected call of PostOrganizationDnsZones.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationDnsZones(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationDnsZones", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationDnsZones), varargs...)
+}
+
+// PostOrganizationDnsZonesWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationDnsZonesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationDnsZonesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationDnsZonesWithBody indicates an expected call of PostOrganizationDnsZonesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationDnsZonesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationDnsZonesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationDnsZonesWithBody), varargs...)
+}
+
+// PostOrganizationFileStorageVolumes mocks base method.
+func (m *MockClientInterface) PostOrganizationFileStorageVolumes(ctx context.Context, body core.PostOrganizationFileStorageVolumesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationFileStorageVolumes", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationFileStorageVolumes indicates an expected call of PostOrganizationFileStorageVolumes.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationFileStorageVolumes(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationFileStorageVolumes", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationFileStorageVolumes), varargs...)
+}
+
+// PostOrganizationFileStorageVolumesWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationFileStorageVolumesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationFileStorageVolumesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationFileStorageVolumesWithBody indicates an expected call of PostOrganizationFileStorageVolumesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationFileStorageVolumesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationFileStorageVolumesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationFileStorageVolumesWithBody), varargs...)
+}
+
+// PostOrganizationIpAddresses mocks base method.
+func (m *MockClientInterface) PostOrganizationIpAddresses(ctx context.Context, body core.PostOrganizationIpAddressesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationIpAddresses", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationIpAddresses indicates an expected call of PostOrganizationIpAddresses.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationIpAddresses(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationIpAddresses", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationIpAddresses), varargs...)
+}
+
+// PostOrganizationIpAddressesWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationIpAddressesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationIpAddressesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationIpAddressesWithBody indicates an expected call of PostOrganizationIpAddressesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationIpAddressesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationIpAddressesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationIpAddressesWithBody), varargs...)
+}
+
+// PostOrganizationLoadBalancers mocks base method.
+func (m *MockClientInterface) PostOrganizationLoadBalancers(ctx context.Context, body core.PostOrganizationLoadBalancersJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationLoadBalancers", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationLoadBalancers indicates an expected call of PostOrganizationLoadBalancers.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationLoadBalancers(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationLoadBalancers", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationLoadBalancers), varargs...)
+}
+
+// PostOrganizationLoadBalancersWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationLoadBalancersWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationLoadBalancersWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationLoadBalancersWithBody indicates an expected call of PostOrganizationLoadBalancersWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationLoadBalancersWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationLoadBalancersWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationLoadBalancersWithBody), varargs...)
+}
+
+// PostOrganizationManaged mocks base method.
+func (m *MockClientInterface) PostOrganizationManaged(ctx context.Context, body core.PostOrganizationManagedJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationManaged", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationManaged indicates an expected call of PostOrganizationManaged.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationManaged(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationManaged", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationManaged), varargs...)
+}
+
+// PostOrganizationManagedWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationManagedWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationManagedWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationManagedWithBody indicates an expected call of PostOrganizationManagedWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationManagedWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationManagedWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationManagedWithBody), varargs...)
+}
+
+// PostOrganizationSecurityGroups mocks base method.
+func (m *MockClientInterface) PostOrganizationSecurityGroups(ctx context.Context, body core.PostOrganizationSecurityGroupsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSecurityGroups", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSecurityGroups indicates an expected call of PostOrganizationSecurityGroups.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationSecurityGroups(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSecurityGroups", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationSecurityGroups), varargs...)
+}
+
+// PostOrganizationSecurityGroupsWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationSecurityGroupsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSecurityGroupsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSecurityGroupsWithBody indicates an expected call of PostOrganizationSecurityGroupsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationSecurityGroupsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSecurityGroupsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationSecurityGroupsWithBody), varargs...)
+}
+
+// PostOrganizationSshKeys mocks base method.
+func (m *MockClientInterface) PostOrganizationSshKeys(ctx context.Context, body core.PostOrganizationSshKeysJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSshKeys", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSshKeys indicates an expected call of PostOrganizationSshKeys.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationSshKeys(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSshKeys", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationSshKeys), varargs...)
+}
+
+// PostOrganizationSshKeysWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationSshKeysWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSshKeysWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSshKeysWithBody indicates an expected call of PostOrganizationSshKeysWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationSshKeysWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSshKeysWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationSshKeysWithBody), varargs...)
+}
+
+// PostOrganizationTags mocks base method.
+func (m *MockClientInterface) PostOrganizationTags(ctx context.Context, body core.PostOrganizationTagsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTags", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTags indicates an expected call of PostOrganizationTags.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationTags(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTags", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationTags), varargs...)
+}
+
+// PostOrganizationTagsWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationTagsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTagsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTagsWithBody indicates an expected call of PostOrganizationTagsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationTagsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTagsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationTagsWithBody), varargs...)
+}
+
+// PostOrganizationTrashObjectsPurgeAll mocks base method.
+func (m *MockClientInterface) PostOrganizationTrashObjectsPurgeAll(ctx context.Context, body core.PostOrganizationTrashObjectsPurgeAllJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTrashObjectsPurgeAll", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTrashObjectsPurgeAll indicates an expected call of PostOrganizationTrashObjectsPurgeAll.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationTrashObjectsPurgeAll(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTrashObjectsPurgeAll", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationTrashObjectsPurgeAll), varargs...)
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationTrashObjectsPurgeAllWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTrashObjectsPurgeAllWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithBody indicates an expected call of PostOrganizationTrashObjectsPurgeAllWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationTrashObjectsPurgeAllWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTrashObjectsPurgeAllWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationTrashObjectsPurgeAllWithBody), varargs...)
+}
+
+// PostOrganizationVirtualMachineGroups mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachineGroups(ctx context.Context, body core.PostOrganizationVirtualMachineGroupsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachineGroups", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachineGroups indicates an expected call of PostOrganizationVirtualMachineGroups.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachineGroups(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachineGroups", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachineGroups), varargs...)
+}
+
+// PostOrganizationVirtualMachineGroupsWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachineGroupsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachineGroupsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachineGroupsWithBody indicates an expected call of PostOrganizationVirtualMachineGroupsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachineGroupsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachineGroupsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachineGroupsWithBody), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuild mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachinesBuild(ctx context.Context, body core.PostOrganizationVirtualMachinesBuildJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuild", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuild indicates an expected call of PostOrganizationVirtualMachinesBuild.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachinesBuild(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuild", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachinesBuild), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpec mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachinesBuildFromSpec(ctx context.Context, body core.PostOrganizationVirtualMachinesBuildFromSpecJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildFromSpec", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpec indicates an expected call of PostOrganizationVirtualMachinesBuildFromSpec.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildFromSpec(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildFromSpec", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachinesBuildFromSpec), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachinesBuildFromSpecWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildFromSpecWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithBody indicates an expected call of PostOrganizationVirtualMachinesBuildFromSpecWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildFromSpecWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildFromSpecWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachinesBuildFromSpecWithBody), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildWithBody mocks base method.
+func (m *MockClientInterface) PostOrganizationVirtualMachinesBuildWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildWithBody indicates an expected call of PostOrganizationVirtualMachinesBuildWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostOrganizationVirtualMachinesBuildWithBody), varargs...)
+}
+
+// PostSecurityGroupRules mocks base method.
+func (m *MockClientInterface) PostSecurityGroupRules(ctx context.Context, body core.PostSecurityGroupRulesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSecurityGroupRules", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSecurityGroupRules indicates an expected call of PostSecurityGroupRules.
+func (mr *MockClientInterfaceMockRecorder) PostSecurityGroupRules(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSecurityGroupRules", reflect.TypeOf((*MockClientInterface)(nil).PostSecurityGroupRules), varargs...)
+}
+
+// PostSecurityGroupRulesWithBody mocks base method.
+func (m *MockClientInterface) PostSecurityGroupRulesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSecurityGroupRulesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSecurityGroupRulesWithBody indicates an expected call of PostSecurityGroupRulesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostSecurityGroupRulesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSecurityGroupRulesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostSecurityGroupRulesWithBody), varargs...)
+}
+
+// PostTrashObjectRestore mocks base method.
+func (m *MockClientInterface) PostTrashObjectRestore(ctx context.Context, body core.PostTrashObjectRestoreJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostTrashObjectRestore", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostTrashObjectRestore indicates an expected call of PostTrashObjectRestore.
+func (mr *MockClientInterfaceMockRecorder) PostTrashObjectRestore(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTrashObjectRestore", reflect.TypeOf((*MockClientInterface)(nil).PostTrashObjectRestore), varargs...)
+}
+
+// PostTrashObjectRestoreWithBody mocks base method.
+func (m *MockClientInterface) PostTrashObjectRestoreWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostTrashObjectRestoreWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostTrashObjectRestoreWithBody indicates an expected call of PostTrashObjectRestoreWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostTrashObjectRestoreWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTrashObjectRestoreWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostTrashObjectRestoreWithBody), varargs...)
+}
+
+// PostVirtualMachineAllocateIp mocks base method.
+func (m *MockClientInterface) PostVirtualMachineAllocateIp(ctx context.Context, body core.PostVirtualMachineAllocateIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineAllocateIp", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineAllocateIp indicates an expected call of PostVirtualMachineAllocateIp.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineAllocateIp(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineAllocateIp", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineAllocateIp), varargs...)
+}
+
+// PostVirtualMachineAllocateIpWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineAllocateIpWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineAllocateIpWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineAllocateIpWithBody indicates an expected call of PostVirtualMachineAllocateIpWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineAllocateIpWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineAllocateIpWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineAllocateIpWithBody), varargs...)
+}
+
+// PostVirtualMachineConsoleSessions mocks base method.
+func (m *MockClientInterface) PostVirtualMachineConsoleSessions(ctx context.Context, body core.PostVirtualMachineConsoleSessionsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineConsoleSessions", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineConsoleSessions indicates an expected call of PostVirtualMachineConsoleSessions.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineConsoleSessions(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineConsoleSessions", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineConsoleSessions), varargs...)
+}
+
+// PostVirtualMachineConsoleSessionsWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineConsoleSessionsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineConsoleSessionsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineConsoleSessionsWithBody indicates an expected call of PostVirtualMachineConsoleSessionsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineConsoleSessionsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineConsoleSessionsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineConsoleSessionsWithBody), varargs...)
+}
+
+// PostVirtualMachineDiskBackupPolicies mocks base method.
+func (m *MockClientInterface) PostVirtualMachineDiskBackupPolicies(ctx context.Context, body core.PostVirtualMachineDiskBackupPoliciesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineDiskBackupPolicies", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineDiskBackupPolicies indicates an expected call of PostVirtualMachineDiskBackupPolicies.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineDiskBackupPolicies(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineDiskBackupPolicies", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineDiskBackupPolicies), varargs...)
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineDiskBackupPoliciesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineDiskBackupPoliciesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithBody indicates an expected call of PostVirtualMachineDiskBackupPoliciesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineDiskBackupPoliciesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineDiskBackupPoliciesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineDiskBackupPoliciesWithBody), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIp mocks base method.
+func (m *MockClientInterface) PostVirtualMachineNetworkInterfaceAllocateIp(ctx context.Context, body core.PostVirtualMachineNetworkInterfaceAllocateIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateIp", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIp indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateIp.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateIp(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateIp", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateIp), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineNetworkInterfaceAllocateIpWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateIpWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithBody indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateIpWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateIpWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateIpWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateIpWithBody), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIp mocks base method.
+func (m *MockClientInterface) PostVirtualMachineNetworkInterfaceAllocateNewIp(ctx context.Context, body core.PostVirtualMachineNetworkInterfaceAllocateNewIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateNewIp", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIp indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateNewIp.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateNewIp(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateNewIp", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateNewIp), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateNewIpWithBody), varargs...)
+}
+
+// PostVirtualMachineReset mocks base method.
+func (m *MockClientInterface) PostVirtualMachineReset(ctx context.Context, body core.PostVirtualMachineResetJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineReset", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineReset indicates an expected call of PostVirtualMachineReset.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineReset(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineReset", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineReset), varargs...)
+}
+
+// PostVirtualMachineResetWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineResetWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineResetWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineResetWithBody indicates an expected call of PostVirtualMachineResetWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineResetWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineResetWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineResetWithBody), varargs...)
+}
+
+// PostVirtualMachineShutdown mocks base method.
+func (m *MockClientInterface) PostVirtualMachineShutdown(ctx context.Context, body core.PostVirtualMachineShutdownJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineShutdown", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineShutdown indicates an expected call of PostVirtualMachineShutdown.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineShutdown(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineShutdown", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineShutdown), varargs...)
+}
+
+// PostVirtualMachineShutdownWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineShutdownWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineShutdownWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineShutdownWithBody indicates an expected call of PostVirtualMachineShutdownWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineShutdownWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineShutdownWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineShutdownWithBody), varargs...)
+}
+
+// PostVirtualMachineStart mocks base method.
+func (m *MockClientInterface) PostVirtualMachineStart(ctx context.Context, body core.PostVirtualMachineStartJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStart", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStart indicates an expected call of PostVirtualMachineStart.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineStart(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStart", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineStart), varargs...)
+}
+
+// PostVirtualMachineStartWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineStartWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStartWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStartWithBody indicates an expected call of PostVirtualMachineStartWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineStartWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStartWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineStartWithBody), varargs...)
+}
+
+// PostVirtualMachineStop mocks base method.
+func (m *MockClientInterface) PostVirtualMachineStop(ctx context.Context, body core.PostVirtualMachineStopJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStop", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStop indicates an expected call of PostVirtualMachineStop.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineStop(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStop", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineStop), varargs...)
+}
+
+// PostVirtualMachineStopWithBody mocks base method.
+func (m *MockClientInterface) PostVirtualMachineStopWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStopWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStopWithBody indicates an expected call of PostVirtualMachineStopWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostVirtualMachineStopWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStopWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostVirtualMachineStopWithBody), varargs...)
+}
+
+// PutVirtualMachineFlexibleResources mocks base method.
+func (m *MockClientInterface) PutVirtualMachineFlexibleResources(ctx context.Context, body core.PutVirtualMachineFlexibleResourcesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachineFlexibleResources", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachineFlexibleResources indicates an expected call of PutVirtualMachineFlexibleResources.
+func (mr *MockClientInterfaceMockRecorder) PutVirtualMachineFlexibleResources(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachineFlexibleResources", reflect.TypeOf((*MockClientInterface)(nil).PutVirtualMachineFlexibleResources), varargs...)
+}
+
+// PutVirtualMachineFlexibleResourcesWithBody mocks base method.
+func (m *MockClientInterface) PutVirtualMachineFlexibleResourcesWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachineFlexibleResourcesWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachineFlexibleResourcesWithBody indicates an expected call of PutVirtualMachineFlexibleResourcesWithBody.
+func (mr *MockClientInterfaceMockRecorder) PutVirtualMachineFlexibleResourcesWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachineFlexibleResourcesWithBody", reflect.TypeOf((*MockClientInterface)(nil).PutVirtualMachineFlexibleResourcesWithBody), varargs...)
+}
+
+// PutVirtualMachinePackage mocks base method.
+func (m *MockClientInterface) PutVirtualMachinePackage(ctx context.Context, body core.PutVirtualMachinePackageJSONRequestBody, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachinePackage", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachinePackage indicates an expected call of PutVirtualMachinePackage.
+func (mr *MockClientInterfaceMockRecorder) PutVirtualMachinePackage(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachinePackage", reflect.TypeOf((*MockClientInterface)(nil).PutVirtualMachinePackage), varargs...)
+}
+
+// PutVirtualMachinePackageWithBody mocks base method.
+func (m *MockClientInterface) PutVirtualMachinePackageWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachinePackageWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachinePackageWithBody indicates an expected call of PutVirtualMachinePackageWithBody.
+func (mr *MockClientInterfaceMockRecorder) PutVirtualMachinePackageWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachinePackageWithBody", reflect.TypeOf((*MockClientInterface)(nil).PutVirtualMachinePackageWithBody), varargs...)
+}
+
+// MockClientWithResponsesInterface is a mock of ClientWithResponsesInterface interface.
+type MockClientWithResponsesInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientWithResponsesInterfaceMockRecorder
+}
+
+// MockClientWithResponsesInterfaceMockRecorder is the mock recorder for MockClientWithResponsesInterface.
+type MockClientWithResponsesInterfaceMockRecorder struct {
+	mock *MockClientWithResponsesInterface
+}
+
+// NewMockClientWithResponsesInterface creates a new mock instance.
+func NewMockClientWithResponsesInterface(ctrl *gomock.Controller) *MockClientWithResponsesInterface {
+	mock := &MockClientWithResponsesInterface{ctrl: ctrl}
+	mock.recorder = &MockClientWithResponsesInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClientWithResponsesInterface) EXPECT() *MockClientWithResponsesInterfaceMockRecorder {
+	return m.recorder
+}
+
+// DeleteAddressListEntryWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteAddressListEntryWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteAddressListEntryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListEntryWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteAddressListEntryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListEntryWithBodyWithResponse indicates an expected call of DeleteAddressListEntryWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAddressListEntryWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListEntryWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAddressListEntryWithBodyWithResponse), varargs...)
+}
+
+// DeleteAddressListEntryWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteAddressListEntryWithResponse(ctx context.Context, body core.DeleteAddressListEntryJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteAddressListEntryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListEntryWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteAddressListEntryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListEntryWithResponse indicates an expected call of DeleteAddressListEntryWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAddressListEntryWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListEntryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAddressListEntryWithResponse), varargs...)
+}
+
+// DeleteAddressListWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteAddressListWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteAddressListResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteAddressListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListWithBodyWithResponse indicates an expected call of DeleteAddressListWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAddressListWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAddressListWithBodyWithResponse), varargs...)
+}
+
+// DeleteAddressListWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteAddressListWithResponse(ctx context.Context, body core.DeleteAddressListJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteAddressListResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteAddressListWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteAddressListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAddressListWithResponse indicates an expected call of DeleteAddressListWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteAddressListWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAddressListWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteAddressListWithResponse), varargs...)
+}
+
+// DeleteDiskBackupPolicyScheduleWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDiskBackupPolicyScheduleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteDiskBackupPolicyScheduleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyScheduleWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDiskBackupPolicyScheduleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyScheduleWithBodyWithResponse indicates an expected call of DeleteDiskBackupPolicyScheduleWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDiskBackupPolicyScheduleWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyScheduleWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDiskBackupPolicyScheduleWithBodyWithResponse), varargs...)
+}
+
+// DeleteDiskBackupPolicyScheduleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDiskBackupPolicyScheduleWithResponse(ctx context.Context, body core.DeleteDiskBackupPolicyScheduleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteDiskBackupPolicyScheduleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyScheduleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDiskBackupPolicyScheduleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyScheduleWithResponse indicates an expected call of DeleteDiskBackupPolicyScheduleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDiskBackupPolicyScheduleWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyScheduleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDiskBackupPolicyScheduleWithResponse), varargs...)
+}
+
+// DeleteDiskBackupPolicyWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDiskBackupPolicyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteDiskBackupPolicyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDiskBackupPolicyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyWithBodyWithResponse indicates an expected call of DeleteDiskBackupPolicyWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDiskBackupPolicyWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDiskBackupPolicyWithBodyWithResponse), varargs...)
+}
+
+// DeleteDiskBackupPolicyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDiskBackupPolicyWithResponse(ctx context.Context, body core.DeleteDiskBackupPolicyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteDiskBackupPolicyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDiskBackupPolicyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDiskBackupPolicyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDiskBackupPolicyWithResponse indicates an expected call of DeleteDiskBackupPolicyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDiskBackupPolicyWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDiskBackupPolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDiskBackupPolicyWithResponse), varargs...)
+}
+
+// DeleteDnsRecordWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDnsRecordWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteDnsRecordResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsRecordWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDnsRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsRecordWithBodyWithResponse indicates an expected call of DeleteDnsRecordWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDnsRecordWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsRecordWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDnsRecordWithBodyWithResponse), varargs...)
+}
+
+// DeleteDnsRecordWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDnsRecordWithResponse(ctx context.Context, body core.DeleteDnsRecordJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteDnsRecordResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsRecordWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDnsRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsRecordWithResponse indicates an expected call of DeleteDnsRecordWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDnsRecordWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsRecordWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDnsRecordWithResponse), varargs...)
+}
+
+// DeleteDnsZoneWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDnsZoneWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteDnsZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsZoneWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDnsZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsZoneWithBodyWithResponse indicates an expected call of DeleteDnsZoneWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDnsZoneWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsZoneWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDnsZoneWithBodyWithResponse), varargs...)
+}
+
+// DeleteDnsZoneWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteDnsZoneWithResponse(ctx context.Context, body core.DeleteDnsZoneJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteDnsZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteDnsZoneWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteDnsZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDnsZoneWithResponse indicates an expected call of DeleteDnsZoneWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteDnsZoneWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDnsZoneWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteDnsZoneWithResponse), varargs...)
+}
+
+// DeleteFileStorageVolumeWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteFileStorageVolumeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteFileStorageVolumeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteFileStorageVolumeWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteFileStorageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteFileStorageVolumeWithBodyWithResponse indicates an expected call of DeleteFileStorageVolumeWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteFileStorageVolumeWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFileStorageVolumeWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteFileStorageVolumeWithBodyWithResponse), varargs...)
+}
+
+// DeleteFileStorageVolumeWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteFileStorageVolumeWithResponse(ctx context.Context, body core.DeleteFileStorageVolumeJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteFileStorageVolumeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteFileStorageVolumeWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteFileStorageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteFileStorageVolumeWithResponse indicates an expected call of DeleteFileStorageVolumeWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteFileStorageVolumeWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFileStorageVolumeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteFileStorageVolumeWithResponse), varargs...)
+}
+
+// DeleteIpAddressWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteIpAddressWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteIpAddressResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteIpAddressWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteIpAddressResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIpAddressWithBodyWithResponse indicates an expected call of DeleteIpAddressWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteIpAddressWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpAddressWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteIpAddressWithBodyWithResponse), varargs...)
+}
+
+// DeleteIpAddressWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteIpAddressWithResponse(ctx context.Context, body core.DeleteIpAddressJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteIpAddressResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteIpAddressWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteIpAddressResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIpAddressWithResponse indicates an expected call of DeleteIpAddressWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteIpAddressWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpAddressWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteIpAddressWithResponse), varargs...)
+}
+
+// DeleteLoadBalancerWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteLoadBalancerWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteLoadBalancerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancerWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteLoadBalancerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancerWithBodyWithResponse indicates an expected call of DeleteLoadBalancerWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteLoadBalancerWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteLoadBalancerWithBodyWithResponse), varargs...)
+}
+
+// DeleteLoadBalancerWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteLoadBalancerWithResponse(ctx context.Context, body core.DeleteLoadBalancerJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteLoadBalancerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancerWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteLoadBalancerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancerWithResponse indicates an expected call of DeleteLoadBalancerWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteLoadBalancerWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteLoadBalancerWithResponse), varargs...)
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteLoadBalancersRulesLoadBalancerRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteLoadBalancersRulesLoadBalancerRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse indicates an expected call of DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse), varargs...)
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteLoadBalancersRulesLoadBalancerRuleWithResponse(ctx context.Context, body core.DeleteLoadBalancersRulesLoadBalancerRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteLoadBalancersRulesLoadBalancerRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteLoadBalancersRulesLoadBalancerRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteLoadBalancersRulesLoadBalancerRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteLoadBalancersRulesLoadBalancerRuleWithResponse indicates an expected call of DeleteLoadBalancersRulesLoadBalancerRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteLoadBalancersRulesLoadBalancerRuleWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancersRulesLoadBalancerRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteLoadBalancersRulesLoadBalancerRuleWithResponse), varargs...)
+}
+
+// DeleteSecurityGroupWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSecurityGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteSecurityGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSecurityGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupWithBodyWithResponse indicates an expected call of DeleteSecurityGroupWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSecurityGroupWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSecurityGroupWithBodyWithResponse), varargs...)
+}
+
+// DeleteSecurityGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSecurityGroupWithResponse(ctx context.Context, body core.DeleteSecurityGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteSecurityGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSecurityGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupWithResponse indicates an expected call of DeleteSecurityGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSecurityGroupWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSecurityGroupWithResponse), varargs...)
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteSecurityGroupsRulesSecurityGroupRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSecurityGroupsRulesSecurityGroupRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse indicates an expected call of DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse), varargs...)
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx context.Context, body core.DeleteSecurityGroupsRulesSecurityGroupRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteSecurityGroupsRulesSecurityGroupRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSecurityGroupsRulesSecurityGroupRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse indicates an expected call of DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSecurityGroupsRulesSecurityGroupRuleWithResponse), varargs...)
+}
+
+// DeleteSshKeyWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSshKeyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteSshKeyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSshKeyWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSshKeyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSshKeyWithBodyWithResponse indicates an expected call of DeleteSshKeyWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSshKeyWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSshKeyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSshKeyWithBodyWithResponse), varargs...)
+}
+
+// DeleteSshKeyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteSshKeyWithResponse(ctx context.Context, body core.DeleteSshKeyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteSshKeyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteSshKeyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteSshKeyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteSshKeyWithResponse indicates an expected call of DeleteSshKeyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSshKeyWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSshKeyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSshKeyWithResponse), varargs...)
+}
+
+// DeleteTagWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteTagWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteTagResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTagWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteTagResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTagWithBodyWithResponse indicates an expected call of DeleteTagWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTagWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTagWithBodyWithResponse), varargs...)
+}
+
+// DeleteTagWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteTagWithResponse(ctx context.Context, body core.DeleteTagJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteTagResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTagWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteTagResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTagWithResponse indicates an expected call of DeleteTagWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTagWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTagWithResponse), varargs...)
+}
+
+// DeleteTrashObjectWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteTrashObjectWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteTrashObjectResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTrashObjectWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteTrashObjectResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTrashObjectWithBodyWithResponse indicates an expected call of DeleteTrashObjectWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTrashObjectWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrashObjectWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTrashObjectWithBodyWithResponse), varargs...)
+}
+
+// DeleteTrashObjectWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteTrashObjectWithResponse(ctx context.Context, body core.DeleteTrashObjectJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteTrashObjectResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteTrashObjectWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteTrashObjectResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteTrashObjectWithResponse indicates an expected call of DeleteTrashObjectWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteTrashObjectWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrashObjectWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteTrashObjectWithResponse), varargs...)
+}
+
+// DeleteVirtualMachineGroupWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteVirtualMachineGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteVirtualMachineGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineGroupWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteVirtualMachineGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineGroupWithBodyWithResponse indicates an expected call of DeleteVirtualMachineGroupWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteVirtualMachineGroupWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineGroupWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteVirtualMachineGroupWithBodyWithResponse), varargs...)
+}
+
+// DeleteVirtualMachineGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteVirtualMachineGroupWithResponse(ctx context.Context, body core.DeleteVirtualMachineGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteVirtualMachineGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteVirtualMachineGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineGroupWithResponse indicates an expected call of DeleteVirtualMachineGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteVirtualMachineGroupWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteVirtualMachineGroupWithResponse), varargs...)
+}
+
+// DeleteVirtualMachineWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteVirtualMachineWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.DeleteVirtualMachineResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteVirtualMachineResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineWithBodyWithResponse indicates an expected call of DeleteVirtualMachineWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteVirtualMachineWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteVirtualMachineWithBodyWithResponse), varargs...)
+}
+
+// DeleteVirtualMachineWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) DeleteVirtualMachineWithResponse(ctx context.Context, body core.DeleteVirtualMachineJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.DeleteVirtualMachineResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteVirtualMachineWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.DeleteVirtualMachineResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteVirtualMachineWithResponse indicates an expected call of DeleteVirtualMachineWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteVirtualMachineWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVirtualMachineWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteVirtualMachineWithResponse), varargs...)
+}
+
+// GetAddressListEntriesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetAddressListEntriesWithResponse(ctx context.Context, params *core.GetAddressListEntriesParams, reqEditors ...core.RequestEditorFn) (*core.GetAddressListEntriesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListEntriesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetAddressListEntriesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListEntriesWithResponse indicates an expected call of GetAddressListEntriesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAddressListEntriesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListEntriesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAddressListEntriesWithResponse), varargs...)
+}
+
+// GetAddressListEntryWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetAddressListEntryWithResponse(ctx context.Context, params *core.GetAddressListEntryParams, reqEditors ...core.RequestEditorFn) (*core.GetAddressListEntryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListEntryWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetAddressListEntryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListEntryWithResponse indicates an expected call of GetAddressListEntryWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAddressListEntryWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListEntryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAddressListEntryWithResponse), varargs...)
+}
+
+// GetAddressListWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetAddressListWithResponse(ctx context.Context, params *core.GetAddressListParams, reqEditors ...core.RequestEditorFn) (*core.GetAddressListResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetAddressListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListWithResponse indicates an expected call of GetAddressListWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAddressListWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAddressListWithResponse), varargs...)
+}
+
+// GetAddressListsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetAddressListsWithResponse(ctx context.Context, params *core.GetAddressListsParams, reqEditors ...core.RequestEditorFn) (*core.GetAddressListsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetAddressListsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetAddressListsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAddressListsWithResponse indicates an expected call of GetAddressListsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAddressListsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddressListsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAddressListsWithResponse), varargs...)
+}
+
+// GetCertificateWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCertificateWithResponse(ctx context.Context, params *core.GetCertificateParams, reqEditors ...core.RequestEditorFn) (*core.GetCertificateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCertificateWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCertificateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCertificateWithResponse indicates an expected call of GetCertificateWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCertificateWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCertificateWithResponse), varargs...)
+}
+
+// GetCountriesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCountriesWithResponse(ctx context.Context, params *core.GetCountriesParams, reqEditors ...core.RequestEditorFn) (*core.GetCountriesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountriesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCountriesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountriesWithResponse indicates an expected call of GetCountriesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCountriesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountriesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCountriesWithResponse), varargs...)
+}
+
+// GetCountryCountryStatesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCountryCountryStatesWithResponse(ctx context.Context, params *core.GetCountryCountryStatesParams, reqEditors ...core.RequestEditorFn) (*core.GetCountryCountryStatesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountryCountryStatesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCountryCountryStatesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountryCountryStatesWithResponse indicates an expected call of GetCountryCountryStatesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCountryCountryStatesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountryCountryStatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCountryCountryStatesWithResponse), varargs...)
+}
+
+// GetCountryStateWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCountryStateWithResponse(ctx context.Context, params *core.GetCountryStateParams, reqEditors ...core.RequestEditorFn) (*core.GetCountryStateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountryStateWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCountryStateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountryStateWithResponse indicates an expected call of GetCountryStateWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCountryStateWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountryStateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCountryStateWithResponse), varargs...)
+}
+
+// GetCountryWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCountryWithResponse(ctx context.Context, params *core.GetCountryParams, reqEditors ...core.RequestEditorFn) (*core.GetCountryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCountryWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCountryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCountryWithResponse indicates an expected call of GetCountryWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCountryWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCountryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCountryWithResponse), varargs...)
+}
+
+// GetCurrenciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCurrenciesWithResponse(ctx context.Context, params *core.GetCurrenciesParams, reqEditors ...core.RequestEditorFn) (*core.GetCurrenciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCurrenciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCurrenciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrenciesWithResponse indicates an expected call of GetCurrenciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCurrenciesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrenciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCurrenciesWithResponse), varargs...)
+}
+
+// GetCurrencyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetCurrencyWithResponse(ctx context.Context, params *core.GetCurrencyParams, reqEditors ...core.RequestEditorFn) (*core.GetCurrencyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCurrencyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetCurrencyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrencyWithResponse indicates an expected call of GetCurrencyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCurrencyWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrencyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCurrencyWithResponse), varargs...)
+}
+
+// GetDataCenterDefaultNetworkWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDataCenterDefaultNetworkWithResponse(ctx context.Context, params *core.GetDataCenterDefaultNetworkParams, reqEditors ...core.RequestEditorFn) (*core.GetDataCenterDefaultNetworkResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenterDefaultNetworkWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDataCenterDefaultNetworkResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenterDefaultNetworkWithResponse indicates an expected call of GetDataCenterDefaultNetworkWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDataCenterDefaultNetworkWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenterDefaultNetworkWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDataCenterDefaultNetworkWithResponse), varargs...)
+}
+
+// GetDataCenterGpuTypesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDataCenterGpuTypesWithResponse(ctx context.Context, params *core.GetDataCenterGpuTypesParams, reqEditors ...core.RequestEditorFn) (*core.GetDataCenterGpuTypesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenterGpuTypesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDataCenterGpuTypesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenterGpuTypesWithResponse indicates an expected call of GetDataCenterGpuTypesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDataCenterGpuTypesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenterGpuTypesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDataCenterGpuTypesWithResponse), varargs...)
+}
+
+// GetDataCenterWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDataCenterWithResponse(ctx context.Context, params *core.GetDataCenterParams, reqEditors ...core.RequestEditorFn) (*core.GetDataCenterResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenterWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDataCenterResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenterWithResponse indicates an expected call of GetDataCenterWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDataCenterWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenterWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDataCenterWithResponse), varargs...)
+}
+
+// GetDataCentersWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDataCentersWithResponse(ctx context.Context, reqEditors ...core.RequestEditorFn) (*core.GetDataCentersResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCentersWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDataCentersResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCentersWithResponse indicates an expected call of GetDataCentersWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDataCentersWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCentersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDataCentersWithResponse), varargs...)
+}
+
+// GetDiskBackupPolicyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskBackupPolicyWithResponse(ctx context.Context, params *core.GetDiskBackupPolicyParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskBackupPolicyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskBackupPolicyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskBackupPolicyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskBackupPolicyWithResponse indicates an expected call of GetDiskBackupPolicyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskBackupPolicyWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskBackupPolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskBackupPolicyWithResponse), varargs...)
+}
+
+// GetDiskDiskBackupPoliciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskDiskBackupPoliciesWithResponse(ctx context.Context, params *core.GetDiskDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskDiskBackupPoliciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskDiskBackupPoliciesWithResponse indicates an expected call of GetDiskDiskBackupPoliciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskDiskBackupPoliciesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskDiskBackupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskDiskBackupPoliciesWithResponse), varargs...)
+}
+
+// GetDiskTemplateVersionSpecWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskTemplateVersionSpecWithResponse(ctx context.Context, params *core.GetDiskTemplateVersionSpecParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskTemplateVersionSpecResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersionSpecWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskTemplateVersionSpecResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersionSpecWithResponse indicates an expected call of GetDiskTemplateVersionSpecWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskTemplateVersionSpecWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersionSpecWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskTemplateVersionSpecWithResponse), varargs...)
+}
+
+// GetDiskTemplateVersionWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskTemplateVersionWithResponse(ctx context.Context, params *core.GetDiskTemplateVersionParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskTemplateVersionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersionWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskTemplateVersionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersionWithResponse indicates an expected call of GetDiskTemplateVersionWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskTemplateVersionWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskTemplateVersionWithResponse), varargs...)
+}
+
+// GetDiskTemplateVersionsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskTemplateVersionsWithResponse(ctx context.Context, params *core.GetDiskTemplateVersionsParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskTemplateVersionsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateVersionsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskTemplateVersionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateVersionsWithResponse indicates an expected call of GetDiskTemplateVersionsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskTemplateVersionsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateVersionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskTemplateVersionsWithResponse), varargs...)
+}
+
+// GetDiskTemplateWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskTemplateWithResponse(ctx context.Context, params *core.GetDiskTemplateParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskTemplateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskTemplateWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskTemplateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskTemplateWithResponse indicates an expected call of GetDiskTemplateWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskTemplateWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskTemplateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskTemplateWithResponse), varargs...)
+}
+
+// GetDiskWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDiskWithResponse(ctx context.Context, params *core.GetDiskParams, reqEditors ...core.RequestEditorFn) (*core.GetDiskResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDiskWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDiskResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDiskWithResponse indicates an expected call of GetDiskWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDiskWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDiskWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDiskWithResponse), varargs...)
+}
+
+// GetDnsRecordWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDnsRecordWithResponse(ctx context.Context, params *core.GetDnsRecordParams, reqEditors ...core.RequestEditorFn) (*core.GetDnsRecordResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsRecordWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDnsRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsRecordWithResponse indicates an expected call of GetDnsRecordWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDnsRecordWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsRecordWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDnsRecordWithResponse), varargs...)
+}
+
+// GetDnsZoneRecordsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDnsZoneRecordsWithResponse(ctx context.Context, params *core.GetDnsZoneRecordsParams, reqEditors ...core.RequestEditorFn) (*core.GetDnsZoneRecordsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsZoneRecordsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDnsZoneRecordsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsZoneRecordsWithResponse indicates an expected call of GetDnsZoneRecordsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDnsZoneRecordsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsZoneRecordsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDnsZoneRecordsWithResponse), varargs...)
+}
+
+// GetDnsZoneWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDnsZoneWithResponse(ctx context.Context, params *core.GetDnsZoneParams, reqEditors ...core.RequestEditorFn) (*core.GetDnsZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDnsZoneWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetDnsZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDnsZoneWithResponse indicates an expected call of GetDnsZoneWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDnsZoneWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDnsZoneWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDnsZoneWithResponse), varargs...)
+}
+
+// GetFileStorageVolumeWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetFileStorageVolumeWithResponse(ctx context.Context, params *core.GetFileStorageVolumeParams, reqEditors ...core.RequestEditorFn) (*core.GetFileStorageVolumeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetFileStorageVolumeWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetFileStorageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFileStorageVolumeWithResponse indicates an expected call of GetFileStorageVolumeWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetFileStorageVolumeWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileStorageVolumeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetFileStorageVolumeWithResponse), varargs...)
+}
+
+// GetGpuTypeWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetGpuTypeWithResponse(ctx context.Context, params *core.GetGpuTypeParams, reqEditors ...core.RequestEditorFn) (*core.GetGpuTypeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGpuTypeWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetGpuTypeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGpuTypeWithResponse indicates an expected call of GetGpuTypeWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetGpuTypeWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuTypeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetGpuTypeWithResponse), varargs...)
+}
+
+// GetGpuTypesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetGpuTypesWithResponse(ctx context.Context, params *core.GetGpuTypesParams, reqEditors ...core.RequestEditorFn) (*core.GetGpuTypesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGpuTypesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetGpuTypesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGpuTypesWithResponse indicates an expected call of GetGpuTypesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetGpuTypesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGpuTypesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetGpuTypesWithResponse), varargs...)
+}
+
+// GetIpAddressWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetIpAddressWithResponse(ctx context.Context, params *core.GetIpAddressParams, reqEditors ...core.RequestEditorFn) (*core.GetIpAddressResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetIpAddressWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetIpAddressResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIpAddressWithResponse indicates an expected call of GetIpAddressWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetIpAddressWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpAddressWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetIpAddressWithResponse), varargs...)
+}
+
+// GetLoadBalancerRulesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetLoadBalancerRulesWithResponse(ctx context.Context, params *core.GetLoadBalancerRulesParams, reqEditors ...core.RequestEditorFn) (*core.GetLoadBalancerRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancerRulesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetLoadBalancerRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancerRulesWithResponse indicates an expected call of GetLoadBalancerRulesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLoadBalancerRulesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLoadBalancerRulesWithResponse), varargs...)
+}
+
+// GetLoadBalancerWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetLoadBalancerWithResponse(ctx context.Context, params *core.GetLoadBalancerParams, reqEditors ...core.RequestEditorFn) (*core.GetLoadBalancerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancerWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetLoadBalancerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancerWithResponse indicates an expected call of GetLoadBalancerWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLoadBalancerWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLoadBalancerWithResponse), varargs...)
+}
+
+// GetLoadBalancersRulesLoadBalancerRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetLoadBalancersRulesLoadBalancerRuleWithResponse(ctx context.Context, params *core.GetLoadBalancersRulesLoadBalancerRuleParams, reqEditors ...core.RequestEditorFn) (*core.GetLoadBalancersRulesLoadBalancerRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLoadBalancersRulesLoadBalancerRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetLoadBalancersRulesLoadBalancerRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLoadBalancersRulesLoadBalancerRuleWithResponse indicates an expected call of GetLoadBalancersRulesLoadBalancerRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLoadBalancersRulesLoadBalancerRuleWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancersRulesLoadBalancerRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLoadBalancersRulesLoadBalancerRuleWithResponse), varargs...)
+}
+
+// GetNetworkWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetNetworkWithResponse(ctx context.Context, params *core.GetNetworkParams, reqEditors ...core.RequestEditorFn) (*core.GetNetworkResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetNetworkWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetNetworkResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetNetworkWithResponse indicates an expected call of GetNetworkWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNetworkWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNetworkWithResponse), varargs...)
+}
+
+// GetOperatingSystemWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOperatingSystemWithResponse(ctx context.Context, params *core.GetOperatingSystemParams, reqEditors ...core.RequestEditorFn) (*core.GetOperatingSystemResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOperatingSystemWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOperatingSystemResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOperatingSystemWithResponse indicates an expected call of GetOperatingSystemWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOperatingSystemWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatingSystemWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOperatingSystemWithResponse), varargs...)
+}
+
+// GetOperatingSystemsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOperatingSystemsWithResponse(ctx context.Context, params *core.GetOperatingSystemsParams, reqEditors ...core.RequestEditorFn) (*core.GetOperatingSystemsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOperatingSystemsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOperatingSystemsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOperatingSystemsWithResponse indicates an expected call of GetOperatingSystemsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOperatingSystemsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatingSystemsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOperatingSystemsWithResponse), varargs...)
+}
+
+// GetOrganizationAddressListsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationAddressListsWithResponse(ctx context.Context, params *core.GetOrganizationAddressListsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationAddressListsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationAddressListsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationAddressListsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationAddressListsWithResponse indicates an expected call of GetOrganizationAddressListsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationAddressListsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationAddressListsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationAddressListsWithResponse), varargs...)
+}
+
+// GetOrganizationAvailableNetworksWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationAvailableNetworksWithResponse(ctx context.Context, params *core.GetOrganizationAvailableNetworksParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationAvailableNetworksResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationAvailableNetworksWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationAvailableNetworksResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationAvailableNetworksWithResponse indicates an expected call of GetOrganizationAvailableNetworksWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationAvailableNetworksWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationAvailableNetworksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationAvailableNetworksWithResponse), varargs...)
+}
+
+// GetOrganizationCertificatesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationCertificatesWithResponse(ctx context.Context, params *core.GetOrganizationCertificatesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationCertificatesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationCertificatesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationCertificatesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationCertificatesWithResponse indicates an expected call of GetOrganizationCertificatesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationCertificatesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationCertificatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationCertificatesWithResponse), varargs...)
+}
+
+// GetOrganizationDiskBackupPoliciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationDiskBackupPoliciesWithResponse(ctx context.Context, params *core.GetOrganizationDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDiskBackupPoliciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDiskBackupPoliciesWithResponse indicates an expected call of GetOrganizationDiskBackupPoliciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationDiskBackupPoliciesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDiskBackupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationDiskBackupPoliciesWithResponse), varargs...)
+}
+
+// GetOrganizationDiskTemplatesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationDiskTemplatesWithResponse(ctx context.Context, params *core.GetOrganizationDiskTemplatesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationDiskTemplatesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDiskTemplatesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationDiskTemplatesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDiskTemplatesWithResponse indicates an expected call of GetOrganizationDiskTemplatesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationDiskTemplatesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDiskTemplatesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationDiskTemplatesWithResponse), varargs...)
+}
+
+// GetOrganizationDisksWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationDisksWithResponse(ctx context.Context, params *core.GetOrganizationDisksParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationDisksResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDisksWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationDisksResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDisksWithResponse indicates an expected call of GetOrganizationDisksWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationDisksWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDisksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationDisksWithResponse), varargs...)
+}
+
+// GetOrganizationDnsZonesNameserversWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationDnsZonesNameserversWithResponse(ctx context.Context, params *core.GetOrganizationDnsZonesNameserversParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationDnsZonesNameserversResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDnsZonesNameserversWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationDnsZonesNameserversResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDnsZonesNameserversWithResponse indicates an expected call of GetOrganizationDnsZonesNameserversWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationDnsZonesNameserversWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDnsZonesNameserversWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationDnsZonesNameserversWithResponse), varargs...)
+}
+
+// GetOrganizationDnsZonesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationDnsZonesWithResponse(ctx context.Context, params *core.GetOrganizationDnsZonesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationDnsZonesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationDnsZonesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationDnsZonesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationDnsZonesWithResponse indicates an expected call of GetOrganizationDnsZonesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationDnsZonesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationDnsZonesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationDnsZonesWithResponse), varargs...)
+}
+
+// GetOrganizationFileStorageVolumesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationFileStorageVolumesWithResponse(ctx context.Context, params *core.GetOrganizationFileStorageVolumesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationFileStorageVolumesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationFileStorageVolumesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationFileStorageVolumesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationFileStorageVolumesWithResponse indicates an expected call of GetOrganizationFileStorageVolumesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationFileStorageVolumesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationFileStorageVolumesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationFileStorageVolumesWithResponse), varargs...)
+}
+
+// GetOrganizationIpAddressesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationIpAddressesWithResponse(ctx context.Context, params *core.GetOrganizationIpAddressesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationIpAddressesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationIpAddressesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationIpAddressesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationIpAddressesWithResponse indicates an expected call of GetOrganizationIpAddressesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationIpAddressesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationIpAddressesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationIpAddressesWithResponse), varargs...)
+}
+
+// GetOrganizationLoadBalancersWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationLoadBalancersWithResponse(ctx context.Context, params *core.GetOrganizationLoadBalancersParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationLoadBalancersResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationLoadBalancersWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationLoadBalancersResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationLoadBalancersWithResponse indicates an expected call of GetOrganizationLoadBalancersWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationLoadBalancersWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationLoadBalancersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationLoadBalancersWithResponse), varargs...)
+}
+
+// GetOrganizationManagedWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationManagedWithResponse(ctx context.Context, params *core.GetOrganizationManagedParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationManagedResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationManagedWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationManagedResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationManagedWithResponse indicates an expected call of GetOrganizationManagedWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationManagedWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationManagedWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationManagedWithResponse), varargs...)
+}
+
+// GetOrganizationNetworkSpeedProfilesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationNetworkSpeedProfilesWithResponse(ctx context.Context, params *core.GetOrganizationNetworkSpeedProfilesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationNetworkSpeedProfilesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationNetworkSpeedProfilesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationNetworkSpeedProfilesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationNetworkSpeedProfilesWithResponse indicates an expected call of GetOrganizationNetworkSpeedProfilesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationNetworkSpeedProfilesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationNetworkSpeedProfilesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationNetworkSpeedProfilesWithResponse), varargs...)
+}
+
+// GetOrganizationPolicyLimitsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationPolicyLimitsWithResponse(ctx context.Context, params *core.GetOrganizationPolicyLimitsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationPolicyLimitsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationPolicyLimitsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationPolicyLimitsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationPolicyLimitsWithResponse indicates an expected call of GetOrganizationPolicyLimitsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationPolicyLimitsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationPolicyLimitsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationPolicyLimitsWithResponse), varargs...)
+}
+
+// GetOrganizationSecurityGroupsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationSecurityGroupsWithResponse(ctx context.Context, params *core.GetOrganizationSecurityGroupsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationSecurityGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationSecurityGroupsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationSecurityGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationSecurityGroupsWithResponse indicates an expected call of GetOrganizationSecurityGroupsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationSecurityGroupsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationSecurityGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationSecurityGroupsWithResponse), varargs...)
+}
+
+// GetOrganizationSshKeysWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationSshKeysWithResponse(ctx context.Context, params *core.GetOrganizationSshKeysParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationSshKeysResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationSshKeysWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationSshKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationSshKeysWithResponse indicates an expected call of GetOrganizationSshKeysWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationSshKeysWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationSshKeysWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationSshKeysWithResponse), varargs...)
+}
+
+// GetOrganizationTagsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationTagsWithResponse(ctx context.Context, params *core.GetOrganizationTagsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationTagsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationTagsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationTagsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationTagsWithResponse indicates an expected call of GetOrganizationTagsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationTagsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationTagsWithResponse), varargs...)
+}
+
+// GetOrganizationTrashObjectsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationTrashObjectsWithResponse(ctx context.Context, params *core.GetOrganizationTrashObjectsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationTrashObjectsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationTrashObjectsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationTrashObjectsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationTrashObjectsWithResponse indicates an expected call of GetOrganizationTrashObjectsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationTrashObjectsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationTrashObjectsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationTrashObjectsWithResponse), varargs...)
+}
+
+// GetOrganizationUsersWithAccessWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationUsersWithAccessWithResponse(ctx context.Context, params *core.GetOrganizationUsersWithAccessParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationUsersWithAccessResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationUsersWithAccessWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationUsersWithAccessResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationUsersWithAccessWithResponse indicates an expected call of GetOrganizationUsersWithAccessWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationUsersWithAccessWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationUsersWithAccessWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationUsersWithAccessWithResponse), varargs...)
+}
+
+// GetOrganizationVirtualMachineGroupsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationVirtualMachineGroupsWithResponse(ctx context.Context, params *core.GetOrganizationVirtualMachineGroupsParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationVirtualMachineGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationVirtualMachineGroupsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationVirtualMachineGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationVirtualMachineGroupsWithResponse indicates an expected call of GetOrganizationVirtualMachineGroupsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationVirtualMachineGroupsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationVirtualMachineGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationVirtualMachineGroupsWithResponse), varargs...)
+}
+
+// GetOrganizationVirtualMachinesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationVirtualMachinesWithResponse(ctx context.Context, params *core.GetOrganizationVirtualMachinesParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationVirtualMachinesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationVirtualMachinesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationVirtualMachinesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationVirtualMachinesWithResponse indicates an expected call of GetOrganizationVirtualMachinesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationVirtualMachinesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationVirtualMachinesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationVirtualMachinesWithResponse), varargs...)
+}
+
+// GetOrganizationWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationWithResponse(ctx context.Context, params *core.GetOrganizationParams, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationWithResponse indicates an expected call of GetOrganizationWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationWithResponse), varargs...)
+}
+
+// GetOrganizationsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetOrganizationsWithResponse(ctx context.Context, reqEditors ...core.RequestEditorFn) (*core.GetOrganizationsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetOrganizationsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetOrganizationsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOrganizationsWithResponse indicates an expected call of GetOrganizationsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOrganizationsWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOrganizationsWithResponse), varargs...)
+}
+
+// GetSecurityGroupRulesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetSecurityGroupRulesWithResponse(ctx context.Context, params *core.GetSecurityGroupRulesParams, reqEditors ...core.RequestEditorFn) (*core.GetSecurityGroupRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroupRulesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetSecurityGroupRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroupRulesWithResponse indicates an expected call of GetSecurityGroupRulesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetSecurityGroupRulesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetSecurityGroupRulesWithResponse), varargs...)
+}
+
+// GetSecurityGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetSecurityGroupWithResponse(ctx context.Context, params *core.GetSecurityGroupParams, reqEditors ...core.RequestEditorFn) (*core.GetSecurityGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetSecurityGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroupWithResponse indicates an expected call of GetSecurityGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetSecurityGroupWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetSecurityGroupWithResponse), varargs...)
+}
+
+// GetSecurityGroupsRulesSecurityGroupRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx context.Context, params *core.GetSecurityGroupsRulesSecurityGroupRuleParams, reqEditors ...core.RequestEditorFn) (*core.GetSecurityGroupsRulesSecurityGroupRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSecurityGroupsRulesSecurityGroupRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetSecurityGroupsRulesSecurityGroupRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSecurityGroupsRulesSecurityGroupRuleWithResponse indicates an expected call of GetSecurityGroupsRulesSecurityGroupRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsRulesSecurityGroupRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetSecurityGroupsRulesSecurityGroupRuleWithResponse), varargs...)
+}
+
+// GetTagWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetTagWithResponse(ctx context.Context, params *core.GetTagParams, reqEditors ...core.RequestEditorFn) (*core.GetTagResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTagWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetTagResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTagWithResponse indicates an expected call of GetTagWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTagWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTagWithResponse), varargs...)
+}
+
+// GetTaskWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetTaskWithResponse(ctx context.Context, params *core.GetTaskParams, reqEditors ...core.RequestEditorFn) (*core.GetTaskResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTaskWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetTaskResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTaskWithResponse indicates an expected call of GetTaskWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTaskWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTaskWithResponse), varargs...)
+}
+
+// GetTrashObjectWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetTrashObjectWithResponse(ctx context.Context, params *core.GetTrashObjectParams, reqEditors ...core.RequestEditorFn) (*core.GetTrashObjectResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetTrashObjectWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetTrashObjectResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTrashObjectWithResponse indicates an expected call of GetTrashObjectWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetTrashObjectWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrashObjectWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetTrashObjectWithResponse), varargs...)
+}
+
+// GetUsersCurrentWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetUsersCurrentWithResponse(ctx context.Context, reqEditors ...core.RequestEditorFn) (*core.GetUsersCurrentResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUsersCurrentWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetUsersCurrentResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUsersCurrentWithResponse indicates an expected call of GetUsersCurrentWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetUsersCurrentWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersCurrentWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetUsersCurrentWithResponse), varargs...)
+}
+
+// GetVMNIVMNIWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVMNIVMNIWithResponse(ctx context.Context, params *core.GetVMNIVMNIParams, reqEditors ...core.RequestEditorFn) (*core.GetVMNIVMNIResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVMNIVMNIWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVMNIVMNIResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVMNIVMNIWithResponse indicates an expected call of GetVMNIVMNIWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVMNIVMNIWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVMNIVMNIWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVMNIVMNIWithResponse), varargs...)
+}
+
+// GetVirtualMachineAuthorizedKeysWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineAuthorizedKeysWithResponse(ctx context.Context, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineAuthorizedKeysResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineAuthorizedKeysWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineAuthorizedKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineAuthorizedKeysWithResponse indicates an expected call of GetVirtualMachineAuthorizedKeysWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineAuthorizedKeysWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineAuthorizedKeysWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineAuthorizedKeysWithResponse), varargs...)
+}
+
+// GetVirtualMachineDiskBackupPoliciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineDiskBackupPoliciesWithResponse(ctx context.Context, params *core.GetVirtualMachineDiskBackupPoliciesParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineDiskBackupPoliciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineDiskBackupPoliciesWithResponse indicates an expected call of GetVirtualMachineDiskBackupPoliciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineDiskBackupPoliciesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineDiskBackupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineDiskBackupPoliciesWithResponse), varargs...)
+}
+
+// GetVirtualMachineDisksWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineDisksWithResponse(ctx context.Context, params *core.GetVirtualMachineDisksParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineDisksResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineDisksWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineDisksResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineDisksWithResponse indicates an expected call of GetVirtualMachineDisksWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineDisksWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineDisksWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineDisksWithResponse), varargs...)
+}
+
+// GetVirtualMachineGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineGroupWithResponse(ctx context.Context, params *core.GetVirtualMachineGroupParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineGroupWithResponse indicates an expected call of GetVirtualMachineGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineGroupWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineGroupWithResponse), varargs...)
+}
+
+// GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse(ctx context.Context, params *core.GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse indicates an expected call of GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineNetworkInterfaceAvailableIpsAddressVersionWithResponse), varargs...)
+}
+
+// GetVirtualMachineNetworkInterfaceWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineNetworkInterfaceWithResponse(ctx context.Context, params *core.GetVirtualMachineNetworkInterfaceParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineNetworkInterfaceResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterfaceWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineNetworkInterfaceResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterfaceWithResponse indicates an expected call of GetVirtualMachineNetworkInterfaceWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineNetworkInterfaceWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterfaceWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineNetworkInterfaceWithResponse), varargs...)
+}
+
+// GetVirtualMachineNetworkInterfacesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineNetworkInterfacesWithResponse(ctx context.Context, params *core.GetVirtualMachineNetworkInterfacesParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineNetworkInterfacesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineNetworkInterfacesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineNetworkInterfacesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineNetworkInterfacesWithResponse indicates an expected call of GetVirtualMachineNetworkInterfacesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineNetworkInterfacesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineNetworkInterfacesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineNetworkInterfacesWithResponse), varargs...)
+}
+
+// GetVirtualMachinePackageWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachinePackageWithResponse(ctx context.Context, params *core.GetVirtualMachinePackageParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachinePackageResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackageWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachinePackageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackageWithResponse indicates an expected call of GetVirtualMachinePackageWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachinePackageWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackageWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachinePackageWithResponse), varargs...)
+}
+
+// GetVirtualMachinePackagesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachinePackagesWithResponse(ctx context.Context, params *core.GetVirtualMachinePackagesParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachinePackagesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackagesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachinePackagesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackagesWithResponse indicates an expected call of GetVirtualMachinePackagesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachinePackagesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachinePackagesWithResponse), varargs...)
+}
+
+// GetVirtualMachineWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachineWithResponse(ctx context.Context, params *core.GetVirtualMachineParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachineResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachineWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachineResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachineWithResponse indicates an expected call of GetVirtualMachineWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachineWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachineWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachineWithResponse), varargs...)
+}
+
+// GetVirtualMachinesBuildsVirtualMachineBuildWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachinesBuildsVirtualMachineBuildWithResponse(ctx context.Context, params *core.GetVirtualMachinesBuildsVirtualMachineBuildParams, reqEditors ...core.RequestEditorFn) (*core.GetVirtualMachinesBuildsVirtualMachineBuildResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinesBuildsVirtualMachineBuildWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetVirtualMachinesBuildsVirtualMachineBuildResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinesBuildsVirtualMachineBuildWithResponse indicates an expected call of GetVirtualMachinesBuildsVirtualMachineBuildWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachinesBuildsVirtualMachineBuildWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinesBuildsVirtualMachineBuildWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachinesBuildsVirtualMachineBuildWithResponse), varargs...)
+}
+
+// GetZoneWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetZoneWithResponse(ctx context.Context, params *core.GetZoneParams, reqEditors ...core.RequestEditorFn) (*core.GetZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetZoneWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetZoneWithResponse indicates an expected call of GetZoneWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetZoneWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZoneWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetZoneWithResponse), varargs...)
+}
+
+// GetZonesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetZonesWithResponse(ctx context.Context, reqEditors ...core.RequestEditorFn) (*core.GetZonesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetZonesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.GetZonesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetZonesWithResponse indicates an expected call of GetZonesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetZonesWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetZonesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetZonesWithResponse), varargs...)
+}
+
+// PatchAddressListEntryWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchAddressListEntryWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchAddressListEntryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListEntryWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchAddressListEntryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListEntryWithBodyWithResponse indicates an expected call of PatchAddressListEntryWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAddressListEntryWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListEntryWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAddressListEntryWithBodyWithResponse), varargs...)
+}
+
+// PatchAddressListEntryWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchAddressListEntryWithResponse(ctx context.Context, body core.PatchAddressListEntryJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchAddressListEntryResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListEntryWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchAddressListEntryResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListEntryWithResponse indicates an expected call of PatchAddressListEntryWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAddressListEntryWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListEntryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAddressListEntryWithResponse), varargs...)
+}
+
+// PatchAddressListWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchAddressListWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchAddressListResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchAddressListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListWithBodyWithResponse indicates an expected call of PatchAddressListWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAddressListWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAddressListWithBodyWithResponse), varargs...)
+}
+
+// PatchAddressListWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchAddressListWithResponse(ctx context.Context, body core.PatchAddressListJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchAddressListResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchAddressListWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchAddressListResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchAddressListWithResponse indicates an expected call of PatchAddressListWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchAddressListWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchAddressListWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchAddressListWithResponse), varargs...)
+}
+
+// PatchDiskBackupPolicyWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDiskBackupPolicyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchDiskBackupPolicyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDiskBackupPolicyWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDiskBackupPolicyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDiskBackupPolicyWithBodyWithResponse indicates an expected call of PatchDiskBackupPolicyWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDiskBackupPolicyWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDiskBackupPolicyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDiskBackupPolicyWithBodyWithResponse), varargs...)
+}
+
+// PatchDiskBackupPolicyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDiskBackupPolicyWithResponse(ctx context.Context, body core.PatchDiskBackupPolicyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchDiskBackupPolicyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDiskBackupPolicyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDiskBackupPolicyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDiskBackupPolicyWithResponse indicates an expected call of PatchDiskBackupPolicyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDiskBackupPolicyWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDiskBackupPolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDiskBackupPolicyWithResponse), varargs...)
+}
+
+// PatchDnsRecordWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDnsRecordWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchDnsRecordResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsRecordWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDnsRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsRecordWithBodyWithResponse indicates an expected call of PatchDnsRecordWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDnsRecordWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsRecordWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDnsRecordWithBodyWithResponse), varargs...)
+}
+
+// PatchDnsRecordWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDnsRecordWithResponse(ctx context.Context, body core.PatchDnsRecordJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchDnsRecordResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsRecordWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDnsRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsRecordWithResponse indicates an expected call of PatchDnsRecordWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDnsRecordWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsRecordWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDnsRecordWithResponse), varargs...)
+}
+
+// PatchDnsZoneWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDnsZoneWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchDnsZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsZoneWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDnsZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsZoneWithBodyWithResponse indicates an expected call of PatchDnsZoneWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDnsZoneWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsZoneWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDnsZoneWithBodyWithResponse), varargs...)
+}
+
+// PatchDnsZoneWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchDnsZoneWithResponse(ctx context.Context, body core.PatchDnsZoneJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchDnsZoneResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchDnsZoneWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchDnsZoneResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchDnsZoneWithResponse indicates an expected call of PatchDnsZoneWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchDnsZoneWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDnsZoneWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchDnsZoneWithResponse), varargs...)
+}
+
+// PatchFileStorageVolumeWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchFileStorageVolumeWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchFileStorageVolumeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchFileStorageVolumeWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchFileStorageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchFileStorageVolumeWithBodyWithResponse indicates an expected call of PatchFileStorageVolumeWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchFileStorageVolumeWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFileStorageVolumeWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchFileStorageVolumeWithBodyWithResponse), varargs...)
+}
+
+// PatchFileStorageVolumeWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchFileStorageVolumeWithResponse(ctx context.Context, body core.PatchFileStorageVolumeJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchFileStorageVolumeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchFileStorageVolumeWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchFileStorageVolumeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchFileStorageVolumeWithResponse indicates an expected call of PatchFileStorageVolumeWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchFileStorageVolumeWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFileStorageVolumeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchFileStorageVolumeWithResponse), varargs...)
+}
+
+// PatchIpAddressWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchIpAddressWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchIpAddressResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchIpAddressWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchIpAddressResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchIpAddressWithBodyWithResponse indicates an expected call of PatchIpAddressWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchIpAddressWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchIpAddressWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchIpAddressWithBodyWithResponse), varargs...)
+}
+
+// PatchIpAddressWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchIpAddressWithResponse(ctx context.Context, body core.PatchIpAddressJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchIpAddressResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchIpAddressWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchIpAddressResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchIpAddressWithResponse indicates an expected call of PatchIpAddressWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchIpAddressWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchIpAddressWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchIpAddressWithResponse), varargs...)
+}
+
+// PatchLoadBalancerWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchLoadBalancerWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchLoadBalancerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancerWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchLoadBalancerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancerWithBodyWithResponse indicates an expected call of PatchLoadBalancerWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLoadBalancerWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancerWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLoadBalancerWithBodyWithResponse), varargs...)
+}
+
+// PatchLoadBalancerWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchLoadBalancerWithResponse(ctx context.Context, body core.PatchLoadBalancerJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchLoadBalancerResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancerWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchLoadBalancerResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancerWithResponse indicates an expected call of PatchLoadBalancerWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLoadBalancerWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancerWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLoadBalancerWithResponse), varargs...)
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchLoadBalancersRulesLoadBalancerRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchLoadBalancersRulesLoadBalancerRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse indicates an expected call of PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLoadBalancersRulesLoadBalancerRuleWithBodyWithResponse), varargs...)
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchLoadBalancersRulesLoadBalancerRuleWithResponse(ctx context.Context, body core.PatchLoadBalancersRulesLoadBalancerRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchLoadBalancersRulesLoadBalancerRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchLoadBalancersRulesLoadBalancerRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchLoadBalancersRulesLoadBalancerRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchLoadBalancersRulesLoadBalancerRuleWithResponse indicates an expected call of PatchLoadBalancersRulesLoadBalancerRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchLoadBalancersRulesLoadBalancerRuleWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchLoadBalancersRulesLoadBalancerRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchLoadBalancersRulesLoadBalancerRuleWithResponse), varargs...)
+}
+
+// PatchSecurityGroupWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchSecurityGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchSecurityGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchSecurityGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupWithBodyWithResponse indicates an expected call of PatchSecurityGroupWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchSecurityGroupWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchSecurityGroupWithBodyWithResponse), varargs...)
+}
+
+// PatchSecurityGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchSecurityGroupWithResponse(ctx context.Context, body core.PatchSecurityGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchSecurityGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchSecurityGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupWithResponse indicates an expected call of PatchSecurityGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchSecurityGroupWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchSecurityGroupWithResponse), varargs...)
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchSecurityGroupsRulesSecurityGroupRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchSecurityGroupsRulesSecurityGroupRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse indicates an expected call of PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchSecurityGroupsRulesSecurityGroupRuleWithBodyWithResponse), varargs...)
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx context.Context, body core.PatchSecurityGroupsRulesSecurityGroupRuleJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchSecurityGroupsRulesSecurityGroupRuleResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchSecurityGroupsRulesSecurityGroupRuleWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchSecurityGroupsRulesSecurityGroupRuleResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchSecurityGroupsRulesSecurityGroupRuleWithResponse indicates an expected call of PatchSecurityGroupsRulesSecurityGroupRuleWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchSecurityGroupsRulesSecurityGroupRuleWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchSecurityGroupsRulesSecurityGroupRuleWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchSecurityGroupsRulesSecurityGroupRuleWithResponse), varargs...)
+}
+
+// PatchTagWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchTagWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchTagResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchTagWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchTagResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchTagWithBodyWithResponse indicates an expected call of PatchTagWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTagWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTagWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTagWithBodyWithResponse), varargs...)
+}
+
+// PatchTagWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchTagWithResponse(ctx context.Context, body core.PatchTagJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchTagResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchTagWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchTagResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchTagWithResponse indicates an expected call of PatchTagWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchTagWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchTagWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchTagWithResponse), varargs...)
+}
+
+// PatchVirtualMachineGroupWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineGroupWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineGroupWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineGroupWithBodyWithResponse indicates an expected call of PatchVirtualMachineGroupWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineGroupWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineGroupWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineGroupWithBodyWithResponse), varargs...)
+}
+
+// PatchVirtualMachineGroupWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineGroupWithResponse(ctx context.Context, body core.PatchVirtualMachineGroupJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineGroupResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineGroupWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineGroupResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineGroupWithResponse indicates an expected call of PatchVirtualMachineGroupWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineGroupWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineGroupWithResponse), varargs...)
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse indicates an expected call of PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithBodyWithResponse), varargs...)
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse(ctx context.Context, body core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse indicates an expected call of PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineNetworkInterfaceUpdateSpeedProfileWithResponse), varargs...)
+}
+
+// PatchVirtualMachineWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineWithBodyWithResponse indicates an expected call of PatchVirtualMachineWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineWithBodyWithResponse), varargs...)
+}
+
+// PatchVirtualMachineWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PatchVirtualMachineWithResponse(ctx context.Context, body core.PatchVirtualMachineJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PatchVirtualMachineResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PatchVirtualMachineWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PatchVirtualMachineResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PatchVirtualMachineWithResponse indicates an expected call of PatchVirtualMachineWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PatchVirtualMachineWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchVirtualMachineWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PatchVirtualMachineWithResponse), varargs...)
+}
+
+// PostAddressListEntriesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostAddressListEntriesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostAddressListEntriesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostAddressListEntriesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostAddressListEntriesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostAddressListEntriesWithBodyWithResponse indicates an expected call of PostAddressListEntriesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAddressListEntriesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAddressListEntriesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAddressListEntriesWithBodyWithResponse), varargs...)
+}
+
+// PostAddressListEntriesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostAddressListEntriesWithResponse(ctx context.Context, body core.PostAddressListEntriesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostAddressListEntriesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostAddressListEntriesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostAddressListEntriesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostAddressListEntriesWithResponse indicates an expected call of PostAddressListEntriesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostAddressListEntriesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostAddressListEntriesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostAddressListEntriesWithResponse), varargs...)
+}
+
+// PostDiskDiskBackupPoliciesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDiskDiskBackupPoliciesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostDiskDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDiskDiskBackupPoliciesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDiskDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDiskDiskBackupPoliciesWithBodyWithResponse indicates an expected call of PostDiskDiskBackupPoliciesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDiskDiskBackupPoliciesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDiskDiskBackupPoliciesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDiskDiskBackupPoliciesWithBodyWithResponse), varargs...)
+}
+
+// PostDiskDiskBackupPoliciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDiskDiskBackupPoliciesWithResponse(ctx context.Context, body core.PostDiskDiskBackupPoliciesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostDiskDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDiskDiskBackupPoliciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDiskDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDiskDiskBackupPoliciesWithResponse indicates an expected call of PostDiskDiskBackupPoliciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDiskDiskBackupPoliciesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDiskDiskBackupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDiskDiskBackupPoliciesWithResponse), varargs...)
+}
+
+// PostDnsZoneRecordsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDnsZoneRecordsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostDnsZoneRecordsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneRecordsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDnsZoneRecordsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneRecordsWithBodyWithResponse indicates an expected call of PostDnsZoneRecordsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDnsZoneRecordsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneRecordsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDnsZoneRecordsWithBodyWithResponse), varargs...)
+}
+
+// PostDnsZoneRecordsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDnsZoneRecordsWithResponse(ctx context.Context, body core.PostDnsZoneRecordsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostDnsZoneRecordsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneRecordsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDnsZoneRecordsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneRecordsWithResponse indicates an expected call of PostDnsZoneRecordsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDnsZoneRecordsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneRecordsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDnsZoneRecordsWithResponse), varargs...)
+}
+
+// PostDnsZoneVerifyWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDnsZoneVerifyWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostDnsZoneVerifyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneVerifyWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDnsZoneVerifyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneVerifyWithBodyWithResponse indicates an expected call of PostDnsZoneVerifyWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDnsZoneVerifyWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneVerifyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDnsZoneVerifyWithBodyWithResponse), varargs...)
+}
+
+// PostDnsZoneVerifyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostDnsZoneVerifyWithResponse(ctx context.Context, body core.PostDnsZoneVerifyJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostDnsZoneVerifyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostDnsZoneVerifyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostDnsZoneVerifyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostDnsZoneVerifyWithResponse indicates an expected call of PostDnsZoneVerifyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostDnsZoneVerifyWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostDnsZoneVerifyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostDnsZoneVerifyWithResponse), varargs...)
+}
+
+// PostInvalidateLinkedWebSessionWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostInvalidateLinkedWebSessionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostInvalidateLinkedWebSessionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostInvalidateLinkedWebSessionWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostInvalidateLinkedWebSessionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostInvalidateLinkedWebSessionWithBodyWithResponse indicates an expected call of PostInvalidateLinkedWebSessionWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInvalidateLinkedWebSessionWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInvalidateLinkedWebSessionWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInvalidateLinkedWebSessionWithBodyWithResponse), varargs...)
+}
+
+// PostInvalidateLinkedWebSessionWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostInvalidateLinkedWebSessionWithResponse(ctx context.Context, body core.PostInvalidateLinkedWebSessionJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostInvalidateLinkedWebSessionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostInvalidateLinkedWebSessionWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostInvalidateLinkedWebSessionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostInvalidateLinkedWebSessionWithResponse indicates an expected call of PostInvalidateLinkedWebSessionWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostInvalidateLinkedWebSessionWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostInvalidateLinkedWebSessionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostInvalidateLinkedWebSessionWithResponse), varargs...)
+}
+
+// PostIpAddressUnallocateWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostIpAddressUnallocateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostIpAddressUnallocateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostIpAddressUnallocateWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostIpAddressUnallocateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostIpAddressUnallocateWithBodyWithResponse indicates an expected call of PostIpAddressUnallocateWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostIpAddressUnallocateWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostIpAddressUnallocateWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostIpAddressUnallocateWithBodyWithResponse), varargs...)
+}
+
+// PostIpAddressUnallocateWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostIpAddressUnallocateWithResponse(ctx context.Context, body core.PostIpAddressUnallocateJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostIpAddressUnallocateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostIpAddressUnallocateWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostIpAddressUnallocateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostIpAddressUnallocateWithResponse indicates an expected call of PostIpAddressUnallocateWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostIpAddressUnallocateWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostIpAddressUnallocateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostIpAddressUnallocateWithResponse), varargs...)
+}
+
+// PostLoadBalancerRulesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostLoadBalancerRulesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostLoadBalancerRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostLoadBalancerRulesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostLoadBalancerRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostLoadBalancerRulesWithBodyWithResponse indicates an expected call of PostLoadBalancerRulesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostLoadBalancerRulesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLoadBalancerRulesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostLoadBalancerRulesWithBodyWithResponse), varargs...)
+}
+
+// PostLoadBalancerRulesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostLoadBalancerRulesWithResponse(ctx context.Context, body core.PostLoadBalancerRulesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostLoadBalancerRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostLoadBalancerRulesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostLoadBalancerRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostLoadBalancerRulesWithResponse indicates an expected call of PostLoadBalancerRulesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostLoadBalancerRulesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostLoadBalancerRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostLoadBalancerRulesWithResponse), varargs...)
+}
+
+// PostOrganizationAddressListsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationAddressListsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationAddressListsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationAddressListsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationAddressListsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationAddressListsWithBodyWithResponse indicates an expected call of PostOrganizationAddressListsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationAddressListsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationAddressListsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationAddressListsWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationAddressListsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationAddressListsWithResponse(ctx context.Context, body core.PostOrganizationAddressListsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationAddressListsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationAddressListsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationAddressListsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationAddressListsWithResponse indicates an expected call of PostOrganizationAddressListsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationAddressListsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationAddressListsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationAddressListsWithResponse), varargs...)
+}
+
+// PostOrganizationDnsZonesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationDnsZonesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationDnsZonesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationDnsZonesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationDnsZonesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationDnsZonesWithBodyWithResponse indicates an expected call of PostOrganizationDnsZonesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationDnsZonesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationDnsZonesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationDnsZonesWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationDnsZonesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationDnsZonesWithResponse(ctx context.Context, body core.PostOrganizationDnsZonesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationDnsZonesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationDnsZonesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationDnsZonesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationDnsZonesWithResponse indicates an expected call of PostOrganizationDnsZonesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationDnsZonesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationDnsZonesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationDnsZonesWithResponse), varargs...)
+}
+
+// PostOrganizationFileStorageVolumesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationFileStorageVolumesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationFileStorageVolumesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationFileStorageVolumesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationFileStorageVolumesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationFileStorageVolumesWithBodyWithResponse indicates an expected call of PostOrganizationFileStorageVolumesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationFileStorageVolumesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationFileStorageVolumesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationFileStorageVolumesWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationFileStorageVolumesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationFileStorageVolumesWithResponse(ctx context.Context, body core.PostOrganizationFileStorageVolumesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationFileStorageVolumesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationFileStorageVolumesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationFileStorageVolumesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationFileStorageVolumesWithResponse indicates an expected call of PostOrganizationFileStorageVolumesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationFileStorageVolumesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationFileStorageVolumesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationFileStorageVolumesWithResponse), varargs...)
+}
+
+// PostOrganizationIpAddressesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationIpAddressesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationIpAddressesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationIpAddressesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationIpAddressesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationIpAddressesWithBodyWithResponse indicates an expected call of PostOrganizationIpAddressesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationIpAddressesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationIpAddressesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationIpAddressesWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationIpAddressesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationIpAddressesWithResponse(ctx context.Context, body core.PostOrganizationIpAddressesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationIpAddressesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationIpAddressesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationIpAddressesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationIpAddressesWithResponse indicates an expected call of PostOrganizationIpAddressesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationIpAddressesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationIpAddressesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationIpAddressesWithResponse), varargs...)
+}
+
+// PostOrganizationLoadBalancersWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationLoadBalancersWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationLoadBalancersResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationLoadBalancersWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationLoadBalancersResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationLoadBalancersWithBodyWithResponse indicates an expected call of PostOrganizationLoadBalancersWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationLoadBalancersWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationLoadBalancersWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationLoadBalancersWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationLoadBalancersWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationLoadBalancersWithResponse(ctx context.Context, body core.PostOrganizationLoadBalancersJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationLoadBalancersResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationLoadBalancersWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationLoadBalancersResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationLoadBalancersWithResponse indicates an expected call of PostOrganizationLoadBalancersWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationLoadBalancersWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationLoadBalancersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationLoadBalancersWithResponse), varargs...)
+}
+
+// PostOrganizationManagedWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationManagedWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationManagedResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationManagedWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationManagedResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationManagedWithBodyWithResponse indicates an expected call of PostOrganizationManagedWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationManagedWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationManagedWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationManagedWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationManagedWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationManagedWithResponse(ctx context.Context, body core.PostOrganizationManagedJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationManagedResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationManagedWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationManagedResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationManagedWithResponse indicates an expected call of PostOrganizationManagedWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationManagedWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationManagedWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationManagedWithResponse), varargs...)
+}
+
+// PostOrganizationSecurityGroupsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationSecurityGroupsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationSecurityGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSecurityGroupsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationSecurityGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSecurityGroupsWithBodyWithResponse indicates an expected call of PostOrganizationSecurityGroupsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationSecurityGroupsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSecurityGroupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationSecurityGroupsWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationSecurityGroupsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationSecurityGroupsWithResponse(ctx context.Context, body core.PostOrganizationSecurityGroupsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationSecurityGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSecurityGroupsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationSecurityGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSecurityGroupsWithResponse indicates an expected call of PostOrganizationSecurityGroupsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationSecurityGroupsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSecurityGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationSecurityGroupsWithResponse), varargs...)
+}
+
+// PostOrganizationSshKeysWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationSshKeysWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationSshKeysResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSshKeysWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationSshKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSshKeysWithBodyWithResponse indicates an expected call of PostOrganizationSshKeysWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationSshKeysWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSshKeysWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationSshKeysWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationSshKeysWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationSshKeysWithResponse(ctx context.Context, body core.PostOrganizationSshKeysJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationSshKeysResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationSshKeysWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationSshKeysResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationSshKeysWithResponse indicates an expected call of PostOrganizationSshKeysWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationSshKeysWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationSshKeysWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationSshKeysWithResponse), varargs...)
+}
+
+// PostOrganizationTagsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationTagsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationTagsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTagsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationTagsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTagsWithBodyWithResponse indicates an expected call of PostOrganizationTagsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationTagsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTagsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationTagsWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationTagsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationTagsWithResponse(ctx context.Context, body core.PostOrganizationTagsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationTagsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTagsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationTagsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTagsWithResponse indicates an expected call of PostOrganizationTagsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationTagsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTagsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationTagsWithResponse), varargs...)
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationTrashObjectsPurgeAllResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationTrashObjectsPurgeAllResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse indicates an expected call of PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationTrashObjectsPurgeAllWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationTrashObjectsPurgeAllWithResponse(ctx context.Context, body core.PostOrganizationTrashObjectsPurgeAllJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationTrashObjectsPurgeAllResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationTrashObjectsPurgeAllWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationTrashObjectsPurgeAllResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationTrashObjectsPurgeAllWithResponse indicates an expected call of PostOrganizationTrashObjectsPurgeAllWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationTrashObjectsPurgeAllWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationTrashObjectsPurgeAllWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationTrashObjectsPurgeAllWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachineGroupsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachineGroupsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachineGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachineGroupsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachineGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachineGroupsWithBodyWithResponse indicates an expected call of PostOrganizationVirtualMachineGroupsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachineGroupsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachineGroupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachineGroupsWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachineGroupsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachineGroupsWithResponse(ctx context.Context, body core.PostOrganizationVirtualMachineGroupsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachineGroupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachineGroupsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachineGroupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachineGroupsWithResponse indicates an expected call of PostOrganizationVirtualMachineGroupsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachineGroupsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachineGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachineGroupsWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachinesBuildFromSpecResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachinesBuildFromSpecResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse indicates an expected call of PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachinesBuildFromSpecWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachinesBuildFromSpecWithResponse(ctx context.Context, body core.PostOrganizationVirtualMachinesBuildFromSpecJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachinesBuildFromSpecResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildFromSpecWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachinesBuildFromSpecResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildFromSpecWithResponse indicates an expected call of PostOrganizationVirtualMachinesBuildFromSpecWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildFromSpecWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildFromSpecWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachinesBuildFromSpecWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachinesBuildWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachinesBuildResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachinesBuildResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildWithBodyWithResponse indicates an expected call of PostOrganizationVirtualMachinesBuildWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachinesBuildWithBodyWithResponse), varargs...)
+}
+
+// PostOrganizationVirtualMachinesBuildWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostOrganizationVirtualMachinesBuildWithResponse(ctx context.Context, body core.PostOrganizationVirtualMachinesBuildJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostOrganizationVirtualMachinesBuildResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostOrganizationVirtualMachinesBuildWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostOrganizationVirtualMachinesBuildResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostOrganizationVirtualMachinesBuildWithResponse indicates an expected call of PostOrganizationVirtualMachinesBuildWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostOrganizationVirtualMachinesBuildWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostOrganizationVirtualMachinesBuildWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostOrganizationVirtualMachinesBuildWithResponse), varargs...)
+}
+
+// PostSecurityGroupRulesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostSecurityGroupRulesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostSecurityGroupRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSecurityGroupRulesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostSecurityGroupRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSecurityGroupRulesWithBodyWithResponse indicates an expected call of PostSecurityGroupRulesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostSecurityGroupRulesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSecurityGroupRulesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostSecurityGroupRulesWithBodyWithResponse), varargs...)
+}
+
+// PostSecurityGroupRulesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostSecurityGroupRulesWithResponse(ctx context.Context, body core.PostSecurityGroupRulesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostSecurityGroupRulesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSecurityGroupRulesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostSecurityGroupRulesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSecurityGroupRulesWithResponse indicates an expected call of PostSecurityGroupRulesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostSecurityGroupRulesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSecurityGroupRulesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostSecurityGroupRulesWithResponse), varargs...)
+}
+
+// PostTrashObjectRestoreWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostTrashObjectRestoreWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostTrashObjectRestoreResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostTrashObjectRestoreWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostTrashObjectRestoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostTrashObjectRestoreWithBodyWithResponse indicates an expected call of PostTrashObjectRestoreWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTrashObjectRestoreWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTrashObjectRestoreWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTrashObjectRestoreWithBodyWithResponse), varargs...)
+}
+
+// PostTrashObjectRestoreWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostTrashObjectRestoreWithResponse(ctx context.Context, body core.PostTrashObjectRestoreJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostTrashObjectRestoreResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostTrashObjectRestoreWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostTrashObjectRestoreResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostTrashObjectRestoreWithResponse indicates an expected call of PostTrashObjectRestoreWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostTrashObjectRestoreWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostTrashObjectRestoreWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostTrashObjectRestoreWithResponse), varargs...)
+}
+
+// PostVirtualMachineAllocateIpWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineAllocateIpWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineAllocateIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineAllocateIpWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineAllocateIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineAllocateIpWithBodyWithResponse indicates an expected call of PostVirtualMachineAllocateIpWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineAllocateIpWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineAllocateIpWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineAllocateIpWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineAllocateIpWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineAllocateIpWithResponse(ctx context.Context, body core.PostVirtualMachineAllocateIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineAllocateIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineAllocateIpWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineAllocateIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineAllocateIpWithResponse indicates an expected call of PostVirtualMachineAllocateIpWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineAllocateIpWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineAllocateIpWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineAllocateIpWithResponse), varargs...)
+}
+
+// PostVirtualMachineConsoleSessionsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineConsoleSessionsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineConsoleSessionsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineConsoleSessionsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineConsoleSessionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineConsoleSessionsWithBodyWithResponse indicates an expected call of PostVirtualMachineConsoleSessionsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineConsoleSessionsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineConsoleSessionsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineConsoleSessionsWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineConsoleSessionsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineConsoleSessionsWithResponse(ctx context.Context, body core.PostVirtualMachineConsoleSessionsJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineConsoleSessionsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineConsoleSessionsWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineConsoleSessionsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineConsoleSessionsWithResponse indicates an expected call of PostVirtualMachineConsoleSessionsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineConsoleSessionsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineConsoleSessionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineConsoleSessionsWithResponse), varargs...)
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse indicates an expected call of PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineDiskBackupPoliciesWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineDiskBackupPoliciesWithResponse(ctx context.Context, body core.PostVirtualMachineDiskBackupPoliciesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineDiskBackupPoliciesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineDiskBackupPoliciesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineDiskBackupPoliciesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineDiskBackupPoliciesWithResponse indicates an expected call of PostVirtualMachineDiskBackupPoliciesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineDiskBackupPoliciesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineDiskBackupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineDiskBackupPoliciesWithResponse), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineNetworkInterfaceAllocateIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineNetworkInterfaceAllocateIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateIpWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineNetworkInterfaceAllocateIpWithResponse(ctx context.Context, body core.PostVirtualMachineNetworkInterfaceAllocateIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineNetworkInterfaceAllocateIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateIpWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineNetworkInterfaceAllocateIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateIpWithResponse indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateIpWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateIpWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateIpWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateIpWithResponse), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineNetworkInterfaceAllocateNewIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineNetworkInterfaceAllocateNewIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateNewIpWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse(ctx context.Context, body core.PostVirtualMachineNetworkInterfaceAllocateNewIpJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineNetworkInterfaceAllocateNewIpResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineNetworkInterfaceAllocateNewIpResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse indicates an expected call of PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineNetworkInterfaceAllocateNewIpWithResponse), varargs...)
+}
+
+// PostVirtualMachineResetWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineResetWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineResetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineResetWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineResetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineResetWithBodyWithResponse indicates an expected call of PostVirtualMachineResetWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineResetWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineResetWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineResetWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineResetWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineResetWithResponse(ctx context.Context, body core.PostVirtualMachineResetJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineResetResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineResetWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineResetResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineResetWithResponse indicates an expected call of PostVirtualMachineResetWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineResetWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineResetWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineResetWithResponse), varargs...)
+}
+
+// PostVirtualMachineShutdownWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineShutdownWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineShutdownResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineShutdownWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineShutdownResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineShutdownWithBodyWithResponse indicates an expected call of PostVirtualMachineShutdownWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineShutdownWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineShutdownWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineShutdownWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineShutdownWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineShutdownWithResponse(ctx context.Context, body core.PostVirtualMachineShutdownJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineShutdownResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineShutdownWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineShutdownResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineShutdownWithResponse indicates an expected call of PostVirtualMachineShutdownWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineShutdownWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineShutdownWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineShutdownWithResponse), varargs...)
+}
+
+// PostVirtualMachineStartWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineStartWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineStartResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStartWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineStartResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStartWithBodyWithResponse indicates an expected call of PostVirtualMachineStartWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineStartWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStartWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineStartWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineStartWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineStartWithResponse(ctx context.Context, body core.PostVirtualMachineStartJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineStartResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStartWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineStartResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStartWithResponse indicates an expected call of PostVirtualMachineStartWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineStartWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStartWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineStartWithResponse), varargs...)
+}
+
+// PostVirtualMachineStopWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineStopWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineStopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStopWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineStopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStopWithBodyWithResponse indicates an expected call of PostVirtualMachineStopWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineStopWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStopWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineStopWithBodyWithResponse), varargs...)
+}
+
+// PostVirtualMachineStopWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostVirtualMachineStopWithResponse(ctx context.Context, body core.PostVirtualMachineStopJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PostVirtualMachineStopResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostVirtualMachineStopWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PostVirtualMachineStopResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostVirtualMachineStopWithResponse indicates an expected call of PostVirtualMachineStopWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostVirtualMachineStopWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostVirtualMachineStopWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostVirtualMachineStopWithResponse), varargs...)
+}
+
+// PutVirtualMachineFlexibleResourcesWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PutVirtualMachineFlexibleResourcesWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PutVirtualMachineFlexibleResourcesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachineFlexibleResourcesWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PutVirtualMachineFlexibleResourcesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachineFlexibleResourcesWithBodyWithResponse indicates an expected call of PutVirtualMachineFlexibleResourcesWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PutVirtualMachineFlexibleResourcesWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachineFlexibleResourcesWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutVirtualMachineFlexibleResourcesWithBodyWithResponse), varargs...)
+}
+
+// PutVirtualMachineFlexibleResourcesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PutVirtualMachineFlexibleResourcesWithResponse(ctx context.Context, body core.PutVirtualMachineFlexibleResourcesJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PutVirtualMachineFlexibleResourcesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachineFlexibleResourcesWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PutVirtualMachineFlexibleResourcesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachineFlexibleResourcesWithResponse indicates an expected call of PutVirtualMachineFlexibleResourcesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PutVirtualMachineFlexibleResourcesWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachineFlexibleResourcesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutVirtualMachineFlexibleResourcesWithResponse), varargs...)
+}
+
+// PutVirtualMachinePackageWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PutVirtualMachinePackageWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...core.RequestEditorFn) (*core.PutVirtualMachinePackageResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachinePackageWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PutVirtualMachinePackageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachinePackageWithBodyWithResponse indicates an expected call of PutVirtualMachinePackageWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PutVirtualMachinePackageWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachinePackageWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutVirtualMachinePackageWithBodyWithResponse), varargs...)
+}
+
+// PutVirtualMachinePackageWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PutVirtualMachinePackageWithResponse(ctx context.Context, body core.PutVirtualMachinePackageJSONRequestBody, reqEditors ...core.RequestEditorFn) (*core.PutVirtualMachinePackageResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutVirtualMachinePackageWithResponse", varargs...)
+	ret0, _ := ret[0].(*core.PutVirtualMachinePackageResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutVirtualMachinePackageWithResponse indicates an expected call of PutVirtualMachinePackageWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PutVirtualMachinePackageWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutVirtualMachinePackageWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PutVirtualMachinePackageWithResponse), varargs...)
+}
diff --git a/next/public/mock/public.go b/next/public/mock/public.go
new file mode 100644
index 0000000..8776bb8
--- /dev/null
+++ b/next/public/mock/public.go
@@ -0,0 +1,424 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: ./public/public.go
+//
+// Generated by this command:
+//
+//	mockgen -source=./public/public.go -destination=./public/mock/public.go
+//
+
+// Package mock_public is a generated GoMock package.
+package mock_public
+
+import (
+	context "context"
+	io "io"
+	http "net/http"
+	reflect "reflect"
+
+	public "github.com/krystal/go-katapult/next/public"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockHttpRequestDoer is a mock of HttpRequestDoer interface.
+type MockHttpRequestDoer struct {
+	ctrl     *gomock.Controller
+	recorder *MockHttpRequestDoerMockRecorder
+}
+
+// MockHttpRequestDoerMockRecorder is the mock recorder for MockHttpRequestDoer.
+type MockHttpRequestDoerMockRecorder struct {
+	mock *MockHttpRequestDoer
+}
+
+// NewMockHttpRequestDoer creates a new mock instance.
+func NewMockHttpRequestDoer(ctrl *gomock.Controller) *MockHttpRequestDoer {
+	mock := &MockHttpRequestDoer{ctrl: ctrl}
+	mock.recorder = &MockHttpRequestDoerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockHttpRequestDoer) EXPECT() *MockHttpRequestDoerMockRecorder {
+	return m.recorder
+}
+
+// Do mocks base method.
+func (m *MockHttpRequestDoer) Do(req *http.Request) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Do", req)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Do indicates an expected call of Do.
+func (mr *MockHttpRequestDoerMockRecorder) Do(req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHttpRequestDoer)(nil).Do), req)
+}
+
+// MockClientInterface is a mock of ClientInterface interface.
+type MockClientInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientInterfaceMockRecorder
+}
+
+// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
+type MockClientInterfaceMockRecorder struct {
+	mock *MockClientInterface
+}
+
+// NewMockClientInterface creates a new mock instance.
+func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
+	mock := &MockClientInterface{ctrl: ctrl}
+	mock.recorder = &MockClientInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClientInterface) EXPECT() *MockClientInterfaceMockRecorder {
+	return m.recorder
+}
+
+// GetDataCenters mocks base method.
+func (m *MockClientInterface) GetDataCenters(ctx context.Context, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCenters", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCenters indicates an expected call of GetDataCenters.
+func (mr *MockClientInterfaceMockRecorder) GetDataCenters(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCenters", reflect.TypeOf((*MockClientInterface)(nil).GetDataCenters), varargs...)
+}
+
+// GetPricingPrices mocks base method.
+func (m *MockClientInterface) GetPricingPrices(ctx context.Context, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetPricingPrices", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPricingPrices indicates an expected call of GetPricingPrices.
+func (mr *MockClientInterfaceMockRecorder) GetPricingPrices(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPricingPrices", reflect.TypeOf((*MockClientInterface)(nil).GetPricingPrices), varargs...)
+}
+
+// GetStats mocks base method.
+func (m *MockClientInterface) GetStats(ctx context.Context, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetStats", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStats indicates an expected call of GetStats.
+func (mr *MockClientInterfaceMockRecorder) GetStats(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStats", reflect.TypeOf((*MockClientInterface)(nil).GetStats), varargs...)
+}
+
+// GetVirtualMachinePackages mocks base method.
+func (m *MockClientInterface) GetVirtualMachinePackages(ctx context.Context, params *public.GetVirtualMachinePackagesParams, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackages", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackages indicates an expected call of GetVirtualMachinePackages.
+func (mr *MockClientInterfaceMockRecorder) GetVirtualMachinePackages(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackages", reflect.TypeOf((*MockClientInterface)(nil).GetVirtualMachinePackages), varargs...)
+}
+
+// PostPricingEstimate mocks base method.
+func (m *MockClientInterface) PostPricingEstimate(ctx context.Context, body public.PostPricingEstimateJSONRequestBody, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostPricingEstimate", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostPricingEstimate indicates an expected call of PostPricingEstimate.
+func (mr *MockClientInterfaceMockRecorder) PostPricingEstimate(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostPricingEstimate", reflect.TypeOf((*MockClientInterface)(nil).PostPricingEstimate), varargs...)
+}
+
+// PostPricingEstimateWithBody mocks base method.
+func (m *MockClientInterface) PostPricingEstimateWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostPricingEstimateWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostPricingEstimateWithBody indicates an expected call of PostPricingEstimateWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostPricingEstimateWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostPricingEstimateWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostPricingEstimateWithBody), varargs...)
+}
+
+// PostSignups mocks base method.
+func (m *MockClientInterface) PostSignups(ctx context.Context, body public.PostSignupsJSONRequestBody, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSignups", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSignups indicates an expected call of PostSignups.
+func (mr *MockClientInterfaceMockRecorder) PostSignups(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSignups", reflect.TypeOf((*MockClientInterface)(nil).PostSignups), varargs...)
+}
+
+// PostSignupsWithBody mocks base method.
+func (m *MockClientInterface) PostSignupsWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...public.RequestEditorFn) (*http.Response, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSignupsWithBody", varargs...)
+	ret0, _ := ret[0].(*http.Response)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSignupsWithBody indicates an expected call of PostSignupsWithBody.
+func (mr *MockClientInterfaceMockRecorder) PostSignupsWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSignupsWithBody", reflect.TypeOf((*MockClientInterface)(nil).PostSignupsWithBody), varargs...)
+}
+
+// MockClientWithResponsesInterface is a mock of ClientWithResponsesInterface interface.
+type MockClientWithResponsesInterface struct {
+	ctrl     *gomock.Controller
+	recorder *MockClientWithResponsesInterfaceMockRecorder
+}
+
+// MockClientWithResponsesInterfaceMockRecorder is the mock recorder for MockClientWithResponsesInterface.
+type MockClientWithResponsesInterfaceMockRecorder struct {
+	mock *MockClientWithResponsesInterface
+}
+
+// NewMockClientWithResponsesInterface creates a new mock instance.
+func NewMockClientWithResponsesInterface(ctrl *gomock.Controller) *MockClientWithResponsesInterface {
+	mock := &MockClientWithResponsesInterface{ctrl: ctrl}
+	mock.recorder = &MockClientWithResponsesInterfaceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockClientWithResponsesInterface) EXPECT() *MockClientWithResponsesInterfaceMockRecorder {
+	return m.recorder
+}
+
+// GetDataCentersWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetDataCentersWithResponse(ctx context.Context, reqEditors ...public.RequestEditorFn) (*public.GetDataCentersResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDataCentersWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.GetDataCentersResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDataCentersWithResponse indicates an expected call of GetDataCentersWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDataCentersWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataCentersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDataCentersWithResponse), varargs...)
+}
+
+// GetPricingPricesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetPricingPricesWithResponse(ctx context.Context, reqEditors ...public.RequestEditorFn) (*public.GetPricingPricesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetPricingPricesWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.GetPricingPricesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPricingPricesWithResponse indicates an expected call of GetPricingPricesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetPricingPricesWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPricingPricesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetPricingPricesWithResponse), varargs...)
+}
+
+// GetStatsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetStatsWithResponse(ctx context.Context, reqEditors ...public.RequestEditorFn) (*public.GetStatsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetStatsWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.GetStatsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetStatsWithResponse indicates an expected call of GetStatsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetStatsWithResponse(ctx any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetStatsWithResponse), varargs...)
+}
+
+// GetVirtualMachinePackagesWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) GetVirtualMachinePackagesWithResponse(ctx context.Context, params *public.GetVirtualMachinePackagesParams, reqEditors ...public.RequestEditorFn) (*public.GetVirtualMachinePackagesResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetVirtualMachinePackagesWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.GetVirtualMachinePackagesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetVirtualMachinePackagesWithResponse indicates an expected call of GetVirtualMachinePackagesWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) GetVirtualMachinePackagesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVirtualMachinePackagesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetVirtualMachinePackagesWithResponse), varargs...)
+}
+
+// PostPricingEstimateWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostPricingEstimateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...public.RequestEditorFn) (*public.PostPricingEstimateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostPricingEstimateWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.PostPricingEstimateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostPricingEstimateWithBodyWithResponse indicates an expected call of PostPricingEstimateWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostPricingEstimateWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostPricingEstimateWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostPricingEstimateWithBodyWithResponse), varargs...)
+}
+
+// PostPricingEstimateWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostPricingEstimateWithResponse(ctx context.Context, body public.PostPricingEstimateJSONRequestBody, reqEditors ...public.RequestEditorFn) (*public.PostPricingEstimateResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostPricingEstimateWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.PostPricingEstimateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostPricingEstimateWithResponse indicates an expected call of PostPricingEstimateWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostPricingEstimateWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostPricingEstimateWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostPricingEstimateWithResponse), varargs...)
+}
+
+// PostSignupsWithBodyWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostSignupsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...public.RequestEditorFn) (*public.PostSignupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, contentType, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSignupsWithBodyWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.PostSignupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSignupsWithBodyWithResponse indicates an expected call of PostSignupsWithBodyWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostSignupsWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, contentType, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSignupsWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostSignupsWithBodyWithResponse), varargs...)
+}
+
+// PostSignupsWithResponse mocks base method.
+func (m *MockClientWithResponsesInterface) PostSignupsWithResponse(ctx context.Context, body public.PostSignupsJSONRequestBody, reqEditors ...public.RequestEditorFn) (*public.PostSignupsResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range reqEditors {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PostSignupsWithResponse", varargs...)
+	ret0, _ := ret[0].(*public.PostSignupsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PostSignupsWithResponse indicates an expected call of PostSignupsWithResponse.
+func (mr *MockClientWithResponsesInterfaceMockRecorder) PostSignupsWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, reqEditors...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostSignupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).PostSignupsWithResponse), varargs...)
+}