// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/hetznercloud/cli/internal/hcapi2 (interfaces: ActionClient,CertificateClient,DatacenterClient,ImageClient,ISOClient,FirewallClient,FloatingIPClient,PrimaryIPClient,LocationClient,LoadBalancerClient,LoadBalancerTypeClient,NetworkClient,ServerClient,ServerTypeClient,SSHKeyClient,VolumeClient,PlacementGroupClient,RDNSClient,PricingClient,StorageBoxClient,StorageBoxTypeClient,ZoneClient)
//
// Generated by this command:
//
//	mockgen -package mock -destination zz_hcapi_mock.go github.com/hetznercloud/cli/internal/hcapi2 ActionClient,CertificateClient,DatacenterClient,ImageClient,ISOClient,FirewallClient,FloatingIPClient,PrimaryIPClient,LocationClient,LoadBalancerClient,LoadBalancerTypeClient,NetworkClient,ServerClient,ServerTypeClient,SSHKeyClient,VolumeClient,PlacementGroupClient,RDNSClient,PricingClient,StorageBoxClient,StorageBoxTypeClient,ZoneClient
//

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	net "net"
	reflect "reflect"

	hcloud "github.com/hetznercloud/hcloud-go/v2/hcloud"
	gomock "go.uber.org/mock/gomock"
)

// MockActionClient is a mock of ActionClient interface.
type MockActionClient struct {
	ctrl     *gomock.Controller
	recorder *MockActionClientMockRecorder
	isgomock struct{}
}

// MockActionClientMockRecorder is the mock recorder for MockActionClient.
type MockActionClientMockRecorder struct {
	mock *MockActionClient
}

// NewMockActionClient creates a new mock instance.
func NewMockActionClient(ctrl *gomock.Controller) *MockActionClient {
	mock := &MockActionClient{ctrl: ctrl}
	mock.recorder = &MockActionClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockActionClient) EXPECT() *MockActionClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockActionClient) All(ctx context.Context) ([]*hcloud.Action, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockActionClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockActionClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockActionClient) AllWithOpts(ctx context.Context, opts hcloud.ActionListOpts) ([]*hcloud.Action, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockActionClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockActionClient)(nil).AllWithOpts), ctx, opts)
}

// GetByID mocks base method.
func (m *MockActionClient) GetByID(ctx context.Context, id int64) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockActionClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockActionClient)(nil).GetByID), ctx, id)
}

// List mocks base method.
func (m *MockActionClient) List(ctx context.Context, opts hcloud.ActionListOpts) ([]*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockActionClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockActionClient)(nil).List), ctx, opts)
}

// WaitFor mocks base method.
func (m *MockActionClient) WaitFor(ctx context.Context, actions ...*hcloud.Action) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range actions {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitFor", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitFor indicates an expected call of WaitFor.
func (mr *MockActionClientMockRecorder) WaitFor(ctx any, actions ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, actions...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitFor", reflect.TypeOf((*MockActionClient)(nil).WaitFor), varargs...)
}

// WaitForFunc mocks base method.
func (m *MockActionClient) WaitForFunc(ctx context.Context, handleUpdate func(*hcloud.Action) error, actions ...*hcloud.Action) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, handleUpdate}
	for _, a := range actions {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitForFunc", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitForFunc indicates an expected call of WaitForFunc.
func (mr *MockActionClientMockRecorder) WaitForFunc(ctx, handleUpdate any, actions ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, handleUpdate}, actions...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForFunc", reflect.TypeOf((*MockActionClient)(nil).WaitForFunc), varargs...)
}

// WatchOverallProgress mocks base method.
func (m *MockActionClient) WatchOverallProgress(ctx context.Context, actions []*hcloud.Action) (<-chan int, <-chan error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchOverallProgress", ctx, actions)
	ret0, _ := ret[0].(<-chan int)
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// WatchOverallProgress indicates an expected call of WatchOverallProgress.
func (mr *MockActionClientMockRecorder) WatchOverallProgress(ctx, actions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchOverallProgress", reflect.TypeOf((*MockActionClient)(nil).WatchOverallProgress), ctx, actions)
}

// WatchProgress mocks base method.
func (m *MockActionClient) WatchProgress(ctx context.Context, action *hcloud.Action) (<-chan int, <-chan error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchProgress", ctx, action)
	ret0, _ := ret[0].(<-chan int)
	ret1, _ := ret[1].(<-chan error)
	return ret0, ret1
}

// WatchProgress indicates an expected call of WatchProgress.
func (mr *MockActionClientMockRecorder) WatchProgress(ctx, action any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchProgress", reflect.TypeOf((*MockActionClient)(nil).WatchProgress), ctx, action)
}

// MockCertificateClient is a mock of CertificateClient interface.
type MockCertificateClient struct {
	ctrl     *gomock.Controller
	recorder *MockCertificateClientMockRecorder
	isgomock struct{}
}

// MockCertificateClientMockRecorder is the mock recorder for MockCertificateClient.
type MockCertificateClientMockRecorder struct {
	mock *MockCertificateClient
}

// NewMockCertificateClient creates a new mock instance.
func NewMockCertificateClient(ctrl *gomock.Controller) *MockCertificateClient {
	mock := &MockCertificateClient{ctrl: ctrl}
	mock.recorder = &MockCertificateClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCertificateClient) EXPECT() *MockCertificateClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockCertificateClient) All(ctx context.Context) ([]*hcloud.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockCertificateClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockCertificateClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockCertificateClient) AllWithOpts(ctx context.Context, opts hcloud.CertificateListOpts) ([]*hcloud.Certificate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockCertificateClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockCertificateClient)(nil).AllWithOpts), ctx, opts)
}

// Create mocks base method.
func (m *MockCertificateClient) Create(ctx context.Context, opts hcloud.CertificateCreateOpts) (*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockCertificateClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockCertificateClient)(nil).Create), ctx, opts)
}

// CreateCertificate mocks base method.
func (m *MockCertificateClient) CreateCertificate(ctx context.Context, opts hcloud.CertificateCreateOpts) (hcloud.CertificateCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCertificate", ctx, opts)
	ret0, _ := ret[0].(hcloud.CertificateCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateCertificate indicates an expected call of CreateCertificate.
func (mr *MockCertificateClientMockRecorder) CreateCertificate(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockCertificateClient)(nil).CreateCertificate), ctx, opts)
}

// Delete mocks base method.
func (m *MockCertificateClient) Delete(ctx context.Context, certificate *hcloud.Certificate) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, certificate)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockCertificateClientMockRecorder) Delete(ctx, certificate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCertificateClient)(nil).Delete), ctx, certificate)
}

// Get mocks base method.
func (m *MockCertificateClient) Get(ctx context.Context, idOrName string) (*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockCertificateClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCertificateClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockCertificateClient) GetByID(ctx context.Context, id int64) (*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockCertificateClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockCertificateClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockCertificateClient) GetByName(ctx context.Context, name string) (*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockCertificateClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockCertificateClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockCertificateClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockCertificateClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockCertificateClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockCertificateClient) List(ctx context.Context, opts hcloud.CertificateListOpts) ([]*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockCertificateClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockCertificateClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockCertificateClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockCertificateClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockCertificateClient)(nil).Names))
}

// RetryIssuance mocks base method.
func (m *MockCertificateClient) RetryIssuance(ctx context.Context, certificate *hcloud.Certificate) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryIssuance", ctx, certificate)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RetryIssuance indicates an expected call of RetryIssuance.
func (mr *MockCertificateClientMockRecorder) RetryIssuance(ctx, certificate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryIssuance", reflect.TypeOf((*MockCertificateClient)(nil).RetryIssuance), ctx, certificate)
}

// Update mocks base method.
func (m *MockCertificateClient) Update(ctx context.Context, certificate *hcloud.Certificate, opts hcloud.CertificateUpdateOpts) (*hcloud.Certificate, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, certificate, opts)
	ret0, _ := ret[0].(*hcloud.Certificate)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockCertificateClientMockRecorder) Update(ctx, certificate, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCertificateClient)(nil).Update), ctx, certificate, opts)
}

// MockDatacenterClient is a mock of DatacenterClient interface.
type MockDatacenterClient struct {
	ctrl     *gomock.Controller
	recorder *MockDatacenterClientMockRecorder
	isgomock struct{}
}

// MockDatacenterClientMockRecorder is the mock recorder for MockDatacenterClient.
type MockDatacenterClientMockRecorder struct {
	mock *MockDatacenterClient
}

// NewMockDatacenterClient creates a new mock instance.
func NewMockDatacenterClient(ctrl *gomock.Controller) *MockDatacenterClient {
	mock := &MockDatacenterClient{ctrl: ctrl}
	mock.recorder = &MockDatacenterClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDatacenterClient) EXPECT() *MockDatacenterClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockDatacenterClient) All(ctx context.Context) ([]*hcloud.Datacenter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Datacenter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockDatacenterClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockDatacenterClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockDatacenterClient) AllWithOpts(ctx context.Context, opts hcloud.DatacenterListOpts) ([]*hcloud.Datacenter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Datacenter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockDatacenterClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockDatacenterClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockDatacenterClient) Get(ctx context.Context, idOrName string) (*hcloud.Datacenter, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Datacenter)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockDatacenterClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDatacenterClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockDatacenterClient) GetByID(ctx context.Context, id int64) (*hcloud.Datacenter, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Datacenter)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockDatacenterClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockDatacenterClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockDatacenterClient) GetByName(ctx context.Context, name string) (*hcloud.Datacenter, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Datacenter)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockDatacenterClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockDatacenterClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockDatacenterClient) List(ctx context.Context, opts hcloud.DatacenterListOpts) ([]*hcloud.Datacenter, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Datacenter)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockDatacenterClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockDatacenterClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockDatacenterClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockDatacenterClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockDatacenterClient)(nil).Names))
}

// MockImageClient is a mock of ImageClient interface.
type MockImageClient struct {
	ctrl     *gomock.Controller
	recorder *MockImageClientMockRecorder
	isgomock struct{}
}

// MockImageClientMockRecorder is the mock recorder for MockImageClient.
type MockImageClientMockRecorder struct {
	mock *MockImageClient
}

// NewMockImageClient creates a new mock instance.
func NewMockImageClient(ctrl *gomock.Controller) *MockImageClient {
	mock := &MockImageClient{ctrl: ctrl}
	mock.recorder = &MockImageClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockImageClient) EXPECT() *MockImageClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockImageClient) All(ctx context.Context) ([]*hcloud.Image, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Image)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockImageClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockImageClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockImageClient) AllWithOpts(ctx context.Context, opts hcloud.ImageListOpts) ([]*hcloud.Image, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Image)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockImageClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockImageClient)(nil).AllWithOpts), ctx, opts)
}

// ChangeProtection mocks base method.
func (m *MockImageClient) ChangeProtection(ctx context.Context, image *hcloud.Image, opts hcloud.ImageChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, image, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockImageClientMockRecorder) ChangeProtection(ctx, image, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockImageClient)(nil).ChangeProtection), ctx, image, opts)
}

// Delete mocks base method.
func (m *MockImageClient) Delete(ctx context.Context, image *hcloud.Image) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, image)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockImageClientMockRecorder) Delete(ctx, image any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockImageClient)(nil).Delete), ctx, image)
}

// Get mocks base method.
func (m *MockImageClient) Get(ctx context.Context, idOrName string) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockImageClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockImageClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockImageClient) GetByID(ctx context.Context, id int64) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockImageClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockImageClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockImageClient) GetByName(ctx context.Context, name string) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockImageClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockImageClient)(nil).GetByName), ctx, name)
}

// GetByNameAndArchitecture mocks base method.
func (m *MockImageClient) GetByNameAndArchitecture(ctx context.Context, name string, architecture hcloud.Architecture) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByNameAndArchitecture", ctx, name, architecture)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByNameAndArchitecture indicates an expected call of GetByNameAndArchitecture.
func (mr *MockImageClientMockRecorder) GetByNameAndArchitecture(ctx, name, architecture any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByNameAndArchitecture", reflect.TypeOf((*MockImageClient)(nil).GetByNameAndArchitecture), ctx, name, architecture)
}

// GetForArchitecture mocks base method.
func (m *MockImageClient) GetForArchitecture(ctx context.Context, idOrName string, architecture hcloud.Architecture) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetForArchitecture", ctx, idOrName, architecture)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetForArchitecture indicates an expected call of GetForArchitecture.
func (mr *MockImageClientMockRecorder) GetForArchitecture(ctx, idOrName, architecture any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetForArchitecture", reflect.TypeOf((*MockImageClient)(nil).GetForArchitecture), ctx, idOrName, architecture)
}

// LabelKeys mocks base method.
func (m *MockImageClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockImageClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockImageClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockImageClient) List(ctx context.Context, opts hcloud.ImageListOpts) ([]*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockImageClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockImageClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockImageClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockImageClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockImageClient)(nil).Names))
}

// Update mocks base method.
func (m *MockImageClient) Update(ctx context.Context, image *hcloud.Image, opts hcloud.ImageUpdateOpts) (*hcloud.Image, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, image, opts)
	ret0, _ := ret[0].(*hcloud.Image)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockImageClientMockRecorder) Update(ctx, image, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockImageClient)(nil).Update), ctx, image, opts)
}

// MockISOClient is a mock of ISOClient interface.
type MockISOClient struct {
	ctrl     *gomock.Controller
	recorder *MockISOClientMockRecorder
	isgomock struct{}
}

// MockISOClientMockRecorder is the mock recorder for MockISOClient.
type MockISOClientMockRecorder struct {
	mock *MockISOClient
}

// NewMockISOClient creates a new mock instance.
func NewMockISOClient(ctrl *gomock.Controller) *MockISOClient {
	mock := &MockISOClient{ctrl: ctrl}
	mock.recorder = &MockISOClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockISOClient) EXPECT() *MockISOClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockISOClient) All(ctx context.Context) ([]*hcloud.ISO, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.ISO)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockISOClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockISOClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockISOClient) AllWithOpts(ctx context.Context, opts hcloud.ISOListOpts) ([]*hcloud.ISO, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.ISO)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockISOClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockISOClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockISOClient) Get(ctx context.Context, idOrName string) (*hcloud.ISO, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.ISO)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockISOClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockISOClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockISOClient) GetByID(ctx context.Context, id int64) (*hcloud.ISO, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.ISO)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockISOClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockISOClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockISOClient) GetByName(ctx context.Context, name string) (*hcloud.ISO, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.ISO)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockISOClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockISOClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockISOClient) List(ctx context.Context, opts hcloud.ISOListOpts) ([]*hcloud.ISO, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.ISO)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockISOClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockISOClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockISOClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockISOClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockISOClient)(nil).Names))
}

