client.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloud/scope/client.go
//
// Generated by this command:
//
//	mockgen -source=./cloud/scope/client.go -destination ./mock/client.go -package mock
//

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

import (
	context "context"
	reflect "reflect"

	linodego "github.com/linode/linodego"
	gomock "go.uber.org/mock/gomock"
	meta "k8s.io/apimachinery/pkg/api/meta"
	runtime "k8s.io/apimachinery/pkg/runtime"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockLinodeMachineClient is a mock of LinodeMachineClient interface.
type MockLinodeMachineClient struct {
	ctrl     *gomock.Controller
	recorder *MockLinodeMachineClientMockRecorder
}

// MockLinodeMachineClientMockRecorder is the mock recorder for MockLinodeMachineClient.
type MockLinodeMachineClientMockRecorder struct {
	mock *MockLinodeMachineClient
}

// NewMockLinodeMachineClient creates a new mock instance.
func NewMockLinodeMachineClient(ctrl *gomock.Controller) *MockLinodeMachineClient {
	mock := &MockLinodeMachineClient{ctrl: ctrl}
	mock.recorder = &MockLinodeMachineClientMockRecorder{mock}
	return mock
}

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

// BootInstance mocks base method.
func (m *MockLinodeMachineClient) BootInstance(ctx context.Context, linodeID, configID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BootInstance", ctx, linodeID, configID)
	ret0, _ := ret[0].(error)
	return ret0
}

// BootInstance indicates an expected call of BootInstance.
func (mr *MockLinodeMachineClientMockRecorder) BootInstance(ctx, linodeID, configID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootInstance", reflect.TypeOf((*MockLinodeMachineClient)(nil).BootInstance), ctx, linodeID, configID)
}

// CreateInstance mocks base method.
func (m *MockLinodeMachineClient) CreateInstance(ctx context.Context, opts linodego.InstanceCreateOptions) (*linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstance", ctx, opts)
	ret0, _ := ret[0].(*linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInstanceDisk mocks base method.
func (m *MockLinodeMachineClient) CreateInstanceDisk(ctx context.Context, linodeID int, opts linodego.InstanceDiskCreateOptions) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceDisk", ctx, linodeID, opts)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodeBalancer mocks base method.
func (m *MockLinodeMachineClient) CreateNodeBalancer(ctx context.Context, opts linodego.NodeBalancerCreateOptions) (*linodego.NodeBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancer", ctx, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodeBalancerConfig mocks base method.
func (m *MockLinodeMachineClient) CreateNodeBalancerConfig(ctx context.Context, nodebalancerID int, opts linodego.NodeBalancerConfigCreateOptions) (*linodego.NodeBalancerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancerConfig", ctx, nodebalancerID, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodeBalancerNode mocks base method.
func (m *MockLinodeMachineClient) CreateNodeBalancerNode(ctx context.Context, nodebalancerID, configID int, opts linodego.NodeBalancerNodeCreateOptions) (*linodego.NodeBalancerNode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancerNode", ctx, nodebalancerID, configID, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancerNode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNodeBalancerNode indicates an expected call of CreateNodeBalancerNode.
func (mr *MockLinodeMachineClientMockRecorder) CreateNodeBalancerNode(ctx, nodebalancerID, configID, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNodeBalancerNode", reflect.TypeOf((*MockLinodeMachineClient)(nil).CreateNodeBalancerNode), ctx, nodebalancerID, configID, opts)
}

// CreateStackscript mocks base method.
func (m *MockLinodeMachineClient) CreateStackscript(ctx context.Context, opts linodego.StackscriptCreateOptions) (*linodego.Stackscript, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStackscript", ctx, opts)
	ret0, _ := ret[0].(*linodego.Stackscript)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInstance mocks base method.
func (m *MockLinodeMachineClient) DeleteInstance(ctx context.Context, linodeID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstance", ctx, linodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteNodeBalancer mocks base method.
func (m *MockLinodeMachineClient) DeleteNodeBalancer(ctx context.Context, nodebalancerID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodeBalancer", ctx, nodebalancerID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteNodeBalancerNode mocks base method.
func (m *MockLinodeMachineClient) DeleteNodeBalancerNode(ctx context.Context, nodebalancerID, configID, nodeID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodeBalancerNode", ctx, nodebalancerID, configID, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNodeBalancerNode indicates an expected call of DeleteNodeBalancerNode.
func (mr *MockLinodeMachineClientMockRecorder) DeleteNodeBalancerNode(ctx, nodebalancerID, configID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNodeBalancerNode", reflect.TypeOf((*MockLinodeMachineClient)(nil).DeleteNodeBalancerNode), ctx, nodebalancerID, configID, nodeID)
}

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

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

// GetInstance mocks base method.
func (m *MockLinodeMachineClient) GetInstance(ctx context.Context, linodeID int) (*linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance", ctx, linodeID)
	ret0, _ := ret[0].(*linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceDisk mocks base method.
func (m *MockLinodeMachineClient) GetInstanceDisk(ctx context.Context, linodeID, diskID int) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceDisk", ctx, linodeID, diskID)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceDisk indicates an expected call of GetInstanceDisk.
func (mr *MockLinodeMachineClientMockRecorder) GetInstanceDisk(ctx, linodeID, diskID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceDisk", reflect.TypeOf((*MockLinodeMachineClient)(nil).GetInstanceDisk), ctx, linodeID, diskID)
}

// GetInstanceIPAddresses mocks base method.
func (m *MockLinodeMachineClient) GetInstanceIPAddresses(ctx context.Context, linodeID int) (*linodego.InstanceIPAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceIPAddresses", ctx, linodeID)
	ret0, _ := ret[0].(*linodego.InstanceIPAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRegion mocks base method.
func (m *MockLinodeMachineClient) GetRegion(ctx context.Context, regionID string) (*linodego.Region, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegion", ctx, regionID)
	ret0, _ := ret[0].(*linodego.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetVPC mocks base method.
func (m *MockLinodeMachineClient) GetVPC(ctx context.Context, vpcID int) (*linodego.VPC, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVPC", ctx, vpcID)
	ret0, _ := ret[0].(*linodego.VPC)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListInstanceConfigs mocks base method.
func (m *MockLinodeMachineClient) ListInstanceConfigs(ctx context.Context, linodeID int, opts *linodego.ListOptions) ([]linodego.InstanceConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInstanceConfigs", ctx, linodeID, opts)
	ret0, _ := ret[0].([]linodego.InstanceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListInstances mocks base method.
func (m *MockLinodeMachineClient) ListInstances(ctx context.Context, opts *linodego.ListOptions) ([]linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInstances", ctx, opts)
	ret0, _ := ret[0].([]linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNodeBalancers mocks base method.
func (m *MockLinodeMachineClient) ListNodeBalancers(ctx context.Context, opts *linodego.ListOptions) ([]linodego.NodeBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeBalancers", ctx, opts)
	ret0, _ := ret[0].([]linodego.NodeBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStackscripts mocks base method.
func (m *MockLinodeMachineClient) ListStackscripts(ctx context.Context, opts *linodego.ListOptions) ([]linodego.Stackscript, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStackscripts", ctx, opts)
	ret0, _ := ret[0].([]linodego.Stackscript)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResizeInstanceDisk mocks base method.
func (m *MockLinodeMachineClient) ResizeInstanceDisk(ctx context.Context, linodeID, diskID, size int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResizeInstanceDisk", ctx, linodeID, diskID, size)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResizeInstanceDisk indicates an expected call of ResizeInstanceDisk.
func (mr *MockLinodeMachineClientMockRecorder) ResizeInstanceDisk(ctx, linodeID, diskID, size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeInstanceDisk", reflect.TypeOf((*MockLinodeMachineClient)(nil).ResizeInstanceDisk), ctx, linodeID, diskID, size)
}

// UpdateInstanceConfig mocks base method.
func (m *MockLinodeMachineClient) UpdateInstanceConfig(ctx context.Context, linodeID, configID int, opts linodego.InstanceConfigUpdateOptions) (*linodego.InstanceConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInstanceConfig", ctx, linodeID, configID, opts)
	ret0, _ := ret[0].(*linodego.InstanceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInstanceConfig indicates an expected call of UpdateInstanceConfig.
func (mr *MockLinodeMachineClientMockRecorder) UpdateInstanceConfig(ctx, linodeID, configID, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInstanceConfig", reflect.TypeOf((*MockLinodeMachineClient)(nil).UpdateInstanceConfig), ctx, linodeID, configID, opts)
}

// WaitForInstanceDiskStatus mocks base method.
func (m *MockLinodeMachineClient) WaitForInstanceDiskStatus(ctx context.Context, instanceID, diskID int, status linodego.DiskStatus, timeoutSeconds int) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForInstanceDiskStatus", ctx, instanceID, diskID, status, timeoutSeconds)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitForInstanceDiskStatus indicates an expected call of WaitForInstanceDiskStatus.
func (mr *MockLinodeMachineClientMockRecorder) WaitForInstanceDiskStatus(ctx, instanceID, diskID, status, timeoutSeconds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForInstanceDiskStatus", reflect.TypeOf((*MockLinodeMachineClient)(nil).WaitForInstanceDiskStatus), ctx, instanceID, diskID, status, timeoutSeconds)
}

// MockLinodeInstanceClient is a mock of LinodeInstanceClient interface.
type MockLinodeInstanceClient struct {
	ctrl     *gomock.Controller
	recorder *MockLinodeInstanceClientMockRecorder
}

// MockLinodeInstanceClientMockRecorder is the mock recorder for MockLinodeInstanceClient.
type MockLinodeInstanceClientMockRecorder struct {
	mock *MockLinodeInstanceClient
}

// NewMockLinodeInstanceClient creates a new mock instance.
func NewMockLinodeInstanceClient(ctrl *gomock.Controller) *MockLinodeInstanceClient {
	mock := &MockLinodeInstanceClient{ctrl: ctrl}
	mock.recorder = &MockLinodeInstanceClientMockRecorder{mock}
	return mock
}

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

// BootInstance mocks base method.
func (m *MockLinodeInstanceClient) BootInstance(ctx context.Context, linodeID, configID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BootInstance", ctx, linodeID, configID)
	ret0, _ := ret[0].(error)
	return ret0
}

// BootInstance indicates an expected call of BootInstance.
func (mr *MockLinodeInstanceClientMockRecorder) BootInstance(ctx, linodeID, configID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BootInstance", reflect.TypeOf((*MockLinodeInstanceClient)(nil).BootInstance), ctx, linodeID, configID)
}

// CreateInstance mocks base method.
func (m *MockLinodeInstanceClient) CreateInstance(ctx context.Context, opts linodego.InstanceCreateOptions) (*linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstance", ctx, opts)
	ret0, _ := ret[0].(*linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateInstanceDisk mocks base method.
func (m *MockLinodeInstanceClient) CreateInstanceDisk(ctx context.Context, linodeID int, opts linodego.InstanceDiskCreateOptions) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstanceDisk", ctx, linodeID, opts)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStackscript mocks base method.
func (m *MockLinodeInstanceClient) CreateStackscript(ctx context.Context, opts linodego.StackscriptCreateOptions) (*linodego.Stackscript, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStackscript", ctx, opts)
	ret0, _ := ret[0].(*linodego.Stackscript)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteInstance mocks base method.
func (m *MockLinodeInstanceClient) DeleteInstance(ctx context.Context, linodeID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstance", ctx, linodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// GetInstance mocks base method.
func (m *MockLinodeInstanceClient) GetInstance(ctx context.Context, linodeID int) (*linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance", ctx, linodeID)
	ret0, _ := ret[0].(*linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInstanceDisk mocks base method.
func (m *MockLinodeInstanceClient) GetInstanceDisk(ctx context.Context, linodeID, diskID int) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceDisk", ctx, linodeID, diskID)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInstanceDisk indicates an expected call of GetInstanceDisk.
func (mr *MockLinodeInstanceClientMockRecorder) GetInstanceDisk(ctx, linodeID, diskID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceDisk", reflect.TypeOf((*MockLinodeInstanceClient)(nil).GetInstanceDisk), ctx, linodeID, diskID)
}

// GetInstanceIPAddresses mocks base method.
func (m *MockLinodeInstanceClient) GetInstanceIPAddresses(ctx context.Context, linodeID int) (*linodego.InstanceIPAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceIPAddresses", ctx, linodeID)
	ret0, _ := ret[0].(*linodego.InstanceIPAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRegion mocks base method.
func (m *MockLinodeInstanceClient) GetRegion(ctx context.Context, regionID string) (*linodego.Region, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegion", ctx, regionID)
	ret0, _ := ret[0].(*linodego.Region)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListInstanceConfigs mocks base method.
func (m *MockLinodeInstanceClient) ListInstanceConfigs(ctx context.Context, linodeID int, opts *linodego.ListOptions) ([]linodego.InstanceConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInstanceConfigs", ctx, linodeID, opts)
	ret0, _ := ret[0].([]linodego.InstanceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListInstances mocks base method.
func (m *MockLinodeInstanceClient) ListInstances(ctx context.Context, opts *linodego.ListOptions) ([]linodego.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListInstances", ctx, opts)
	ret0, _ := ret[0].([]linodego.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStackscripts mocks base method.
func (m *MockLinodeInstanceClient) ListStackscripts(ctx context.Context, opts *linodego.ListOptions) ([]linodego.Stackscript, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStackscripts", ctx, opts)
	ret0, _ := ret[0].([]linodego.Stackscript)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResizeInstanceDisk mocks base method.
func (m *MockLinodeInstanceClient) ResizeInstanceDisk(ctx context.Context, linodeID, diskID, size int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResizeInstanceDisk", ctx, linodeID, diskID, size)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResizeInstanceDisk indicates an expected call of ResizeInstanceDisk.
func (mr *MockLinodeInstanceClientMockRecorder) ResizeInstanceDisk(ctx, linodeID, diskID, size any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeInstanceDisk", reflect.TypeOf((*MockLinodeInstanceClient)(nil).ResizeInstanceDisk), ctx, linodeID, diskID, size)
}

// UpdateInstanceConfig mocks base method.
func (m *MockLinodeInstanceClient) UpdateInstanceConfig(ctx context.Context, linodeID, configID int, opts linodego.InstanceConfigUpdateOptions) (*linodego.InstanceConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInstanceConfig", ctx, linodeID, configID, opts)
	ret0, _ := ret[0].(*linodego.InstanceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInstanceConfig indicates an expected call of UpdateInstanceConfig.
func (mr *MockLinodeInstanceClientMockRecorder) UpdateInstanceConfig(ctx, linodeID, configID, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInstanceConfig", reflect.TypeOf((*MockLinodeInstanceClient)(nil).UpdateInstanceConfig), ctx, linodeID, configID, opts)
}

// WaitForInstanceDiskStatus mocks base method.
func (m *MockLinodeInstanceClient) WaitForInstanceDiskStatus(ctx context.Context, instanceID, diskID int, status linodego.DiskStatus, timeoutSeconds int) (*linodego.InstanceDisk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForInstanceDiskStatus", ctx, instanceID, diskID, status, timeoutSeconds)
	ret0, _ := ret[0].(*linodego.InstanceDisk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitForInstanceDiskStatus indicates an expected call of WaitForInstanceDiskStatus.
func (mr *MockLinodeInstanceClientMockRecorder) WaitForInstanceDiskStatus(ctx, instanceID, diskID, status, timeoutSeconds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForInstanceDiskStatus", reflect.TypeOf((*MockLinodeInstanceClient)(nil).WaitForInstanceDiskStatus), ctx, instanceID, diskID, status, timeoutSeconds)
}

// MockLinodeVPCClient is a mock of LinodeVPCClient interface.
type MockLinodeVPCClient struct {
	ctrl     *gomock.Controller
	recorder *MockLinodeVPCClientMockRecorder
}

// MockLinodeVPCClientMockRecorder is the mock recorder for MockLinodeVPCClient.
type MockLinodeVPCClientMockRecorder struct {
	mock *MockLinodeVPCClient
}

// NewMockLinodeVPCClient creates a new mock instance.
func NewMockLinodeVPCClient(ctrl *gomock.Controller) *MockLinodeVPCClient {
	mock := &MockLinodeVPCClient{ctrl: ctrl}
	mock.recorder = &MockLinodeVPCClientMockRecorder{mock}
	return mock
}

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

// GetVPC mocks base method.
func (m *MockLinodeVPCClient) GetVPC(ctx context.Context, vpcID int) (*linodego.VPC, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVPC", ctx, vpcID)
	ret0, _ := ret[0].(*linodego.VPC)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLinodeNodeBalancerClient is a mock of LinodeNodeBalancerClient interface.
type MockLinodeNodeBalancerClient struct {
	ctrl     *gomock.Controller
	recorder *MockLinodeNodeBalancerClientMockRecorder
}

// MockLinodeNodeBalancerClientMockRecorder is the mock recorder for MockLinodeNodeBalancerClient.
type MockLinodeNodeBalancerClientMockRecorder struct {
	mock *MockLinodeNodeBalancerClient
}

// NewMockLinodeNodeBalancerClient creates a new mock instance.
func NewMockLinodeNodeBalancerClient(ctrl *gomock.Controller) *MockLinodeNodeBalancerClient {
	mock := &MockLinodeNodeBalancerClient{ctrl: ctrl}
	mock.recorder = &MockLinodeNodeBalancerClientMockRecorder{mock}
	return mock
}

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

// CreateNodeBalancer mocks base method.
func (m *MockLinodeNodeBalancerClient) CreateNodeBalancer(ctx context.Context, opts linodego.NodeBalancerCreateOptions) (*linodego.NodeBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancer", ctx, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodeBalancerConfig mocks base method.
func (m *MockLinodeNodeBalancerClient) CreateNodeBalancerConfig(ctx context.Context, nodebalancerID int, opts linodego.NodeBalancerConfigCreateOptions) (*linodego.NodeBalancerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancerConfig", ctx, nodebalancerID, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodeBalancerNode mocks base method.
func (m *MockLinodeNodeBalancerClient) CreateNodeBalancerNode(ctx context.Context, nodebalancerID, configID int, opts linodego.NodeBalancerNodeCreateOptions) (*linodego.NodeBalancerNode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodeBalancerNode", ctx, nodebalancerID, configID, opts)
	ret0, _ := ret[0].(*linodego.NodeBalancerNode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNodeBalancerNode indicates an expected call of CreateNodeBalancerNode.
func (mr *MockLinodeNodeBalancerClientMockRecorder) CreateNodeBalancerNode(ctx, nodebalancerID, configID, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNodeBalancerNode", reflect.TypeOf((*MockLinodeNodeBalancerClient)(nil).CreateNodeBalancerNode), ctx, nodebalancerID, configID, opts)
}

// DeleteNodeBalancer mocks base method.
func (m *MockLinodeNodeBalancerClient) DeleteNodeBalancer(ctx context.Context, nodebalancerID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodeBalancer", ctx, nodebalancerID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteNodeBalancerNode mocks base method.
func (m *MockLinodeNodeBalancerClient) DeleteNodeBalancerNode(ctx context.Context, nodebalancerID, configID, nodeID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodeBalancerNode", ctx, nodebalancerID, configID, nodeID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNodeBalancerNode indicates an expected call of DeleteNodeBalancerNode.
func (mr *MockLinodeNodeBalancerClientMockRecorder) DeleteNodeBalancerNode(ctx, nodebalancerID, configID, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNodeBalancerNode", reflect.TypeOf((*MockLinodeNodeBalancerClient)(nil).DeleteNodeBalancerNode), ctx, nodebalancerID, configID, nodeID)
}

// ListNodeBalancers mocks base method.
func (m *MockLinodeNodeBalancerClient) ListNodeBalancers(ctx context.Context, opts *linodego.ListOptions) ([]linodego.NodeBalancer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodeBalancers", ctx, opts)
	ret0, _ := ret[0].([]linodego.NodeBalancer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLinodeObjectStorageClient is a mock of LinodeObjectStorageClient interface.
type MockLinodeObjectStorageClient struct {
	ctrl     *gomock.Controller
	recorder *MockLinodeObjectStorageClientMockRecorder
}

// MockLinodeObjectStorageClientMockRecorder is the mock recorder for MockLinodeObjectStorageClient.
type MockLinodeObjectStorageClientMockRecorder struct {
	mock *MockLinodeObjectStorageClient
}

// NewMockLinodeObjectStorageClient creates a new mock instance.
func NewMockLinodeObjectStorageClient(ctrl *gomock.Controller) *MockLinodeObjectStorageClient {
	mock := &MockLinodeObjectStorageClient{ctrl: ctrl}
	mock.recorder = &MockLinodeObjectStorageClientMockRecorder{mock}
	return mock
}

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

// CreateObjectStorageBucket mocks base method.
func (m *MockLinodeObjectStorageClient) CreateObjectStorageBucket(ctx context.Context, opts linodego.ObjectStorageBucketCreateOptions) (*linodego.ObjectStorageBucket, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateObjectStorageBucket", ctx, opts)
	ret0, _ := ret[0].(*linodego.ObjectStorageBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateObjectStorageKey mocks base method.
func (m *MockLinodeObjectStorageClient) CreateObjectStorageKey(ctx context.Context, opts linodego.ObjectStorageKeyCreateOptions) (*linodego.ObjectStorageKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateObjectStorageKey", ctx, opts)
	ret0, _ := ret[0].(*linodego.ObjectStorageKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteObjectStorageKey mocks base method.
func (m *MockLinodeObjectStorageClient) DeleteObjectStorageKey(ctx context.Context, keyID int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObjectStorageKey", ctx, keyID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetObjectStorageBucket mocks base method.
func (m *MockLinodeObjectStorageClient) GetObjectStorageBucket(ctx context.Context, cluster, label string) (*linodego.ObjectStorageBucket, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectStorageBucket", ctx, cluster, label)
	ret0, _ := ret[0].(*linodego.ObjectStorageBucket)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetObjectStorageBucket indicates an expected call of GetObjectStorageBucket.
func (mr *MockLinodeObjectStorageClientMockRecorder) GetObjectStorageBucket(ctx, cluster, label any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectStorageBucket", reflect.TypeOf((*MockLinodeObjectStorageClient)(nil).GetObjectStorageBucket), ctx, cluster, label)
}

// GetObjectStorageKey mocks base method.
func (m *MockLinodeObjectStorageClient) GetObjectStorageKey(ctx context.Context, keyID int) (*linodego.ObjectStorageKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectStorageKey", ctx, keyID)
	ret0, _ := ret[0].(*linodego.ObjectStorageKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Mockk8sClient is a mock of k8sClient interface.
type Mockk8sClient struct {
	ctrl     *gomock.Controller
	recorder *Mockk8sClientMockRecorder
}

// Mockk8sClientMockRecorder is the mock recorder for Mockk8sClient.
type Mockk8sClientMockRecorder struct {
	mock *Mockk8sClient
}

// NewMockk8sClient creates a new mock instance.
func NewMockk8sClient(ctrl *gomock.Controller) *Mockk8sClient {
	mock := &Mockk8sClient{ctrl: ctrl}
	mock.recorder = &Mockk8sClientMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *Mockk8sClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Create", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *Mockk8sClientMockRecorder) Create(ctx, obj any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*Mockk8sClient)(nil).Create), varargs...)
}

// Delete mocks base method.
func (m *Mockk8sClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *Mockk8sClientMockRecorder) Delete(ctx, obj any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*Mockk8sClient)(nil).Delete), varargs...)
}

// DeleteAllOf mocks base method.
func (m *Mockk8sClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllOf", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAllOf indicates an expected call of DeleteAllOf.
func (mr *Mockk8sClientMockRecorder) DeleteAllOf(ctx, obj any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOf", reflect.TypeOf((*Mockk8sClient)(nil).DeleteAllOf), varargs...)
}

// Get mocks base method.
func (m *Mockk8sClient) Get(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *Mockk8sClientMockRecorder) Get(ctx, key, obj any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*Mockk8sClient)(nil).Get), varargs...)
}

// GroupVersionKindFor mocks base method.
func (m *Mockk8sClient) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GroupVersionKindFor", obj)
	ret0, _ := ret[0].(schema.GroupVersionKind)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GroupVersionKindFor indicates an expected call of GroupVersionKindFor.
func (mr *Mockk8sClientMockRecorder) GroupVersionKindFor(obj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKindFor", reflect.TypeOf((*Mockk8sClient)(nil).GroupVersionKindFor), obj)
}

// IsObjectNamespaced mocks base method.
func (m *Mockk8sClient) IsObjectNamespaced(obj runtime.Object) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsObjectNamespaced", obj)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsObjectNamespaced indicates an expected call of IsObjectNamespaced.
func (mr *Mockk8sClientMockRecorder) IsObjectNamespaced(obj any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsObjectNamespaced", reflect.TypeOf((*Mockk8sClient)(nil).IsObjectNamespaced), obj)
}

// List mocks base method.
func (m *Mockk8sClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, list}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// List indicates an expected call of List.
func (mr *Mockk8sClientMockRecorder) List(ctx, list any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, list}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*Mockk8sClient)(nil).List), varargs...)
}

// Patch mocks base method.
func (m *Mockk8sClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Patch", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Patch indicates an expected call of Patch.
func (mr *Mockk8sClientMockRecorder) Patch(ctx, obj, patch any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*Mockk8sClient)(nil).Patch), varargs...)
}

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

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

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

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

// Status mocks base method.
func (m *Mockk8sClient) Status() client.SubResourceWriter {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(client.SubResourceWriter)
	return ret0
}

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

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

// SubResource indicates an expected call of SubResource.
func (mr *Mockk8sClientMockRecorder) SubResource(subResource any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubResource", reflect.TypeOf((*Mockk8sClient)(nil).SubResource), subResource)
}

// Update mocks base method.
func (m *Mockk8sClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Update", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *Mockk8sClientMockRecorder) Update(ctx, obj any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*Mockk8sClient)(nil).Update), varargs...)
}