// MockFirewallClient is a mock of FirewallClient interface.
type MockFirewallClient struct {
	ctrl     *gomock.Controller
	recorder *MockFirewallClientMockRecorder
	isgomock struct{}
}

// MockFirewallClientMockRecorder is the mock recorder for MockFirewallClient.
type MockFirewallClientMockRecorder struct {
	mock *MockFirewallClient
}

// NewMockFirewallClient creates a new mock instance.
func NewMockFirewallClient(ctrl *gomock.Controller) *MockFirewallClient {
	mock := &MockFirewallClient{ctrl: ctrl}
	mock.recorder = &MockFirewallClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFirewallClient) EXPECT() *MockFirewallClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockFirewallClient) All(ctx context.Context) ([]*hcloud.Firewall, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Firewall)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockFirewallClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockFirewallClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockFirewallClient) AllWithOpts(ctx context.Context, opts hcloud.FirewallListOpts) ([]*hcloud.Firewall, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Firewall)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockFirewallClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockFirewallClient)(nil).AllWithOpts), ctx, opts)
}

// ApplyResources mocks base method.
func (m *MockFirewallClient) ApplyResources(ctx context.Context, firewall *hcloud.Firewall, resources []hcloud.FirewallResource) ([]*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyResources", ctx, firewall, resources)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ApplyResources indicates an expected call of ApplyResources.
func (mr *MockFirewallClientMockRecorder) ApplyResources(ctx, firewall, resources any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyResources", reflect.TypeOf((*MockFirewallClient)(nil).ApplyResources), ctx, firewall, resources)
}

// Create mocks base method.
func (m *MockFirewallClient) Create(ctx context.Context, opts hcloud.FirewallCreateOpts) (hcloud.FirewallCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.FirewallCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockFirewallClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFirewallClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockFirewallClient) Delete(ctx context.Context, firewall *hcloud.Firewall) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, firewall)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockFirewallClientMockRecorder) Delete(ctx, firewall any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockFirewallClient)(nil).Delete), ctx, firewall)
}

// Get mocks base method.
func (m *MockFirewallClient) Get(ctx context.Context, idOrName string) (*hcloud.Firewall, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Firewall)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockFirewallClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockFirewallClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockFirewallClient) GetByID(ctx context.Context, id int64) (*hcloud.Firewall, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Firewall)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockFirewallClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockFirewallClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockFirewallClient) GetByName(ctx context.Context, name string) (*hcloud.Firewall, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Firewall)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockFirewallClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockFirewallClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockFirewallClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockFirewallClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockFirewallClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockFirewallClient) List(ctx context.Context, opts hcloud.FirewallListOpts) ([]*hcloud.Firewall, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Firewall)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockFirewallClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockFirewallClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockFirewallClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockFirewallClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockFirewallClient)(nil).Names))
}

// RemoveResources mocks base method.
func (m *MockFirewallClient) RemoveResources(ctx context.Context, firewall *hcloud.Firewall, resources []hcloud.FirewallResource) ([]*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveResources", ctx, firewall, resources)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveResources indicates an expected call of RemoveResources.
func (mr *MockFirewallClientMockRecorder) RemoveResources(ctx, firewall, resources any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResources", reflect.TypeOf((*MockFirewallClient)(nil).RemoveResources), ctx, firewall, resources)
}

// SetRules mocks base method.
func (m *MockFirewallClient) SetRules(ctx context.Context, firewall *hcloud.Firewall, opts hcloud.FirewallSetRulesOpts) ([]*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRules", ctx, firewall, opts)
	ret0, _ := ret[0].([]*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SetRules indicates an expected call of SetRules.
func (mr *MockFirewallClientMockRecorder) SetRules(ctx, firewall, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRules", reflect.TypeOf((*MockFirewallClient)(nil).SetRules), ctx, firewall, opts)
}

// Update mocks base method.
func (m *MockFirewallClient) Update(ctx context.Context, firewall *hcloud.Firewall, opts hcloud.FirewallUpdateOpts) (*hcloud.Firewall, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, firewall, opts)
	ret0, _ := ret[0].(*hcloud.Firewall)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockFirewallClientMockRecorder) Update(ctx, firewall, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockFirewallClient)(nil).Update), ctx, firewall, opts)
}

// MockFloatingIPClient is a mock of FloatingIPClient interface.
type MockFloatingIPClient struct {
	ctrl     *gomock.Controller
	recorder *MockFloatingIPClientMockRecorder
	isgomock struct{}
}

// MockFloatingIPClientMockRecorder is the mock recorder for MockFloatingIPClient.
type MockFloatingIPClientMockRecorder struct {
	mock *MockFloatingIPClient
}

// NewMockFloatingIPClient creates a new mock instance.
func NewMockFloatingIPClient(ctrl *gomock.Controller) *MockFloatingIPClient {
	mock := &MockFloatingIPClient{ctrl: ctrl}
	mock.recorder = &MockFloatingIPClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFloatingIPClient) EXPECT() *MockFloatingIPClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockFloatingIPClient) All(ctx context.Context) ([]*hcloud.FloatingIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.FloatingIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockFloatingIPClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockFloatingIPClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockFloatingIPClient) AllWithOpts(ctx context.Context, opts hcloud.FloatingIPListOpts) ([]*hcloud.FloatingIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.FloatingIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockFloatingIPClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockFloatingIPClient)(nil).AllWithOpts), ctx, opts)
}

// Assign mocks base method.
func (m *MockFloatingIPClient) Assign(ctx context.Context, floatingIP *hcloud.FloatingIP, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Assign", ctx, floatingIP, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Assign indicates an expected call of Assign.
func (mr *MockFloatingIPClientMockRecorder) Assign(ctx, floatingIP, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Assign", reflect.TypeOf((*MockFloatingIPClient)(nil).Assign), ctx, floatingIP, server)
}

// ChangeDNSPtr mocks base method.
func (m *MockFloatingIPClient) ChangeDNSPtr(ctx context.Context, floatingIP *hcloud.FloatingIP, ip string, ptr *string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeDNSPtr", ctx, floatingIP, ip, ptr)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeDNSPtr indicates an expected call of ChangeDNSPtr.
func (mr *MockFloatingIPClientMockRecorder) ChangeDNSPtr(ctx, floatingIP, ip, ptr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDNSPtr", reflect.TypeOf((*MockFloatingIPClient)(nil).ChangeDNSPtr), ctx, floatingIP, ip, ptr)
}

// ChangeProtection mocks base method.
func (m *MockFloatingIPClient) ChangeProtection(ctx context.Context, floatingIP *hcloud.FloatingIP, opts hcloud.FloatingIPChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, floatingIP, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockFloatingIPClientMockRecorder) ChangeProtection(ctx, floatingIP, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockFloatingIPClient)(nil).ChangeProtection), ctx, floatingIP, opts)
}

// Create mocks base method.
func (m *MockFloatingIPClient) Create(ctx context.Context, opts hcloud.FloatingIPCreateOpts) (hcloud.FloatingIPCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.FloatingIPCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockFloatingIPClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFloatingIPClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockFloatingIPClient) Delete(ctx context.Context, floatingIP *hcloud.FloatingIP) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, floatingIP)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockFloatingIPClientMockRecorder) Delete(ctx, floatingIP any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockFloatingIPClient)(nil).Delete), ctx, floatingIP)
}

// Get mocks base method.
func (m *MockFloatingIPClient) Get(ctx context.Context, idOrName string) (*hcloud.FloatingIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.FloatingIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockFloatingIPClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockFloatingIPClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockFloatingIPClient) GetByID(ctx context.Context, id int64) (*hcloud.FloatingIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.FloatingIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockFloatingIPClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockFloatingIPClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockFloatingIPClient) GetByName(ctx context.Context, name string) (*hcloud.FloatingIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.FloatingIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockFloatingIPClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockFloatingIPClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockFloatingIPClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockFloatingIPClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockFloatingIPClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockFloatingIPClient) List(ctx context.Context, opts hcloud.FloatingIPListOpts) ([]*hcloud.FloatingIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.FloatingIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockFloatingIPClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockFloatingIPClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockFloatingIPClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockFloatingIPClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockFloatingIPClient)(nil).Names))
}

// Unassign mocks base method.
func (m *MockFloatingIPClient) Unassign(ctx context.Context, floatingIP *hcloud.FloatingIP) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unassign", ctx, floatingIP)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Unassign indicates an expected call of Unassign.
func (mr *MockFloatingIPClientMockRecorder) Unassign(ctx, floatingIP any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unassign", reflect.TypeOf((*MockFloatingIPClient)(nil).Unassign), ctx, floatingIP)
}

// Update mocks base method.
func (m *MockFloatingIPClient) Update(ctx context.Context, floatingIP *hcloud.FloatingIP, opts hcloud.FloatingIPUpdateOpts) (*hcloud.FloatingIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, floatingIP, opts)
	ret0, _ := ret[0].(*hcloud.FloatingIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockFloatingIPClientMockRecorder) Update(ctx, floatingIP, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockFloatingIPClient)(nil).Update), ctx, floatingIP, opts)
}

// MockPrimaryIPClient is a mock of PrimaryIPClient interface.
type MockPrimaryIPClient struct {
	ctrl     *gomock.Controller
	recorder *MockPrimaryIPClientMockRecorder
	isgomock struct{}
}

// MockPrimaryIPClientMockRecorder is the mock recorder for MockPrimaryIPClient.
type MockPrimaryIPClientMockRecorder struct {
	mock *MockPrimaryIPClient
}

// NewMockPrimaryIPClient creates a new mock instance.
func NewMockPrimaryIPClient(ctrl *gomock.Controller) *MockPrimaryIPClient {
	mock := &MockPrimaryIPClient{ctrl: ctrl}
	mock.recorder = &MockPrimaryIPClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPrimaryIPClient) EXPECT() *MockPrimaryIPClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockPrimaryIPClient) All(ctx context.Context) ([]*hcloud.PrimaryIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.PrimaryIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockPrimaryIPClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockPrimaryIPClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockPrimaryIPClient) AllWithOpts(ctx context.Context, opts hcloud.PrimaryIPListOpts) ([]*hcloud.PrimaryIP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.PrimaryIP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockPrimaryIPClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockPrimaryIPClient)(nil).AllWithOpts), ctx, opts)
}

// Assign mocks base method.
func (m *MockPrimaryIPClient) Assign(ctx context.Context, opts hcloud.PrimaryIPAssignOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Assign", ctx, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Assign indicates an expected call of Assign.
func (mr *MockPrimaryIPClientMockRecorder) Assign(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Assign", reflect.TypeOf((*MockPrimaryIPClient)(nil).Assign), ctx, opts)
}

// ChangeDNSPtr mocks base method.
func (m *MockPrimaryIPClient) ChangeDNSPtr(ctx context.Context, opts hcloud.PrimaryIPChangeDNSPtrOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeDNSPtr", ctx, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeDNSPtr indicates an expected call of ChangeDNSPtr.
func (mr *MockPrimaryIPClientMockRecorder) ChangeDNSPtr(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDNSPtr", reflect.TypeOf((*MockPrimaryIPClient)(nil).ChangeDNSPtr), ctx, opts)
}

// ChangeProtection mocks base method.
func (m *MockPrimaryIPClient) ChangeProtection(ctx context.Context, opts hcloud.PrimaryIPChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockPrimaryIPClientMockRecorder) ChangeProtection(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockPrimaryIPClient)(nil).ChangeProtection), ctx, opts)
}

// Create mocks base method.
func (m *MockPrimaryIPClient) Create(ctx context.Context, opts hcloud.PrimaryIPCreateOpts) (*hcloud.PrimaryIPCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(*hcloud.PrimaryIPCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockPrimaryIPClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPrimaryIPClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockPrimaryIPClient) Delete(ctx context.Context, primaryIP *hcloud.PrimaryIP) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, primaryIP)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockPrimaryIPClientMockRecorder) Delete(ctx, primaryIP any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPrimaryIPClient)(nil).Delete), ctx, primaryIP)
}

// Get mocks base method.
func (m *MockPrimaryIPClient) Get(ctx context.Context, idOrName string) (*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockPrimaryIPClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPrimaryIPClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockPrimaryIPClient) GetByID(ctx context.Context, id int64) (*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockPrimaryIPClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockPrimaryIPClient)(nil).GetByID), ctx, id)
}

// GetByIP mocks base method.
func (m *MockPrimaryIPClient) GetByIP(ctx context.Context, ip string) (*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByIP", ctx, ip)
	ret0, _ := ret[0].(*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByIP indicates an expected call of GetByIP.
func (mr *MockPrimaryIPClientMockRecorder) GetByIP(ctx, ip any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByIP", reflect.TypeOf((*MockPrimaryIPClient)(nil).GetByIP), ctx, ip)
}

// GetByName mocks base method.
func (m *MockPrimaryIPClient) GetByName(ctx context.Context, name string) (*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockPrimaryIPClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockPrimaryIPClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockPrimaryIPClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockPrimaryIPClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockPrimaryIPClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockPrimaryIPClient) List(ctx context.Context, opts hcloud.PrimaryIPListOpts) ([]*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockPrimaryIPClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPrimaryIPClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockPrimaryIPClient) Names(hideAssigned, hideUnassigned bool, ipType *hcloud.PrimaryIPType) func() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names", hideAssigned, hideUnassigned, ipType)
	ret0, _ := ret[0].(func() []string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockPrimaryIPClientMockRecorder) Names(hideAssigned, hideUnassigned, ipType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockPrimaryIPClient)(nil).Names), hideAssigned, hideUnassigned, ipType)
}

// Unassign mocks base method.
func (m *MockPrimaryIPClient) Unassign(ctx context.Context, id int64) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unassign", ctx, id)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Unassign indicates an expected call of Unassign.
func (mr *MockPrimaryIPClientMockRecorder) Unassign(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unassign", reflect.TypeOf((*MockPrimaryIPClient)(nil).Unassign), ctx, id)
}

// Update mocks base method.
func (m *MockPrimaryIPClient) Update(ctx context.Context, primaryIP *hcloud.PrimaryIP, opts hcloud.PrimaryIPUpdateOpts) (*hcloud.PrimaryIP, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, primaryIP, opts)
	ret0, _ := ret[0].(*hcloud.PrimaryIP)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockPrimaryIPClientMockRecorder) Update(ctx, primaryIP, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockPrimaryIPClient)(nil).Update), ctx, primaryIP, opts)
}

// MockLocationClient is a mock of LocationClient interface.
type MockLocationClient struct {
	ctrl     *gomock.Controller
	recorder *MockLocationClientMockRecorder
	isgomock struct{}
}

// MockLocationClientMockRecorder is the mock recorder for MockLocationClient.
type MockLocationClientMockRecorder struct {
	mock *MockLocationClient
}

// NewMockLocationClient creates a new mock instance.
func NewMockLocationClient(ctrl *gomock.Controller) *MockLocationClient {
	mock := &MockLocationClient{ctrl: ctrl}
	mock.recorder = &MockLocationClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLocationClient) EXPECT() *MockLocationClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockLocationClient) All(ctx context.Context) ([]*hcloud.Location, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Location)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockLocationClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockLocationClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockLocationClient) AllWithOpts(ctx context.Context, opts hcloud.LocationListOpts) ([]*hcloud.Location, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Location)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockLocationClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockLocationClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockLocationClient) Get(ctx context.Context, idOrName string) (*hcloud.Location, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Location)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockLocationClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLocationClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockLocationClient) GetByID(ctx context.Context, id int64) (*hcloud.Location, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Location)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockLocationClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockLocationClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockLocationClient) GetByName(ctx context.Context, name string) (*hcloud.Location, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Location)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockLocationClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockLocationClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockLocationClient) List(ctx context.Context, opts hcloud.LocationListOpts) ([]*hcloud.Location, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Location)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockLocationClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLocationClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockLocationClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockLocationClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockLocationClient)(nil).Names))
}

// NetworkZones mocks base method.
func (m *MockLocationClient) NetworkZones() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetworkZones")
	ret0, _ := ret[0].([]string)
	return ret0
}

// NetworkZones indicates an expected call of NetworkZones.
func (mr *MockLocationClientMockRecorder) NetworkZones() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkZones", reflect.TypeOf((*MockLocationClient)(nil).NetworkZones))
}

// MockLoadBalancerClient is a mock of LoadBalancerClient interface.
type MockLoadBalancerClient struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancerClientMockRecorder
	isgomock struct{}
}

// MockLoadBalancerClientMockRecorder is the mock recorder for MockLoadBalancerClient.
type MockLoadBalancerClientMockRecorder struct {
	mock *MockLoadBalancerClient
}

// NewMockLoadBalancerClient creates a new mock instance.
func NewMockLoadBalancerClient(ctrl *gomock.Controller) *MockLoadBalancerClient {
	mock := &MockLoadBalancerClient{ctrl: ctrl}
	mock.recorder = &MockLoadBalancerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLoadBalancerClient) EXPECT() *MockLoadBalancerClientMockRecorder {
	return m.recorder
}

// AddIPTarget mocks base method.
func (m *MockLoadBalancerClient) AddIPTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerAddIPTargetOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddIPTarget", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddIPTarget indicates an expected call of AddIPTarget.
func (mr *MockLoadBalancerClientMockRecorder) AddIPTarget(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddIPTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).AddIPTarget), ctx, loadBalancer, opts)
}

// AddLabelSelectorTarget mocks base method.
func (m *MockLoadBalancerClient) AddLabelSelectorTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerAddLabelSelectorTargetOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddLabelSelectorTarget", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddLabelSelectorTarget indicates an expected call of AddLabelSelectorTarget.
func (mr *MockLoadBalancerClientMockRecorder) AddLabelSelectorTarget(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLabelSelectorTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).AddLabelSelectorTarget), ctx, loadBalancer, opts)
}

// AddServerTarget mocks base method.
func (m *MockLoadBalancerClient) AddServerTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerAddServerTargetOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddServerTarget", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddServerTarget indicates an expected call of AddServerTarget.
func (mr *MockLoadBalancerClientMockRecorder) AddServerTarget(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddServerTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).AddServerTarget), ctx, loadBalancer, opts)
}

// AddService mocks base method.
func (m *MockLoadBalancerClient) AddService(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerAddServiceOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddService", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddService indicates an expected call of AddService.
func (mr *MockLoadBalancerClientMockRecorder) AddService(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddService", reflect.TypeOf((*MockLoadBalancerClient)(nil).AddService), ctx, loadBalancer, opts)
}

// All mocks base method.
func (m *MockLoadBalancerClient) All(ctx context.Context) ([]*hcloud.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockLoadBalancerClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockLoadBalancerClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockLoadBalancerClient) AllWithOpts(ctx context.Context, opts hcloud.LoadBalancerListOpts) ([]*hcloud.LoadBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.LoadBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockLoadBalancerClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockLoadBalancerClient)(nil).AllWithOpts), ctx, opts)
}

// AttachToNetwork mocks base method.
func (m *MockLoadBalancerClient) AttachToNetwork(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerAttachToNetworkOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachToNetwork", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AttachToNetwork indicates an expected call of AttachToNetwork.
func (mr *MockLoadBalancerClientMockRecorder) AttachToNetwork(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachToNetwork", reflect.TypeOf((*MockLoadBalancerClient)(nil).AttachToNetwork), ctx, loadBalancer, opts)
}

// ChangeAlgorithm mocks base method.
func (m *MockLoadBalancerClient) ChangeAlgorithm(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerChangeAlgorithmOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeAlgorithm", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeAlgorithm indicates an expected call of ChangeAlgorithm.
func (mr *MockLoadBalancerClientMockRecorder) ChangeAlgorithm(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeAlgorithm", reflect.TypeOf((*MockLoadBalancerClient)(nil).ChangeAlgorithm), ctx, loadBalancer, opts)
}

// ChangeDNSPtr mocks base method.
func (m *MockLoadBalancerClient) ChangeDNSPtr(ctx context.Context, lb *hcloud.LoadBalancer, ip string, ptr *string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeDNSPtr", ctx, lb, ip, ptr)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeDNSPtr indicates an expected call of ChangeDNSPtr.
func (mr *MockLoadBalancerClientMockRecorder) ChangeDNSPtr(ctx, lb, ip, ptr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDNSPtr", reflect.TypeOf((*MockLoadBalancerClient)(nil).ChangeDNSPtr), ctx, lb, ip, ptr)
}

// ChangeProtection mocks base method.
func (m *MockLoadBalancerClient) ChangeProtection(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockLoadBalancerClientMockRecorder) ChangeProtection(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockLoadBalancerClient)(nil).ChangeProtection), ctx, loadBalancer, opts)
}

// ChangeType mocks base method.
func (m *MockLoadBalancerClient) ChangeType(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerChangeTypeOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeType", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeType indicates an expected call of ChangeType.
func (mr *MockLoadBalancerClientMockRecorder) ChangeType(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeType", reflect.TypeOf((*MockLoadBalancerClient)(nil).ChangeType), ctx, loadBalancer, opts)
}

// Create mocks base method.
func (m *MockLoadBalancerClient) Create(ctx context.Context, opts hcloud.LoadBalancerCreateOpts) (hcloud.LoadBalancerCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.LoadBalancerCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockLoadBalancerClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLoadBalancerClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockLoadBalancerClient) Delete(ctx context.Context, loadBalancer *hcloud.LoadBalancer) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, loadBalancer)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockLoadBalancerClientMockRecorder) Delete(ctx, loadBalancer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLoadBalancerClient)(nil).Delete), ctx, loadBalancer)
}

// DeleteService mocks base method.
func (m *MockLoadBalancerClient) DeleteService(ctx context.Context, loadBalancer *hcloud.LoadBalancer, listenPort int) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteService", ctx, loadBalancer, listenPort)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteService indicates an expected call of DeleteService.
func (mr *MockLoadBalancerClientMockRecorder) DeleteService(ctx, loadBalancer, listenPort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockLoadBalancerClient)(nil).DeleteService), ctx, loadBalancer, listenPort)
}

// DetachFromNetwork mocks base method.
func (m *MockLoadBalancerClient) DetachFromNetwork(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerDetachFromNetworkOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachFromNetwork", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DetachFromNetwork indicates an expected call of DetachFromNetwork.
func (mr *MockLoadBalancerClientMockRecorder) DetachFromNetwork(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachFromNetwork", reflect.TypeOf((*MockLoadBalancerClient)(nil).DetachFromNetwork), ctx, loadBalancer, opts)
}

// DisablePublicInterface mocks base method.
func (m *MockLoadBalancerClient) DisablePublicInterface(ctx context.Context, loadBalancer *hcloud.LoadBalancer) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisablePublicInterface", ctx, loadBalancer)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DisablePublicInterface indicates an expected call of DisablePublicInterface.
func (mr *MockLoadBalancerClientMockRecorder) DisablePublicInterface(ctx, loadBalancer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisablePublicInterface", reflect.TypeOf((*MockLoadBalancerClient)(nil).DisablePublicInterface), ctx, loadBalancer)
}

// EnablePublicInterface mocks base method.
func (m *MockLoadBalancerClient) EnablePublicInterface(ctx context.Context, loadBalancer *hcloud.LoadBalancer) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnablePublicInterface", ctx, loadBalancer)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EnablePublicInterface indicates an expected call of EnablePublicInterface.
func (mr *MockLoadBalancerClientMockRecorder) EnablePublicInterface(ctx, loadBalancer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnablePublicInterface", reflect.TypeOf((*MockLoadBalancerClient)(nil).EnablePublicInterface), ctx, loadBalancer)
}

// Get mocks base method.
func (m *MockLoadBalancerClient) Get(ctx context.Context, idOrName string) (*hcloud.LoadBalancer, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.LoadBalancer)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockLoadBalancerClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoadBalancerClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockLoadBalancerClient) GetByID(ctx context.Context, id int64) (*hcloud.LoadBalancer, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.LoadBalancer)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockLoadBalancerClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockLoadBalancerClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockLoadBalancerClient) GetByName(ctx context.Context, name string) (*hcloud.LoadBalancer, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.LoadBalancer)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockLoadBalancerClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockLoadBalancerClient)(nil).GetByName), ctx, name)
}

// GetMetrics mocks base method.
func (m *MockLoadBalancerClient) GetMetrics(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerGetMetricsOpts) (*hcloud.LoadBalancerMetrics, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetrics", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.LoadBalancerMetrics)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMetrics indicates an expected call of GetMetrics.
func (mr *MockLoadBalancerClientMockRecorder) GetMetrics(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetrics", reflect.TypeOf((*MockLoadBalancerClient)(nil).GetMetrics), ctx, loadBalancer, opts)
}

// LabelKeys mocks base method.
func (m *MockLoadBalancerClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockLoadBalancerClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockLoadBalancerClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockLoadBalancerClient) List(ctx context.Context, opts hcloud.LoadBalancerListOpts) ([]*hcloud.LoadBalancer, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.LoadBalancer)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockLoadBalancerClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLoadBalancerClient)(nil).List), ctx, opts)
}

// LoadBalancerName mocks base method.
func (m *MockLoadBalancerClient) LoadBalancerName(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerName", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// LoadBalancerName indicates an expected call of LoadBalancerName.
func (mr *MockLoadBalancerClientMockRecorder) LoadBalancerName(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerName", reflect.TypeOf((*MockLoadBalancerClient)(nil).LoadBalancerName), id)
}

// Names mocks base method.
func (m *MockLoadBalancerClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockLoadBalancerClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockLoadBalancerClient)(nil).Names))
}

// RemoveIPTarget mocks base method.
func (m *MockLoadBalancerClient) RemoveIPTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, ip net.IP) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveIPTarget", ctx, loadBalancer, ip)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveIPTarget indicates an expected call of RemoveIPTarget.
func (mr *MockLoadBalancerClientMockRecorder) RemoveIPTarget(ctx, loadBalancer, ip any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveIPTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).RemoveIPTarget), ctx, loadBalancer, ip)
}

// RemoveLabelSelectorTarget mocks base method.
func (m *MockLoadBalancerClient) RemoveLabelSelectorTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, labelSelector string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveLabelSelectorTarget", ctx, loadBalancer, labelSelector)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveLabelSelectorTarget indicates an expected call of RemoveLabelSelectorTarget.
func (mr *MockLoadBalancerClientMockRecorder) RemoveLabelSelectorTarget(ctx, loadBalancer, labelSelector any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveLabelSelectorTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).RemoveLabelSelectorTarget), ctx, loadBalancer, labelSelector)
}

// RemoveServerTarget mocks base method.
func (m *MockLoadBalancerClient) RemoveServerTarget(ctx context.Context, loadBalancer *hcloud.LoadBalancer, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveServerTarget", ctx, loadBalancer, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveServerTarget indicates an expected call of RemoveServerTarget.
func (mr *MockLoadBalancerClientMockRecorder) RemoveServerTarget(ctx, loadBalancer, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveServerTarget", reflect.TypeOf((*MockLoadBalancerClient)(nil).RemoveServerTarget), ctx, loadBalancer, server)
}

// Update mocks base method.
func (m *MockLoadBalancerClient) Update(ctx context.Context, loadBalancer *hcloud.LoadBalancer, opts hcloud.LoadBalancerUpdateOpts) (*hcloud.LoadBalancer, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, loadBalancer, opts)
	ret0, _ := ret[0].(*hcloud.LoadBalancer)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockLoadBalancerClientMockRecorder) Update(ctx, loadBalancer, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLoadBalancerClient)(nil).Update), ctx, loadBalancer, opts)
}

// UpdateService mocks base method.
func (m *MockLoadBalancerClient) UpdateService(ctx context.Context, loadBalancer *hcloud.LoadBalancer, listenPort int, opts hcloud.LoadBalancerUpdateServiceOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateService", ctx, loadBalancer, listenPort, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateService indicates an expected call of UpdateService.
func (mr *MockLoadBalancerClientMockRecorder) UpdateService(ctx, loadBalancer, listenPort, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockLoadBalancerClient)(nil).UpdateService), ctx, loadBalancer, listenPort, opts)
}

// MockLoadBalancerTypeClient is a mock of LoadBalancerTypeClient interface.
type MockLoadBalancerTypeClient struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancerTypeClientMockRecorder
	isgomock struct{}
}

// MockLoadBalancerTypeClientMockRecorder is the mock recorder for MockLoadBalancerTypeClient.
type MockLoadBalancerTypeClientMockRecorder struct {
	mock *MockLoadBalancerTypeClient
}

// NewMockLoadBalancerTypeClient creates a new mock instance.
func NewMockLoadBalancerTypeClient(ctrl *gomock.Controller) *MockLoadBalancerTypeClient {
	mock := &MockLoadBalancerTypeClient{ctrl: ctrl}
	mock.recorder = &MockLoadBalancerTypeClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLoadBalancerTypeClient) EXPECT() *MockLoadBalancerTypeClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockLoadBalancerTypeClient) All(ctx context.Context) ([]*hcloud.LoadBalancerType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockLoadBalancerTypeClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockLoadBalancerTypeClient) AllWithOpts(ctx context.Context, opts hcloud.LoadBalancerTypeListOpts) ([]*hcloud.LoadBalancerType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockLoadBalancerTypeClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockLoadBalancerTypeClient) Get(ctx context.Context, idOrName string) (*hcloud.LoadBalancerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockLoadBalancerTypeClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockLoadBalancerTypeClient) GetByID(ctx context.Context, id int64) (*hcloud.LoadBalancerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockLoadBalancerTypeClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockLoadBalancerTypeClient) GetByName(ctx context.Context, name string) (*hcloud.LoadBalancerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockLoadBalancerTypeClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockLoadBalancerTypeClient) List(ctx context.Context, opts hcloud.LoadBalancerTypeListOpts) ([]*hcloud.LoadBalancerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.LoadBalancerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockLoadBalancerTypeClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).List), ctx, opts)
}

// LoadBalancerTypeDescription mocks base method.
func (m *MockLoadBalancerTypeClient) LoadBalancerTypeDescription(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerTypeDescription", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// LoadBalancerTypeDescription indicates an expected call of LoadBalancerTypeDescription.
func (mr *MockLoadBalancerTypeClientMockRecorder) LoadBalancerTypeDescription(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerTypeDescription", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).LoadBalancerTypeDescription), id)
}

// LoadBalancerTypeName mocks base method.
func (m *MockLoadBalancerTypeClient) LoadBalancerTypeName(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadBalancerTypeName", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// LoadBalancerTypeName indicates an expected call of LoadBalancerTypeName.
func (mr *MockLoadBalancerTypeClientMockRecorder) LoadBalancerTypeName(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancerTypeName", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).LoadBalancerTypeName), id)
}

// Names mocks base method.
func (m *MockLoadBalancerTypeClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockLoadBalancerTypeClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockLoadBalancerTypeClient)(nil).Names))
}

// MockNetworkClient is a mock of NetworkClient interface.
type MockNetworkClient struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkClientMockRecorder
	isgomock struct{}
}

// MockNetworkClientMockRecorder is the mock recorder for MockNetworkClient.
type MockNetworkClientMockRecorder struct {
	mock *MockNetworkClient
}

// NewMockNetworkClient creates a new mock instance.
func NewMockNetworkClient(ctrl *gomock.Controller) *MockNetworkClient {
	mock := &MockNetworkClient{ctrl: ctrl}
	mock.recorder = &MockNetworkClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNetworkClient) EXPECT() *MockNetworkClientMockRecorder {
	return m.recorder
}

// AddRoute mocks base method.
func (m *MockNetworkClient) AddRoute(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkAddRouteOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRoute", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddRoute indicates an expected call of AddRoute.
func (mr *MockNetworkClientMockRecorder) AddRoute(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoute", reflect.TypeOf((*MockNetworkClient)(nil).AddRoute), ctx, network, opts)
}

// AddSubnet mocks base method.
func (m *MockNetworkClient) AddSubnet(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkAddSubnetOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSubnet", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddSubnet indicates an expected call of AddSubnet.
func (mr *MockNetworkClientMockRecorder) AddSubnet(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSubnet", reflect.TypeOf((*MockNetworkClient)(nil).AddSubnet), ctx, network, opts)
}

// All mocks base method.
func (m *MockNetworkClient) All(ctx context.Context) ([]*hcloud.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockNetworkClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockNetworkClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockNetworkClient) AllWithOpts(ctx context.Context, opts hcloud.NetworkListOpts) ([]*hcloud.Network, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Network)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockNetworkClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockNetworkClient)(nil).AllWithOpts), ctx, opts)
}

// ChangeIPRange mocks base method.
func (m *MockNetworkClient) ChangeIPRange(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkChangeIPRangeOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeIPRange", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeIPRange indicates an expected call of ChangeIPRange.
func (mr *MockNetworkClientMockRecorder) ChangeIPRange(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeIPRange", reflect.TypeOf((*MockNetworkClient)(nil).ChangeIPRange), ctx, network, opts)
}

// ChangeProtection mocks base method.
func (m *MockNetworkClient) ChangeProtection(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockNetworkClientMockRecorder) ChangeProtection(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockNetworkClient)(nil).ChangeProtection), ctx, network, opts)
}

// Create mocks base method.
func (m *MockNetworkClient) Create(ctx context.Context, opts hcloud.NetworkCreateOpts) (*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockNetworkClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockNetworkClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockNetworkClient) Delete(ctx context.Context, network *hcloud.Network) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, network)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockNetworkClientMockRecorder) Delete(ctx, network any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockNetworkClient)(nil).Delete), ctx, network)
}

// DeleteRoute mocks base method.
func (m *MockNetworkClient) DeleteRoute(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkDeleteRouteOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRoute", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteRoute indicates an expected call of DeleteRoute.
func (mr *MockNetworkClientMockRecorder) DeleteRoute(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockNetworkClient)(nil).DeleteRoute), ctx, network, opts)
}

// DeleteSubnet mocks base method.
func (m *MockNetworkClient) DeleteSubnet(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkDeleteSubnetOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubnet", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteSubnet indicates an expected call of DeleteSubnet.
func (mr *MockNetworkClientMockRecorder) DeleteSubnet(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockNetworkClient)(nil).DeleteSubnet), ctx, network, opts)
}

// Get mocks base method.
func (m *MockNetworkClient) Get(ctx context.Context, idOrName string) (*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockNetworkClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockNetworkClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockNetworkClient) GetByID(ctx context.Context, id int64) (*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockNetworkClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockNetworkClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockNetworkClient) GetByName(ctx context.Context, name string) (*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockNetworkClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockNetworkClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockNetworkClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockNetworkClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockNetworkClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockNetworkClient) List(ctx context.Context, opts hcloud.NetworkListOpts) ([]*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockNetworkClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockNetworkClient)(nil).List), ctx, opts)
}

// Name mocks base method.
func (m *MockNetworkClient) Name(arg0 int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name", arg0)
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockNetworkClientMockRecorder) Name(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNetworkClient)(nil).Name), arg0)
}

// Names mocks base method.
func (m *MockNetworkClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockNetworkClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockNetworkClient)(nil).Names))
}

// Update mocks base method.
func (m *MockNetworkClient) Update(ctx context.Context, network *hcloud.Network, opts hcloud.NetworkUpdateOpts) (*hcloud.Network, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, network, opts)
	ret0, _ := ret[0].(*hcloud.Network)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockNetworkClientMockRecorder) Update(ctx, network, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNetworkClient)(nil).Update), ctx, network, opts)
}

// MockServerClient is a mock of ServerClient interface.
type MockServerClient struct {
	ctrl     *gomock.Controller
	recorder *MockServerClientMockRecorder
	isgomock struct{}
}

// MockServerClientMockRecorder is the mock recorder for MockServerClient.
type MockServerClientMockRecorder struct {
	mock *MockServerClient
}

// NewMockServerClient creates a new mock instance.
func NewMockServerClient(ctrl *gomock.Controller) *MockServerClient {
	mock := &MockServerClient{ctrl: ctrl}
	mock.recorder = &MockServerClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServerClient) EXPECT() *MockServerClientMockRecorder {
	return m.recorder
}

// AddToPlacementGroup mocks base method.
func (m *MockServerClient) AddToPlacementGroup(ctx context.Context, server *hcloud.Server, placementGroup *hcloud.PlacementGroup) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddToPlacementGroup", ctx, server, placementGroup)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddToPlacementGroup indicates an expected call of AddToPlacementGroup.
func (mr *MockServerClientMockRecorder) AddToPlacementGroup(ctx, server, placementGroup any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddToPlacementGroup", reflect.TypeOf((*MockServerClient)(nil).AddToPlacementGroup), ctx, server, placementGroup)
}

// All mocks base method.
func (m *MockServerClient) All(ctx context.Context) ([]*hcloud.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockServerClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockServerClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockServerClient) AllWithOpts(ctx context.Context, opts hcloud.ServerListOpts) ([]*hcloud.Server, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Server)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockServerClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockServerClient)(nil).AllWithOpts), ctx, opts)
}

// AttachISO mocks base method.
func (m *MockServerClient) AttachISO(ctx context.Context, server *hcloud.Server, iso *hcloud.ISO) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachISO", ctx, server, iso)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AttachISO indicates an expected call of AttachISO.
func (mr *MockServerClientMockRecorder) AttachISO(ctx, server, iso any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachISO", reflect.TypeOf((*MockServerClient)(nil).AttachISO), ctx, server, iso)
}

// AttachToNetwork mocks base method.
func (m *MockServerClient) AttachToNetwork(ctx context.Context, server *hcloud.Server, opts hcloud.ServerAttachToNetworkOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachToNetwork", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AttachToNetwork indicates an expected call of AttachToNetwork.
func (mr *MockServerClientMockRecorder) AttachToNetwork(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachToNetwork", reflect.TypeOf((*MockServerClient)(nil).AttachToNetwork), ctx, server, opts)
}

// ChangeAliasIPs mocks base method.
func (m *MockServerClient) ChangeAliasIPs(ctx context.Context, server *hcloud.Server, opts hcloud.ServerChangeAliasIPsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeAliasIPs", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeAliasIPs indicates an expected call of ChangeAliasIPs.
func (mr *MockServerClientMockRecorder) ChangeAliasIPs(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeAliasIPs", reflect.TypeOf((*MockServerClient)(nil).ChangeAliasIPs), ctx, server, opts)
}

// ChangeDNSPtr mocks base method.
func (m *MockServerClient) ChangeDNSPtr(ctx context.Context, server *hcloud.Server, ip string, ptr *string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeDNSPtr", ctx, server, ip, ptr)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeDNSPtr indicates an expected call of ChangeDNSPtr.
func (mr *MockServerClientMockRecorder) ChangeDNSPtr(ctx, server, ip, ptr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDNSPtr", reflect.TypeOf((*MockServerClient)(nil).ChangeDNSPtr), ctx, server, ip, ptr)
}

// ChangeProtection mocks base method.
func (m *MockServerClient) ChangeProtection(ctx context.Context, server *hcloud.Server, opts hcloud.ServerChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockServerClientMockRecorder) ChangeProtection(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockServerClient)(nil).ChangeProtection), ctx, server, opts)
}

// ChangeType mocks base method.
func (m *MockServerClient) ChangeType(ctx context.Context, server *hcloud.Server, opts hcloud.ServerChangeTypeOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeType", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeType indicates an expected call of ChangeType.
func (mr *MockServerClientMockRecorder) ChangeType(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeType", reflect.TypeOf((*MockServerClient)(nil).ChangeType), ctx, server, opts)
}

// Create mocks base method.
func (m *MockServerClient) Create(ctx context.Context, opts hcloud.ServerCreateOpts) (hcloud.ServerCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.ServerCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockServerClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockServerClient)(nil).Create), ctx, opts)
}

// CreateImage mocks base method.
func (m *MockServerClient) CreateImage(ctx context.Context, server *hcloud.Server, opts *hcloud.ServerCreateImageOpts) (hcloud.ServerCreateImageResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateImage", ctx, server, opts)
	ret0, _ := ret[0].(hcloud.ServerCreateImageResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateImage indicates an expected call of CreateImage.
func (mr *MockServerClientMockRecorder) CreateImage(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockServerClient)(nil).CreateImage), ctx, server, opts)
}

// Delete mocks base method.
func (m *MockServerClient) Delete(ctx context.Context, server *hcloud.Server) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, server)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockServerClientMockRecorder) Delete(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServerClient)(nil).Delete), ctx, server)
}

// DeleteWithResult mocks base method.
func (m *MockServerClient) DeleteWithResult(ctx context.Context, server *hcloud.Server) (*hcloud.ServerDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWithResult", ctx, server)
	ret0, _ := ret[0].(*hcloud.ServerDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteWithResult indicates an expected call of DeleteWithResult.
func (mr *MockServerClientMockRecorder) DeleteWithResult(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithResult", reflect.TypeOf((*MockServerClient)(nil).DeleteWithResult), ctx, server)
}

// DetachFromNetwork mocks base method.
func (m *MockServerClient) DetachFromNetwork(ctx context.Context, server *hcloud.Server, opts hcloud.ServerDetachFromNetworkOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachFromNetwork", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DetachFromNetwork indicates an expected call of DetachFromNetwork.
func (mr *MockServerClientMockRecorder) DetachFromNetwork(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachFromNetwork", reflect.TypeOf((*MockServerClient)(nil).DetachFromNetwork), ctx, server, opts)
}

// DetachISO mocks base method.
func (m *MockServerClient) DetachISO(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachISO", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DetachISO indicates an expected call of DetachISO.
func (mr *MockServerClientMockRecorder) DetachISO(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachISO", reflect.TypeOf((*MockServerClient)(nil).DetachISO), ctx, server)
}

// DisableBackup mocks base method.
func (m *MockServerClient) DisableBackup(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableBackup", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DisableBackup indicates an expected call of DisableBackup.
func (mr *MockServerClientMockRecorder) DisableBackup(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableBackup", reflect.TypeOf((*MockServerClient)(nil).DisableBackup), ctx, server)
}

// DisableRescue mocks base method.
func (m *MockServerClient) DisableRescue(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableRescue", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DisableRescue indicates an expected call of DisableRescue.
func (mr *MockServerClientMockRecorder) DisableRescue(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableRescue", reflect.TypeOf((*MockServerClient)(nil).DisableRescue), ctx, server)
}

// EnableBackup mocks base method.
func (m *MockServerClient) EnableBackup(ctx context.Context, server *hcloud.Server, window string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableBackup", ctx, server, window)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EnableBackup indicates an expected call of EnableBackup.
func (mr *MockServerClientMockRecorder) EnableBackup(ctx, server, window any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableBackup", reflect.TypeOf((*MockServerClient)(nil).EnableBackup), ctx, server, window)
}

// EnableRescue mocks base method.
func (m *MockServerClient) EnableRescue(ctx context.Context, server *hcloud.Server, opts hcloud.ServerEnableRescueOpts) (hcloud.ServerEnableRescueResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableRescue", ctx, server, opts)
	ret0, _ := ret[0].(hcloud.ServerEnableRescueResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EnableRescue indicates an expected call of EnableRescue.
func (mr *MockServerClientMockRecorder) EnableRescue(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableRescue", reflect.TypeOf((*MockServerClient)(nil).EnableRescue), ctx, server, opts)
}

// Get mocks base method.
func (m *MockServerClient) Get(ctx context.Context, idOrName string) (*hcloud.Server, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Server)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockServerClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockServerClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockServerClient) GetByID(ctx context.Context, id int64) (*hcloud.Server, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Server)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockServerClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockServerClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockServerClient) GetByName(ctx context.Context, name string) (*hcloud.Server, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Server)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockServerClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockServerClient)(nil).GetByName), ctx, name)
}

// GetMetrics mocks base method.
func (m *MockServerClient) GetMetrics(ctx context.Context, server *hcloud.Server, opts hcloud.ServerGetMetricsOpts) (*hcloud.ServerMetrics, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMetrics", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.ServerMetrics)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetMetrics indicates an expected call of GetMetrics.
func (mr *MockServerClientMockRecorder) GetMetrics(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetrics", reflect.TypeOf((*MockServerClient)(nil).GetMetrics), ctx, server, opts)
}

// LabelKeys mocks base method.
func (m *MockServerClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockServerClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockServerClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockServerClient) List(ctx context.Context, opts hcloud.ServerListOpts) ([]*hcloud.Server, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Server)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockServerClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockServerClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockServerClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockServerClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockServerClient)(nil).Names))
}

// Poweroff mocks base method.
func (m *MockServerClient) Poweroff(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Poweroff", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Poweroff indicates an expected call of Poweroff.
func (mr *MockServerClientMockRecorder) Poweroff(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Poweroff", reflect.TypeOf((*MockServerClient)(nil).Poweroff), ctx, server)
}

// Poweron mocks base method.
func (m *MockServerClient) Poweron(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Poweron", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Poweron indicates an expected call of Poweron.
func (mr *MockServerClientMockRecorder) Poweron(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Poweron", reflect.TypeOf((*MockServerClient)(nil).Poweron), ctx, server)
}

// Reboot mocks base method.
func (m *MockServerClient) Reboot(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reboot", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Reboot indicates an expected call of Reboot.
func (mr *MockServerClientMockRecorder) Reboot(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reboot", reflect.TypeOf((*MockServerClient)(nil).Reboot), ctx, server)
}

// Rebuild mocks base method.
func (m *MockServerClient) Rebuild(ctx context.Context, server *hcloud.Server, opts hcloud.ServerRebuildOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rebuild", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Rebuild indicates an expected call of Rebuild.
func (mr *MockServerClientMockRecorder) Rebuild(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rebuild", reflect.TypeOf((*MockServerClient)(nil).Rebuild), ctx, server, opts)
}

// RebuildWithResult mocks base method.
func (m *MockServerClient) RebuildWithResult(ctx context.Context, server *hcloud.Server, opts hcloud.ServerRebuildOpts) (hcloud.ServerRebuildResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebuildWithResult", ctx, server, opts)
	ret0, _ := ret[0].(hcloud.ServerRebuildResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RebuildWithResult indicates an expected call of RebuildWithResult.
func (mr *MockServerClientMockRecorder) RebuildWithResult(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebuildWithResult", reflect.TypeOf((*MockServerClient)(nil).RebuildWithResult), ctx, server, opts)
}

// RemoveFromPlacementGroup mocks base method.
func (m *MockServerClient) RemoveFromPlacementGroup(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFromPlacementGroup", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveFromPlacementGroup indicates an expected call of RemoveFromPlacementGroup.
func (mr *MockServerClientMockRecorder) RemoveFromPlacementGroup(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromPlacementGroup", reflect.TypeOf((*MockServerClient)(nil).RemoveFromPlacementGroup), ctx, server)
}

// RequestConsole mocks base method.
func (m *MockServerClient) RequestConsole(ctx context.Context, server *hcloud.Server) (hcloud.ServerRequestConsoleResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestConsole", ctx, server)
	ret0, _ := ret[0].(hcloud.ServerRequestConsoleResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RequestConsole indicates an expected call of RequestConsole.
func (mr *MockServerClientMockRecorder) RequestConsole(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestConsole", reflect.TypeOf((*MockServerClient)(nil).RequestConsole), ctx, server)
}

// Reset mocks base method.
func (m *MockServerClient) Reset(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reset", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Reset indicates an expected call of Reset.
func (mr *MockServerClientMockRecorder) Reset(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockServerClient)(nil).Reset), ctx, server)
}

// ResetPassword mocks base method.
func (m *MockServerClient) ResetPassword(ctx context.Context, server *hcloud.Server) (hcloud.ServerResetPasswordResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPassword", ctx, server)
	ret0, _ := ret[0].(hcloud.ServerResetPasswordResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetPassword indicates an expected call of ResetPassword.
func (mr *MockServerClientMockRecorder) ResetPassword(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPassword", reflect.TypeOf((*MockServerClient)(nil).ResetPassword), ctx, server)
}

// ServerName mocks base method.
func (m *MockServerClient) ServerName(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerName", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// ServerName indicates an expected call of ServerName.
func (mr *MockServerClientMockRecorder) ServerName(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerName", reflect.TypeOf((*MockServerClient)(nil).ServerName), id)
}

// Shutdown mocks base method.
func (m *MockServerClient) Shutdown(ctx context.Context, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Shutdown", ctx, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Shutdown indicates an expected call of Shutdown.
func (mr *MockServerClientMockRecorder) Shutdown(ctx, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockServerClient)(nil).Shutdown), ctx, server)
}

// Update mocks base method.
func (m *MockServerClient) Update(ctx context.Context, server *hcloud.Server, opts hcloud.ServerUpdateOpts) (*hcloud.Server, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, server, opts)
	ret0, _ := ret[0].(*hcloud.Server)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockServerClientMockRecorder) Update(ctx, server, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServerClient)(nil).Update), ctx, server, opts)
}

// MockServerTypeClient is a mock of ServerTypeClient interface.
type MockServerTypeClient struct {
	ctrl     *gomock.Controller
	recorder *MockServerTypeClientMockRecorder
	isgomock struct{}
}

// MockServerTypeClientMockRecorder is the mock recorder for MockServerTypeClient.
type MockServerTypeClientMockRecorder struct {
	mock *MockServerTypeClient
}

// NewMockServerTypeClient creates a new mock instance.
func NewMockServerTypeClient(ctrl *gomock.Controller) *MockServerTypeClient {
	mock := &MockServerTypeClient{ctrl: ctrl}
	mock.recorder = &MockServerTypeClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServerTypeClient) EXPECT() *MockServerTypeClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockServerTypeClient) All(ctx context.Context) ([]*hcloud.ServerType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.ServerType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockServerTypeClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockServerTypeClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockServerTypeClient) AllWithOpts(ctx context.Context, opts hcloud.ServerTypeListOpts) ([]*hcloud.ServerType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.ServerType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockServerTypeClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockServerTypeClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockServerTypeClient) Get(ctx context.Context, idOrName string) (*hcloud.ServerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.ServerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockServerTypeClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockServerTypeClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockServerTypeClient) GetByID(ctx context.Context, id int64) (*hcloud.ServerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.ServerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockServerTypeClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockServerTypeClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockServerTypeClient) GetByName(ctx context.Context, name string) (*hcloud.ServerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.ServerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockServerTypeClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockServerTypeClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockServerTypeClient) List(ctx context.Context, opts hcloud.ServerTypeListOpts) ([]*hcloud.ServerType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.ServerType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockServerTypeClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockServerTypeClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockServerTypeClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockServerTypeClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockServerTypeClient)(nil).Names))
}

// ServerTypeDescription mocks base method.
func (m *MockServerTypeClient) ServerTypeDescription(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerTypeDescription", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// ServerTypeDescription indicates an expected call of ServerTypeDescription.
func (mr *MockServerTypeClientMockRecorder) ServerTypeDescription(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerTypeDescription", reflect.TypeOf((*MockServerTypeClient)(nil).ServerTypeDescription), id)
}

// ServerTypeName mocks base method.
func (m *MockServerTypeClient) ServerTypeName(id int64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServerTypeName", id)
	ret0, _ := ret[0].(string)
	return ret0
}

// ServerTypeName indicates an expected call of ServerTypeName.
func (mr *MockServerTypeClientMockRecorder) ServerTypeName(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerTypeName", reflect.TypeOf((*MockServerTypeClient)(nil).ServerTypeName), id)
}

// MockSSHKeyClient is a mock of SSHKeyClient interface.
type MockSSHKeyClient struct {
	ctrl     *gomock.Controller
	recorder *MockSSHKeyClientMockRecorder
	isgomock struct{}
}

// MockSSHKeyClientMockRecorder is the mock recorder for MockSSHKeyClient.
type MockSSHKeyClientMockRecorder struct {
	mock *MockSSHKeyClient
}

// NewMockSSHKeyClient creates a new mock instance.
func NewMockSSHKeyClient(ctrl *gomock.Controller) *MockSSHKeyClient {
	mock := &MockSSHKeyClient{ctrl: ctrl}
	mock.recorder = &MockSSHKeyClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSSHKeyClient) EXPECT() *MockSSHKeyClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockSSHKeyClient) All(ctx context.Context) ([]*hcloud.SSHKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.SSHKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockSSHKeyClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockSSHKeyClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockSSHKeyClient) AllWithOpts(ctx context.Context, opts hcloud.SSHKeyListOpts) ([]*hcloud.SSHKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.SSHKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockSSHKeyClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockSSHKeyClient)(nil).AllWithOpts), ctx, opts)
}

// Create mocks base method.
func (m *MockSSHKeyClient) Create(ctx context.Context, opts hcloud.SSHKeyCreateOpts) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockSSHKeyClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSSHKeyClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockSSHKeyClient) Delete(ctx context.Context, sshKey *hcloud.SSHKey) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, sshKey)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockSSHKeyClientMockRecorder) Delete(ctx, sshKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSSHKeyClient)(nil).Delete), ctx, sshKey)
}

// Get mocks base method.
func (m *MockSSHKeyClient) Get(ctx context.Context, idOrName string) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockSSHKeyClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSSHKeyClient)(nil).Get), ctx, idOrName)
}

// GetByFingerprint mocks base method.
func (m *MockSSHKeyClient) GetByFingerprint(ctx context.Context, fingerprint string) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByFingerprint", ctx, fingerprint)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByFingerprint indicates an expected call of GetByFingerprint.
func (mr *MockSSHKeyClientMockRecorder) GetByFingerprint(ctx, fingerprint any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByFingerprint", reflect.TypeOf((*MockSSHKeyClient)(nil).GetByFingerprint), ctx, fingerprint)
}

// GetByID mocks base method.
func (m *MockSSHKeyClient) GetByID(ctx context.Context, id int64) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockSSHKeyClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockSSHKeyClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockSSHKeyClient) GetByName(ctx context.Context, name string) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockSSHKeyClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockSSHKeyClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockSSHKeyClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockSSHKeyClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockSSHKeyClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockSSHKeyClient) List(ctx context.Context, opts hcloud.SSHKeyListOpts) ([]*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockSSHKeyClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSSHKeyClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockSSHKeyClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockSSHKeyClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockSSHKeyClient)(nil).Names))
}

// Update mocks base method.
func (m *MockSSHKeyClient) Update(ctx context.Context, sshKey *hcloud.SSHKey, opts hcloud.SSHKeyUpdateOpts) (*hcloud.SSHKey, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, sshKey, opts)
	ret0, _ := ret[0].(*hcloud.SSHKey)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockSSHKeyClientMockRecorder) Update(ctx, sshKey, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSSHKeyClient)(nil).Update), ctx, sshKey, opts)
}

// MockVolumeClient is a mock of VolumeClient interface.
type MockVolumeClient struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeClientMockRecorder
	isgomock struct{}
}

// MockVolumeClientMockRecorder is the mock recorder for MockVolumeClient.
type MockVolumeClientMockRecorder struct {
	mock *MockVolumeClient
}

// NewMockVolumeClient creates a new mock instance.
func NewMockVolumeClient(ctrl *gomock.Controller) *MockVolumeClient {
	mock := &MockVolumeClient{ctrl: ctrl}
	mock.recorder = &MockVolumeClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVolumeClient) EXPECT() *MockVolumeClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockVolumeClient) All(ctx context.Context) ([]*hcloud.Volume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockVolumeClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockVolumeClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockVolumeClient) AllWithOpts(ctx context.Context, opts hcloud.VolumeListOpts) ([]*hcloud.Volume, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Volume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockVolumeClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockVolumeClient)(nil).AllWithOpts), ctx, opts)
}

// Attach mocks base method.
func (m *MockVolumeClient) Attach(ctx context.Context, volume *hcloud.Volume, server *hcloud.Server) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attach", ctx, volume, server)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Attach indicates an expected call of Attach.
func (mr *MockVolumeClientMockRecorder) Attach(ctx, volume, server any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attach", reflect.TypeOf((*MockVolumeClient)(nil).Attach), ctx, volume, server)
}

// AttachWithOpts mocks base method.
func (m *MockVolumeClient) AttachWithOpts(ctx context.Context, volume *hcloud.Volume, opts hcloud.VolumeAttachOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachWithOpts", ctx, volume, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AttachWithOpts indicates an expected call of AttachWithOpts.
func (mr *MockVolumeClientMockRecorder) AttachWithOpts(ctx, volume, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachWithOpts", reflect.TypeOf((*MockVolumeClient)(nil).AttachWithOpts), ctx, volume, opts)
}

// ChangeProtection mocks base method.
func (m *MockVolumeClient) ChangeProtection(ctx context.Context, volume *hcloud.Volume, opts hcloud.VolumeChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, volume, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockVolumeClientMockRecorder) ChangeProtection(ctx, volume, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockVolumeClient)(nil).ChangeProtection), ctx, volume, opts)
}

// Create mocks base method.
func (m *MockVolumeClient) Create(ctx context.Context, opts hcloud.VolumeCreateOpts) (hcloud.VolumeCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.VolumeCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockVolumeClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockVolumeClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockVolumeClient) Delete(ctx context.Context, volume *hcloud.Volume) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, volume)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockVolumeClientMockRecorder) Delete(ctx, volume any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockVolumeClient)(nil).Delete), ctx, volume)
}

// Detach mocks base method.
func (m *MockVolumeClient) Detach(ctx context.Context, volume *hcloud.Volume) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Detach", ctx, volume)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Detach indicates an expected call of Detach.
func (mr *MockVolumeClientMockRecorder) Detach(ctx, volume any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Detach", reflect.TypeOf((*MockVolumeClient)(nil).Detach), ctx, volume)
}

// Get mocks base method.
func (m *MockVolumeClient) Get(ctx context.Context, idOrName string) (*hcloud.Volume, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Volume)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockVolumeClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockVolumeClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockVolumeClient) GetByID(ctx context.Context, id int64) (*hcloud.Volume, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Volume)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockVolumeClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockVolumeClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockVolumeClient) GetByName(ctx context.Context, name string) (*hcloud.Volume, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Volume)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockVolumeClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockVolumeClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockVolumeClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockVolumeClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockVolumeClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockVolumeClient) List(ctx context.Context, opts hcloud.VolumeListOpts) ([]*hcloud.Volume, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Volume)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockVolumeClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockVolumeClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockVolumeClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockVolumeClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockVolumeClient)(nil).Names))
}

// Resize mocks base method.
func (m *MockVolumeClient) Resize(ctx context.Context, volume *hcloud.Volume, size int) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resize", ctx, volume, size)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Resize indicates an expected call of Resize.
func (mr *MockVolumeClientMockRecorder) Resize(ctx, volume, size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resize", reflect.TypeOf((*MockVolumeClient)(nil).Resize), ctx, volume, size)
}

// Update mocks base method.
func (m *MockVolumeClient) Update(ctx context.Context, volume *hcloud.Volume, opts hcloud.VolumeUpdateOpts) (*hcloud.Volume, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, volume, opts)
	ret0, _ := ret[0].(*hcloud.Volume)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockVolumeClientMockRecorder) Update(ctx, volume, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockVolumeClient)(nil).Update), ctx, volume, opts)
}

// MockPlacementGroupClient is a mock of PlacementGroupClient interface.
type MockPlacementGroupClient struct {
	ctrl     *gomock.Controller
	recorder *MockPlacementGroupClientMockRecorder
	isgomock struct{}
}

// MockPlacementGroupClientMockRecorder is the mock recorder for MockPlacementGroupClient.
type MockPlacementGroupClientMockRecorder struct {
	mock *MockPlacementGroupClient
}

// NewMockPlacementGroupClient creates a new mock instance.
func NewMockPlacementGroupClient(ctrl *gomock.Controller) *MockPlacementGroupClient {
	mock := &MockPlacementGroupClient{ctrl: ctrl}
	mock.recorder = &MockPlacementGroupClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPlacementGroupClient) EXPECT() *MockPlacementGroupClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockPlacementGroupClient) All(ctx context.Context) ([]*hcloud.PlacementGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.PlacementGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockPlacementGroupClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockPlacementGroupClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockPlacementGroupClient) AllWithOpts(ctx context.Context, opts hcloud.PlacementGroupListOpts) ([]*hcloud.PlacementGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.PlacementGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockPlacementGroupClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockPlacementGroupClient)(nil).AllWithOpts), ctx, opts)
}

// Create mocks base method.
func (m *MockPlacementGroupClient) Create(ctx context.Context, opts hcloud.PlacementGroupCreateOpts) (hcloud.PlacementGroupCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.PlacementGroupCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockPlacementGroupClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPlacementGroupClient)(nil).Create), ctx, opts)
}

// Delete mocks base method.
func (m *MockPlacementGroupClient) Delete(ctx context.Context, placementGroup *hcloud.PlacementGroup) (*hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, placementGroup)
	ret0, _ := ret[0].(*hcloud.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Delete indicates an expected call of Delete.
func (mr *MockPlacementGroupClientMockRecorder) Delete(ctx, placementGroup any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPlacementGroupClient)(nil).Delete), ctx, placementGroup)
}

// Get mocks base method.
func (m *MockPlacementGroupClient) Get(ctx context.Context, idOrName string) (*hcloud.PlacementGroup, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.PlacementGroup)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockPlacementGroupClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPlacementGroupClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockPlacementGroupClient) GetByID(ctx context.Context, id int64) (*hcloud.PlacementGroup, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.PlacementGroup)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockPlacementGroupClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockPlacementGroupClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockPlacementGroupClient) GetByName(ctx context.Context, name string) (*hcloud.PlacementGroup, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.PlacementGroup)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockPlacementGroupClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockPlacementGroupClient)(nil).GetByName), ctx, name)
}

// LabelKeys mocks base method.
func (m *MockPlacementGroupClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockPlacementGroupClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockPlacementGroupClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockPlacementGroupClient) List(ctx context.Context, opts hcloud.PlacementGroupListOpts) ([]*hcloud.PlacementGroup, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.PlacementGroup)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockPlacementGroupClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPlacementGroupClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockPlacementGroupClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockPlacementGroupClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockPlacementGroupClient)(nil).Names))
}

// Update mocks base method.
func (m *MockPlacementGroupClient) Update(ctx context.Context, placementGroup *hcloud.PlacementGroup, opts hcloud.PlacementGroupUpdateOpts) (*hcloud.PlacementGroup, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, placementGroup, opts)
	ret0, _ := ret[0].(*hcloud.PlacementGroup)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockPlacementGroupClientMockRecorder) Update(ctx, placementGroup, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockPlacementGroupClient)(nil).Update), ctx, placementGroup, opts)
}

// MockRDNSClient is a mock of RDNSClient interface.
type MockRDNSClient struct {
	ctrl     *gomock.Controller
	recorder *MockRDNSClientMockRecorder
	isgomock struct{}
}

// MockRDNSClientMockRecorder is the mock recorder for MockRDNSClient.
type MockRDNSClientMockRecorder struct {
	mock *MockRDNSClient
}

// NewMockRDNSClient creates a new mock instance.
func NewMockRDNSClient(ctrl *gomock.Controller) *MockRDNSClient {
	mock := &MockRDNSClient{ctrl: ctrl}
	mock.recorder = &MockRDNSClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRDNSClient) EXPECT() *MockRDNSClientMockRecorder {
	return m.recorder
}

// ChangeDNSPtr mocks base method.
func (m *MockRDNSClient) ChangeDNSPtr(ctx context.Context, rdns hcloud.RDNSSupporter, ip net.IP, ptr *string) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeDNSPtr", ctx, rdns, ip, ptr)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeDNSPtr indicates an expected call of ChangeDNSPtr.
func (mr *MockRDNSClientMockRecorder) ChangeDNSPtr(ctx, rdns, ip, ptr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDNSPtr", reflect.TypeOf((*MockRDNSClient)(nil).ChangeDNSPtr), ctx, rdns, ip, ptr)
}

// MockPricingClient is a mock of PricingClient interface.
type MockPricingClient struct {
	ctrl     *gomock.Controller
	recorder *MockPricingClientMockRecorder
	isgomock struct{}
}

// MockPricingClientMockRecorder is the mock recorder for MockPricingClient.
type MockPricingClientMockRecorder struct {
	mock *MockPricingClient
}

// NewMockPricingClient creates a new mock instance.
func NewMockPricingClient(ctrl *gomock.Controller) *MockPricingClient {
	mock := &MockPricingClient{ctrl: ctrl}
	mock.recorder = &MockPricingClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPricingClient) EXPECT() *MockPricingClientMockRecorder {
	return m.recorder
}

// Get mocks base method.
func (m *MockPricingClient) Get(ctx context.Context) (hcloud.Pricing, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx)
	ret0, _ := ret[0].(hcloud.Pricing)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockPricingClientMockRecorder) Get(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPricingClient)(nil).Get), ctx)
}

// MockStorageBoxClient is a mock of StorageBoxClient interface.
type MockStorageBoxClient struct {
	ctrl     *gomock.Controller
	recorder *MockStorageBoxClientMockRecorder
	isgomock struct{}
}

// MockStorageBoxClientMockRecorder is the mock recorder for MockStorageBoxClient.
type MockStorageBoxClientMockRecorder struct {
	mock *MockStorageBoxClient
}

// NewMockStorageBoxClient creates a new mock instance.
func NewMockStorageBoxClient(ctrl *gomock.Controller) *MockStorageBoxClient {
	mock := &MockStorageBoxClient{ctrl: ctrl}
	mock.recorder = &MockStorageBoxClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStorageBoxClient) EXPECT() *MockStorageBoxClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockStorageBoxClient) All(ctx context.Context) ([]*hcloud.StorageBox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.StorageBox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockStorageBoxClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockStorageBoxClient)(nil).All), ctx)
}

// AllSnapshots mocks base method.
func (m *MockStorageBoxClient) AllSnapshots(ctx context.Context, storageBox *hcloud.StorageBox) ([]*hcloud.StorageBoxSnapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSnapshots", ctx, storageBox)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSnapshots indicates an expected call of AllSnapshots.
func (mr *MockStorageBoxClientMockRecorder) AllSnapshots(ctx, storageBox any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSnapshots", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSnapshots), ctx, storageBox)
}

// AllSnapshotsWithOpts mocks base method.
func (m *MockStorageBoxClient) AllSnapshotsWithOpts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotListOpts) ([]*hcloud.StorageBoxSnapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSnapshotsWithOpts", ctx, storageBox, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSnapshotsWithOpts indicates an expected call of AllSnapshotsWithOpts.
func (mr *MockStorageBoxClientMockRecorder) AllSnapshotsWithOpts(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSnapshotsWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSnapshotsWithOpts), ctx, storageBox, opts)
}

// AllSubaccounts mocks base method.
func (m *MockStorageBoxClient) AllSubaccounts(ctx context.Context, storageBox *hcloud.StorageBox) ([]*hcloud.StorageBoxSubaccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSubaccounts", ctx, storageBox)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSubaccounts indicates an expected call of AllSubaccounts.
func (mr *MockStorageBoxClientMockRecorder) AllSubaccounts(ctx, storageBox any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSubaccounts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSubaccounts), ctx, storageBox)
}

// AllSubaccountsWithOpts mocks base method.
func (m *MockStorageBoxClient) AllSubaccountsWithOpts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountListOpts) ([]*hcloud.StorageBoxSubaccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllSubaccountsWithOpts", ctx, storageBox, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllSubaccountsWithOpts indicates an expected call of AllSubaccountsWithOpts.
func (mr *MockStorageBoxClientMockRecorder) AllSubaccountsWithOpts(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllSubaccountsWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllSubaccountsWithOpts), ctx, storageBox, opts)
}

// AllWithOpts mocks base method.
func (m *MockStorageBoxClient) AllWithOpts(ctx context.Context, opts hcloud.StorageBoxListOpts) ([]*hcloud.StorageBox, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBox)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockStorageBoxClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockStorageBoxClient)(nil).AllWithOpts), ctx, opts)
}

// ChangeProtection mocks base method.
func (m *MockStorageBoxClient) ChangeProtection(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockStorageBoxClientMockRecorder) ChangeProtection(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockStorageBoxClient)(nil).ChangeProtection), ctx, storageBox, opts)
}

// ChangeSubaccountHomeDirectory mocks base method.
func (m *MockStorageBoxClient) ChangeSubaccountHomeDirectory(ctx context.Context, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountChangeHomeDirectoryOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeSubaccountHomeDirectory", ctx, subaccount, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeSubaccountHomeDirectory indicates an expected call of ChangeSubaccountHomeDirectory.
func (mr *MockStorageBoxClientMockRecorder) ChangeSubaccountHomeDirectory(ctx, subaccount, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeSubaccountHomeDirectory", reflect.TypeOf((*MockStorageBoxClient)(nil).ChangeSubaccountHomeDirectory), ctx, subaccount, opts)
}

// ChangeType mocks base method.
func (m *MockStorageBoxClient) ChangeType(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxChangeTypeOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeType", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeType indicates an expected call of ChangeType.
func (mr *MockStorageBoxClientMockRecorder) ChangeType(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeType", reflect.TypeOf((*MockStorageBoxClient)(nil).ChangeType), ctx, storageBox, opts)
}

// Create mocks base method.
func (m *MockStorageBoxClient) Create(ctx context.Context, opts hcloud.StorageBoxCreateOpts) (hcloud.StorageBoxCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.StorageBoxCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockStorageBoxClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockStorageBoxClient)(nil).Create), ctx, opts)
}

// CreateSnapshot mocks base method.
func (m *MockStorageBoxClient) CreateSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotCreateOpts) (hcloud.StorageBoxSnapshotCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSnapshot", ctx, storageBox, opts)
	ret0, _ := ret[0].(hcloud.StorageBoxSnapshotCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateSnapshot indicates an expected call of CreateSnapshot.
func (mr *MockStorageBoxClientMockRecorder) CreateSnapshot(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).CreateSnapshot), ctx, storageBox, opts)
}

// CreateSubaccount mocks base method.
func (m *MockStorageBoxClient) CreateSubaccount(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountCreateOpts) (hcloud.StorageBoxSubaccountCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSubaccount", ctx, storageBox, opts)
	ret0, _ := ret[0].(hcloud.StorageBoxSubaccountCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateSubaccount indicates an expected call of CreateSubaccount.
func (mr *MockStorageBoxClientMockRecorder) CreateSubaccount(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).CreateSubaccount), ctx, storageBox, opts)
}

// Delete mocks base method.
func (m *MockStorageBoxClient) Delete(ctx context.Context, storageBox *hcloud.StorageBox) (hcloud.StorageBoxDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, storageBox)
	ret0, _ := ret[0].(hcloud.StorageBoxDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Delete indicates an expected call of Delete.
func (mr *MockStorageBoxClientMockRecorder) Delete(ctx, storageBox any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockStorageBoxClient)(nil).Delete), ctx, storageBox)
}

// DeleteSnapshot mocks base method.
func (m *MockStorageBoxClient) DeleteSnapshot(ctx context.Context, snapshot *hcloud.StorageBoxSnapshot) (hcloud.StorageBoxSnapshotDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSnapshot", ctx, snapshot)
	ret0, _ := ret[0].(hcloud.StorageBoxSnapshotDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteSnapshot indicates an expected call of DeleteSnapshot.
func (mr *MockStorageBoxClientMockRecorder) DeleteSnapshot(ctx, snapshot any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).DeleteSnapshot), ctx, snapshot)
}

// DeleteSubaccount mocks base method.
func (m *MockStorageBoxClient) DeleteSubaccount(ctx context.Context, subaccount *hcloud.StorageBoxSubaccount) (hcloud.StorageBoxSubaccountDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSubaccount", ctx, subaccount)
	ret0, _ := ret[0].(hcloud.StorageBoxSubaccountDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteSubaccount indicates an expected call of DeleteSubaccount.
func (mr *MockStorageBoxClientMockRecorder) DeleteSubaccount(ctx, subaccount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).DeleteSubaccount), ctx, subaccount)
}

// DisableSnapshotPlan mocks base method.
func (m *MockStorageBoxClient) DisableSnapshotPlan(ctx context.Context, storageBox *hcloud.StorageBox) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableSnapshotPlan", ctx, storageBox)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DisableSnapshotPlan indicates an expected call of DisableSnapshotPlan.
func (mr *MockStorageBoxClientMockRecorder) DisableSnapshotPlan(ctx, storageBox any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotPlan", reflect.TypeOf((*MockStorageBoxClient)(nil).DisableSnapshotPlan), ctx, storageBox)
}

// EnableSnapshotPlan mocks base method.
func (m *MockStorageBoxClient) EnableSnapshotPlan(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxEnableSnapshotPlanOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableSnapshotPlan", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// EnableSnapshotPlan indicates an expected call of EnableSnapshotPlan.
func (mr *MockStorageBoxClientMockRecorder) EnableSnapshotPlan(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotPlan", reflect.TypeOf((*MockStorageBoxClient)(nil).EnableSnapshotPlan), ctx, storageBox, opts)
}

// Folders mocks base method.
func (m *MockStorageBoxClient) Folders(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxFoldersOpts) (hcloud.StorageBoxFoldersResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Folders", ctx, storageBox, opts)
	ret0, _ := ret[0].(hcloud.StorageBoxFoldersResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Folders indicates an expected call of Folders.
func (mr *MockStorageBoxClientMockRecorder) Folders(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Folders", reflect.TypeOf((*MockStorageBoxClient)(nil).Folders), ctx, storageBox, opts)
}

// Get mocks base method.
func (m *MockStorageBoxClient) Get(ctx context.Context, idOrName string) (*hcloud.StorageBox, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.StorageBox)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockStorageBoxClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStorageBoxClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockStorageBoxClient) GetByID(ctx context.Context, id int64) (*hcloud.StorageBox, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.StorageBox)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockStorageBoxClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockStorageBoxClient) GetByName(ctx context.Context, name string) (*hcloud.StorageBox, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.StorageBox)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockStorageBoxClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockStorageBoxClient)(nil).GetByName), ctx, name)
}

// GetSnapshot mocks base method.
func (m *MockStorageBoxClient) GetSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, idOrName string) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshot", ctx, storageBox, idOrName)
	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSnapshot indicates an expected call of GetSnapshot.
func (mr *MockStorageBoxClientMockRecorder) GetSnapshot(ctx, storageBox, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshot), ctx, storageBox, idOrName)
}

// GetSnapshotByID mocks base method.
func (m *MockStorageBoxClient) GetSnapshotByID(ctx context.Context, storageBox *hcloud.StorageBox, id int64) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshotByID", ctx, storageBox, id)
	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSnapshotByID indicates an expected call of GetSnapshotByID.
func (mr *MockStorageBoxClientMockRecorder) GetSnapshotByID(ctx, storageBox, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshotByID), ctx, storageBox, id)
}

// GetSnapshotByName mocks base method.
func (m *MockStorageBoxClient) GetSnapshotByName(ctx context.Context, storageBox *hcloud.StorageBox, name string) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSnapshotByName", ctx, storageBox, name)
	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSnapshotByName indicates an expected call of GetSnapshotByName.
func (mr *MockStorageBoxClientMockRecorder) GetSnapshotByName(ctx, storageBox, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotByName", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSnapshotByName), ctx, storageBox, name)
}

// GetSubaccount mocks base method.
func (m *MockStorageBoxClient) GetSubaccount(ctx context.Context, storageBox *hcloud.StorageBox, idOrName string) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubaccount", ctx, storageBox, idOrName)
	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSubaccount indicates an expected call of GetSubaccount.
func (mr *MockStorageBoxClientMockRecorder) GetSubaccount(ctx, storageBox, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSubaccount), ctx, storageBox, idOrName)
}

// GetSubaccountByID mocks base method.
func (m *MockStorageBoxClient) GetSubaccountByID(ctx context.Context, storageBox *hcloud.StorageBox, id int64) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubaccountByID", ctx, storageBox, id)
	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSubaccountByID indicates an expected call of GetSubaccountByID.
func (mr *MockStorageBoxClientMockRecorder) GetSubaccountByID(ctx, storageBox, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubaccountByID", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSubaccountByID), ctx, storageBox, id)
}

// GetSubaccountByName mocks base method.
func (m *MockStorageBoxClient) GetSubaccountByName(ctx context.Context, storageBox *hcloud.StorageBox, name string) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubaccountByName", ctx, storageBox, name)
	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSubaccountByName indicates an expected call of GetSubaccountByName.
func (mr *MockStorageBoxClientMockRecorder) GetSubaccountByName(ctx, storageBox, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubaccountByName", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSubaccountByName), ctx, storageBox, name)
}

// GetSubaccountByUsername mocks base method.
func (m *MockStorageBoxClient) GetSubaccountByUsername(ctx context.Context, storageBox *hcloud.StorageBox, username string) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubaccountByUsername", ctx, storageBox, username)
	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetSubaccountByUsername indicates an expected call of GetSubaccountByUsername.
func (mr *MockStorageBoxClientMockRecorder) GetSubaccountByUsername(ctx, storageBox, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubaccountByUsername", reflect.TypeOf((*MockStorageBoxClient)(nil).GetSubaccountByUsername), ctx, storageBox, username)
}

// LabelKeys mocks base method.
func (m *MockStorageBoxClient) LabelKeys(arg0 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", arg0)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockStorageBoxClientMockRecorder) LabelKeys(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockStorageBoxClient)(nil).LabelKeys), arg0)
}

// List mocks base method.
func (m *MockStorageBoxClient) List(ctx context.Context, opts hcloud.StorageBoxListOpts) ([]*hcloud.StorageBox, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBox)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockStorageBoxClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStorageBoxClient)(nil).List), ctx, opts)
}

// ListSnapshots mocks base method.
func (m *MockStorageBoxClient) ListSnapshots(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSnapshotListOpts) ([]*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSnapshots", ctx, storageBox, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListSnapshots indicates an expected call of ListSnapshots.
func (mr *MockStorageBoxClientMockRecorder) ListSnapshots(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshots", reflect.TypeOf((*MockStorageBoxClient)(nil).ListSnapshots), ctx, storageBox, opts)
}

// ListSubaccounts mocks base method.
func (m *MockStorageBoxClient) ListSubaccounts(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxSubaccountListOpts) ([]*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSubaccounts", ctx, storageBox, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListSubaccounts indicates an expected call of ListSubaccounts.
func (mr *MockStorageBoxClientMockRecorder) ListSubaccounts(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSubaccounts", reflect.TypeOf((*MockStorageBoxClient)(nil).ListSubaccounts), ctx, storageBox, opts)
}

// Names mocks base method.
func (m *MockStorageBoxClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockStorageBoxClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockStorageBoxClient)(nil).Names))
}

// ResetPassword mocks base method.
func (m *MockStorageBoxClient) ResetPassword(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxResetPasswordOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetPassword", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetPassword indicates an expected call of ResetPassword.
func (mr *MockStorageBoxClientMockRecorder) ResetPassword(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPassword", reflect.TypeOf((*MockStorageBoxClient)(nil).ResetPassword), ctx, storageBox, opts)
}

// ResetSubaccountPassword mocks base method.
func (m *MockStorageBoxClient) ResetSubaccountPassword(ctx context.Context, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountResetPasswordOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetSubaccountPassword", ctx, subaccount, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ResetSubaccountPassword indicates an expected call of ResetSubaccountPassword.
func (mr *MockStorageBoxClientMockRecorder) ResetSubaccountPassword(ctx, subaccount, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSubaccountPassword", reflect.TypeOf((*MockStorageBoxClient)(nil).ResetSubaccountPassword), ctx, subaccount, opts)
}

// RollbackSnapshot mocks base method.
func (m *MockStorageBoxClient) RollbackSnapshot(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxRollbackSnapshotOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RollbackSnapshot", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RollbackSnapshot indicates an expected call of RollbackSnapshot.
func (mr *MockStorageBoxClientMockRecorder) RollbackSnapshot(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).RollbackSnapshot), ctx, storageBox, opts)
}

// SnapshotLabelKeys mocks base method.
func (m *MockStorageBoxClient) SnapshotLabelKeys(arg0, arg1 string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SnapshotLabelKeys", arg0, arg1)
	ret0, _ := ret[0].([]string)
	return ret0
}

// SnapshotLabelKeys indicates an expected call of SnapshotLabelKeys.
func (mr *MockStorageBoxClientMockRecorder) SnapshotLabelKeys(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotLabelKeys", reflect.TypeOf((*MockStorageBoxClient)(nil).SnapshotLabelKeys), arg0, arg1)
}

// Update mocks base method.
func (m *MockStorageBoxClient) Update(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxUpdateOpts) (*hcloud.StorageBox, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.StorageBox)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockStorageBoxClientMockRecorder) Update(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStorageBoxClient)(nil).Update), ctx, storageBox, opts)
}

// UpdateAccessSettings mocks base method.
func (m *MockStorageBoxClient) UpdateAccessSettings(ctx context.Context, storageBox *hcloud.StorageBox, opts hcloud.StorageBoxUpdateAccessSettingsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccessSettings", ctx, storageBox, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateAccessSettings indicates an expected call of UpdateAccessSettings.
func (mr *MockStorageBoxClientMockRecorder) UpdateAccessSettings(ctx, storageBox, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccessSettings", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateAccessSettings), ctx, storageBox, opts)
}

// UpdateSnapshot mocks base method.
func (m *MockStorageBoxClient) UpdateSnapshot(ctx context.Context, snapshot *hcloud.StorageBoxSnapshot, opts hcloud.StorageBoxSnapshotUpdateOpts) (*hcloud.StorageBoxSnapshot, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSnapshot", ctx, snapshot, opts)
	ret0, _ := ret[0].(*hcloud.StorageBoxSnapshot)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateSnapshot indicates an expected call of UpdateSnapshot.
func (mr *MockStorageBoxClientMockRecorder) UpdateSnapshot(ctx, snapshot, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSnapshot", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSnapshot), ctx, snapshot, opts)
}

// UpdateSubaccount mocks base method.
func (m *MockStorageBoxClient) UpdateSubaccount(ctx context.Context, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountUpdateOpts) (*hcloud.StorageBoxSubaccount, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSubaccount", ctx, subaccount, opts)
	ret0, _ := ret[0].(*hcloud.StorageBoxSubaccount)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateSubaccount indicates an expected call of UpdateSubaccount.
func (mr *MockStorageBoxClientMockRecorder) UpdateSubaccount(ctx, subaccount, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubaccount", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSubaccount), ctx, subaccount, opts)
}

// UpdateSubaccountAccessSettings mocks base method.
func (m *MockStorageBoxClient) UpdateSubaccountAccessSettings(ctx context.Context, subaccount *hcloud.StorageBoxSubaccount, opts hcloud.StorageBoxSubaccountUpdateAccessSettingsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSubaccountAccessSettings", ctx, subaccount, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateSubaccountAccessSettings indicates an expected call of UpdateSubaccountAccessSettings.
func (mr *MockStorageBoxClientMockRecorder) UpdateSubaccountAccessSettings(ctx, subaccount, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubaccountAccessSettings", reflect.TypeOf((*MockStorageBoxClient)(nil).UpdateSubaccountAccessSettings), ctx, subaccount, opts)
}

// MockStorageBoxTypeClient is a mock of StorageBoxTypeClient interface.
type MockStorageBoxTypeClient struct {
	ctrl     *gomock.Controller
	recorder *MockStorageBoxTypeClientMockRecorder
	isgomock struct{}
}

// MockStorageBoxTypeClientMockRecorder is the mock recorder for MockStorageBoxTypeClient.
type MockStorageBoxTypeClientMockRecorder struct {
	mock *MockStorageBoxTypeClient
}

// NewMockStorageBoxTypeClient creates a new mock instance.
func NewMockStorageBoxTypeClient(ctrl *gomock.Controller) *MockStorageBoxTypeClient {
	mock := &MockStorageBoxTypeClient{ctrl: ctrl}
	mock.recorder = &MockStorageBoxTypeClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStorageBoxTypeClient) EXPECT() *MockStorageBoxTypeClientMockRecorder {
	return m.recorder
}

// All mocks base method.
func (m *MockStorageBoxTypeClient) All(ctx context.Context) ([]*hcloud.StorageBoxType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.StorageBoxType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockStorageBoxTypeClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).All), ctx)
}

// AllWithOpts mocks base method.
func (m *MockStorageBoxTypeClient) AllWithOpts(ctx context.Context, opts hcloud.StorageBoxTypeListOpts) ([]*hcloud.StorageBoxType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockStorageBoxTypeClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).AllWithOpts), ctx, opts)
}

// Get mocks base method.
func (m *MockStorageBoxTypeClient) Get(ctx context.Context, idOrName string) (*hcloud.StorageBoxType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.StorageBoxType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockStorageBoxTypeClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockStorageBoxTypeClient) GetByID(ctx context.Context, id int64) (*hcloud.StorageBoxType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.StorageBoxType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockStorageBoxTypeClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockStorageBoxTypeClient) GetByName(ctx context.Context, name string) (*hcloud.StorageBoxType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.StorageBoxType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockStorageBoxTypeClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).GetByName), ctx, name)
}

// List mocks base method.
func (m *MockStorageBoxTypeClient) List(ctx context.Context, opts hcloud.StorageBoxTypeListOpts) ([]*hcloud.StorageBoxType, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.StorageBoxType)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockStorageBoxTypeClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).List), ctx, opts)
}

// Names mocks base method.
func (m *MockStorageBoxTypeClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockStorageBoxTypeClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockStorageBoxTypeClient)(nil).Names))
}

// MockZoneClient is a mock of ZoneClient interface.
type MockZoneClient struct {
	ctrl     *gomock.Controller
	recorder *MockZoneClientMockRecorder
	isgomock struct{}
}

// MockZoneClientMockRecorder is the mock recorder for MockZoneClient.
type MockZoneClientMockRecorder struct {
	mock *MockZoneClient
}

// NewMockZoneClient creates a new mock instance.
func NewMockZoneClient(ctrl *gomock.Controller) *MockZoneClient {
	mock := &MockZoneClient{ctrl: ctrl}
	mock.recorder = &MockZoneClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockZoneClient) EXPECT() *MockZoneClientMockRecorder {
	return m.recorder
}

// AddRRSetRecords mocks base method.
func (m *MockZoneClient) AddRRSetRecords(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetAddRecordsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRRSetRecords", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddRRSetRecords indicates an expected call of AddRRSetRecords.
func (mr *MockZoneClientMockRecorder) AddRRSetRecords(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRRSetRecords", reflect.TypeOf((*MockZoneClient)(nil).AddRRSetRecords), ctx, rrset, opts)
}

// All mocks base method.
func (m *MockZoneClient) All(ctx context.Context) ([]*hcloud.Zone, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx)
	ret0, _ := ret[0].([]*hcloud.Zone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// All indicates an expected call of All.
func (mr *MockZoneClientMockRecorder) All(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockZoneClient)(nil).All), ctx)
}

// AllRRSets mocks base method.
func (m *MockZoneClient) AllRRSets(ctx context.Context, zone *hcloud.Zone) ([]*hcloud.ZoneRRSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllRRSets", ctx, zone)
	ret0, _ := ret[0].([]*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllRRSets indicates an expected call of AllRRSets.
func (mr *MockZoneClientMockRecorder) AllRRSets(ctx, zone any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllRRSets", reflect.TypeOf((*MockZoneClient)(nil).AllRRSets), ctx, zone)
}

// AllRRSetsWithOpts mocks base method.
func (m *MockZoneClient) AllRRSetsWithOpts(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneRRSetListOpts) ([]*hcloud.ZoneRRSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllRRSetsWithOpts", ctx, zone, opts)
	ret0, _ := ret[0].([]*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllRRSetsWithOpts indicates an expected call of AllRRSetsWithOpts.
func (mr *MockZoneClientMockRecorder) AllRRSetsWithOpts(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllRRSetsWithOpts", reflect.TypeOf((*MockZoneClient)(nil).AllRRSetsWithOpts), ctx, zone, opts)
}

// AllWithOpts mocks base method.
func (m *MockZoneClient) AllWithOpts(ctx context.Context, opts hcloud.ZoneListOpts) ([]*hcloud.Zone, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllWithOpts", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Zone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllWithOpts indicates an expected call of AllWithOpts.
func (mr *MockZoneClientMockRecorder) AllWithOpts(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllWithOpts", reflect.TypeOf((*MockZoneClient)(nil).AllWithOpts), ctx, opts)
}

// ChangePrimaryNameservers mocks base method.
func (m *MockZoneClient) ChangePrimaryNameservers(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneChangePrimaryNameserversOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangePrimaryNameservers", ctx, zone, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangePrimaryNameservers indicates an expected call of ChangePrimaryNameservers.
func (mr *MockZoneClientMockRecorder) ChangePrimaryNameservers(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePrimaryNameservers", reflect.TypeOf((*MockZoneClient)(nil).ChangePrimaryNameservers), ctx, zone, opts)
}

// ChangeProtection mocks base method.
func (m *MockZoneClient) ChangeProtection(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeProtection", ctx, zone, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeProtection indicates an expected call of ChangeProtection.
func (mr *MockZoneClientMockRecorder) ChangeProtection(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProtection", reflect.TypeOf((*MockZoneClient)(nil).ChangeProtection), ctx, zone, opts)
}

// ChangeRRSetProtection mocks base method.
func (m *MockZoneClient) ChangeRRSetProtection(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetChangeProtectionOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeRRSetProtection", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeRRSetProtection indicates an expected call of ChangeRRSetProtection.
func (mr *MockZoneClientMockRecorder) ChangeRRSetProtection(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeRRSetProtection", reflect.TypeOf((*MockZoneClient)(nil).ChangeRRSetProtection), ctx, rrset, opts)
}

// ChangeRRSetTTL mocks base method.
func (m *MockZoneClient) ChangeRRSetTTL(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetChangeTTLOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeRRSetTTL", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeRRSetTTL indicates an expected call of ChangeRRSetTTL.
func (mr *MockZoneClientMockRecorder) ChangeRRSetTTL(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeRRSetTTL", reflect.TypeOf((*MockZoneClient)(nil).ChangeRRSetTTL), ctx, rrset, opts)
}

// ChangeTTL mocks base method.
func (m *MockZoneClient) ChangeTTL(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneChangeTTLOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeTTL", ctx, zone, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ChangeTTL indicates an expected call of ChangeTTL.
func (mr *MockZoneClientMockRecorder) ChangeTTL(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTTL", reflect.TypeOf((*MockZoneClient)(nil).ChangeTTL), ctx, zone, opts)
}

// Create mocks base method.
func (m *MockZoneClient) Create(ctx context.Context, opts hcloud.ZoneCreateOpts) (hcloud.ZoneCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, opts)
	ret0, _ := ret[0].(hcloud.ZoneCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Create indicates an expected call of Create.
func (mr *MockZoneClientMockRecorder) Create(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockZoneClient)(nil).Create), ctx, opts)
}

// CreateRRSet mocks base method.
func (m *MockZoneClient) CreateRRSet(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneRRSetCreateOpts) (hcloud.ZoneRRSetCreateResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRRSet", ctx, zone, opts)
	ret0, _ := ret[0].(hcloud.ZoneRRSetCreateResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateRRSet indicates an expected call of CreateRRSet.
func (mr *MockZoneClientMockRecorder) CreateRRSet(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRRSet", reflect.TypeOf((*MockZoneClient)(nil).CreateRRSet), ctx, zone, opts)
}

// Delete mocks base method.
func (m *MockZoneClient) Delete(ctx context.Context, zone *hcloud.Zone) (hcloud.ZoneDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, zone)
	ret0, _ := ret[0].(hcloud.ZoneDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Delete indicates an expected call of Delete.
func (mr *MockZoneClientMockRecorder) Delete(ctx, zone any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockZoneClient)(nil).Delete), ctx, zone)
}

// DeleteRRSet mocks base method.
func (m *MockZoneClient) DeleteRRSet(ctx context.Context, rrset *hcloud.ZoneRRSet) (hcloud.ZoneRRSetDeleteResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRRSet", ctx, rrset)
	ret0, _ := ret[0].(hcloud.ZoneRRSetDeleteResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DeleteRRSet indicates an expected call of DeleteRRSet.
func (mr *MockZoneClientMockRecorder) DeleteRRSet(ctx, rrset any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRRSet", reflect.TypeOf((*MockZoneClient)(nil).DeleteRRSet), ctx, rrset)
}

// ExportZonefile mocks base method.
func (m *MockZoneClient) ExportZonefile(ctx context.Context, zone *hcloud.Zone) (hcloud.ZoneExportZonefileResult, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportZonefile", ctx, zone)
	ret0, _ := ret[0].(hcloud.ZoneExportZonefileResult)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ExportZonefile indicates an expected call of ExportZonefile.
func (mr *MockZoneClientMockRecorder) ExportZonefile(ctx, zone any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportZonefile", reflect.TypeOf((*MockZoneClient)(nil).ExportZonefile), ctx, zone)
}

// Get mocks base method.
func (m *MockZoneClient) Get(ctx context.Context, idOrName string) (*hcloud.Zone, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, idOrName)
	ret0, _ := ret[0].(*hcloud.Zone)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Get indicates an expected call of Get.
func (mr *MockZoneClientMockRecorder) Get(ctx, idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockZoneClient)(nil).Get), ctx, idOrName)
}

// GetByID mocks base method.
func (m *MockZoneClient) GetByID(ctx context.Context, id int64) (*hcloud.Zone, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByID", ctx, id)
	ret0, _ := ret[0].(*hcloud.Zone)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByID indicates an expected call of GetByID.
func (mr *MockZoneClientMockRecorder) GetByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockZoneClient)(nil).GetByID), ctx, id)
}

// GetByName mocks base method.
func (m *MockZoneClient) GetByName(ctx context.Context, name string) (*hcloud.Zone, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByName", ctx, name)
	ret0, _ := ret[0].(*hcloud.Zone)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetByName indicates an expected call of GetByName.
func (mr *MockZoneClientMockRecorder) GetByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByName", reflect.TypeOf((*MockZoneClient)(nil).GetByName), ctx, name)
}

// GetRRSetByID mocks base method.
func (m *MockZoneClient) GetRRSetByID(ctx context.Context, zone *hcloud.Zone, rrsetID string) (*hcloud.ZoneRRSet, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRRSetByID", ctx, zone, rrsetID)
	ret0, _ := ret[0].(*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRRSetByID indicates an expected call of GetRRSetByID.
func (mr *MockZoneClientMockRecorder) GetRRSetByID(ctx, zone, rrsetID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRRSetByID", reflect.TypeOf((*MockZoneClient)(nil).GetRRSetByID), ctx, zone, rrsetID)
}

// GetRRSetByNameAndType mocks base method.
func (m *MockZoneClient) GetRRSetByNameAndType(ctx context.Context, zone *hcloud.Zone, rrsetName string, rrsetType hcloud.ZoneRRSetType) (*hcloud.ZoneRRSet, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRRSetByNameAndType", ctx, zone, rrsetName, rrsetType)
	ret0, _ := ret[0].(*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetRRSetByNameAndType indicates an expected call of GetRRSetByNameAndType.
func (mr *MockZoneClientMockRecorder) GetRRSetByNameAndType(ctx, zone, rrsetName, rrsetType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRRSetByNameAndType", reflect.TypeOf((*MockZoneClient)(nil).GetRRSetByNameAndType), ctx, zone, rrsetName, rrsetType)
}

// ImportZonefile mocks base method.
func (m *MockZoneClient) ImportZonefile(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneImportZonefileOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportZonefile", ctx, zone, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ImportZonefile indicates an expected call of ImportZonefile.
func (mr *MockZoneClientMockRecorder) ImportZonefile(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportZonefile", reflect.TypeOf((*MockZoneClient)(nil).ImportZonefile), ctx, zone, opts)
}

// LabelKeys mocks base method.
func (m *MockZoneClient) LabelKeys(idOrName string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LabelKeys", idOrName)
	ret0, _ := ret[0].([]string)
	return ret0
}

// LabelKeys indicates an expected call of LabelKeys.
func (mr *MockZoneClientMockRecorder) LabelKeys(idOrName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LabelKeys", reflect.TypeOf((*MockZoneClient)(nil).LabelKeys), idOrName)
}

// List mocks base method.
func (m *MockZoneClient) List(ctx context.Context, opts hcloud.ZoneListOpts) ([]*hcloud.Zone, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, opts)
	ret0, _ := ret[0].([]*hcloud.Zone)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// List indicates an expected call of List.
func (mr *MockZoneClientMockRecorder) List(ctx, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockZoneClient)(nil).List), ctx, opts)
}

// ListRRSets mocks base method.
func (m *MockZoneClient) ListRRSets(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneRRSetListOpts) ([]*hcloud.ZoneRRSet, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRRSets", ctx, zone, opts)
	ret0, _ := ret[0].([]*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListRRSets indicates an expected call of ListRRSets.
func (mr *MockZoneClientMockRecorder) ListRRSets(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRRSets", reflect.TypeOf((*MockZoneClient)(nil).ListRRSets), ctx, zone, opts)
}

// Names mocks base method.
func (m *MockZoneClient) Names() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Names")
	ret0, _ := ret[0].([]string)
	return ret0
}

// Names indicates an expected call of Names.
func (mr *MockZoneClientMockRecorder) Names() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Names", reflect.TypeOf((*MockZoneClient)(nil).Names))
}

// RRSetLabelKeys mocks base method.
func (m *MockZoneClient) RRSetLabelKeys(zoneIDOrName, rrsetName string, rrsetType hcloud.ZoneRRSetType) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RRSetLabelKeys", zoneIDOrName, rrsetName, rrsetType)
	ret0, _ := ret[0].([]string)
	return ret0
}

// RRSetLabelKeys indicates an expected call of RRSetLabelKeys.
func (mr *MockZoneClientMockRecorder) RRSetLabelKeys(zoneIDOrName, rrsetName, rrsetType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RRSetLabelKeys", reflect.TypeOf((*MockZoneClient)(nil).RRSetLabelKeys), zoneIDOrName, rrsetName, rrsetType)
}

// RemoveRRSetRecords mocks base method.
func (m *MockZoneClient) RemoveRRSetRecords(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetRemoveRecordsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveRRSetRecords", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RemoveRRSetRecords indicates an expected call of RemoveRRSetRecords.
func (mr *MockZoneClientMockRecorder) RemoveRRSetRecords(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRRSetRecords", reflect.TypeOf((*MockZoneClient)(nil).RemoveRRSetRecords), ctx, rrset, opts)
}

// SetRRSetRecords mocks base method.
func (m *MockZoneClient) SetRRSetRecords(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetSetRecordsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRRSetRecords", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SetRRSetRecords indicates an expected call of SetRRSetRecords.
func (mr *MockZoneClientMockRecorder) SetRRSetRecords(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRRSetRecords", reflect.TypeOf((*MockZoneClient)(nil).SetRRSetRecords), ctx, rrset, opts)
}

// Update mocks base method.
func (m *MockZoneClient) Update(ctx context.Context, zone *hcloud.Zone, opts hcloud.ZoneUpdateOpts) (*hcloud.Zone, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, zone, opts)
	ret0, _ := ret[0].(*hcloud.Zone)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Update indicates an expected call of Update.
func (mr *MockZoneClientMockRecorder) Update(ctx, zone, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockZoneClient)(nil).Update), ctx, zone, opts)
}

// UpdateRRSet mocks base method.
func (m *MockZoneClient) UpdateRRSet(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetUpdateOpts) (*hcloud.ZoneRRSet, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRRSet", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.ZoneRRSet)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateRRSet indicates an expected call of UpdateRRSet.
func (mr *MockZoneClientMockRecorder) UpdateRRSet(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRRSet", reflect.TypeOf((*MockZoneClient)(nil).UpdateRRSet), ctx, rrset, opts)
}

// UpdateRRSetRecords mocks base method.
func (m *MockZoneClient) UpdateRRSetRecords(ctx context.Context, rrset *hcloud.ZoneRRSet, opts hcloud.ZoneRRSetUpdateRecordsOpts) (*hcloud.Action, *hcloud.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateRRSetRecords", ctx, rrset, opts)
	ret0, _ := ret[0].(*hcloud.Action)
	ret1, _ := ret[1].(*hcloud.Response)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateRRSetRecords indicates an expected call of UpdateRRSetRecords.
func (mr *MockZoneClientMockRecorder) UpdateRRSetRecords(ctx, rrset, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRRSetRecords", reflect.TypeOf((*MockZoneClient)(nil).UpdateRRSetRecords), ctx, rrset, opts)
}
