client_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./client.go

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

import (
	reflect "reflect"

	ecs "github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
	resourcemanager "github.com/aliyun/alibaba-cloud-sdk-go/services/resourcemanager"
	slb "github.com/aliyun/alibaba-cloud-sdk-go/services/slb"
	vpc "github.com/aliyun/alibaba-cloud-sdk-go/services/vpc"
	gomock "github.com/golang/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// AddBackendServers mocks base method.
func (m *MockClient) AddBackendServers(arg0 *slb.AddBackendServersRequest) (*slb.AddBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBackendServers", arg0)
	ret0, _ := ret[0].(*slb.AddBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddBackendServers indicates an expected call of AddBackendServers.
func (mr *MockClientMockRecorder) AddBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBackendServers", reflect.TypeOf((*MockClient)(nil).AddBackendServers), arg0)
}

// AddVServerGroupBackendServers mocks base method.
func (m *MockClient) AddVServerGroupBackendServers(arg0 *slb.AddVServerGroupBackendServersRequest) (*slb.AddVServerGroupBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddVServerGroupBackendServers", arg0)
	ret0, _ := ret[0].(*slb.AddVServerGroupBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddVServerGroupBackendServers indicates an expected call of AddVServerGroupBackendServers.
func (mr *MockClientMockRecorder) AddVServerGroupBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddVServerGroupBackendServers", reflect.TypeOf((*MockClient)(nil).AddVServerGroupBackendServers), arg0)
}

// AllocateEipAddress mocks base method.
func (m *MockClient) AllocateEipAddress(arg0 *vpc.AllocateEipAddressRequest) (*vpc.AllocateEipAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocateEipAddress", arg0)
	ret0, _ := ret[0].(*vpc.AllocateEipAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllocateEipAddress indicates an expected call of AllocateEipAddress.
func (mr *MockClientMockRecorder) AllocateEipAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateEipAddress", reflect.TypeOf((*MockClient)(nil).AllocateEipAddress), arg0)
}

// AllocatePublicIPAddress mocks base method.
func (m *MockClient) AllocatePublicIPAddress(arg0 *ecs.AllocatePublicIpAddressRequest) (*ecs.AllocatePublicIpAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllocatePublicIPAddress", arg0)
	ret0, _ := ret[0].(*ecs.AllocatePublicIpAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllocatePublicIPAddress indicates an expected call of AllocatePublicIPAddress.
func (mr *MockClientMockRecorder) AllocatePublicIPAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocatePublicIPAddress", reflect.TypeOf((*MockClient)(nil).AllocatePublicIPAddress), arg0)
}

// AssociateEipAddress mocks base method.
func (m *MockClient) AssociateEipAddress(arg0 *vpc.AssociateEipAddressRequest) (*vpc.AssociateEipAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateEipAddress", arg0)
	ret0, _ := ret[0].(*vpc.AssociateEipAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssociateEipAddress indicates an expected call of AssociateEipAddress.
func (mr *MockClientMockRecorder) AssociateEipAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEipAddress", reflect.TypeOf((*MockClient)(nil).AssociateEipAddress), arg0)
}

// AttachDisk mocks base method.
func (m *MockClient) AttachDisk(arg0 *ecs.AttachDiskRequest) (*ecs.AttachDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachDisk", arg0)
	ret0, _ := ret[0].(*ecs.AttachDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachDisk indicates an expected call of AttachDisk.
func (mr *MockClientMockRecorder) AttachDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockClient)(nil).AttachDisk), arg0)
}

// AttachInstanceRAMRole mocks base method.
func (m *MockClient) AttachInstanceRAMRole(arg0 *ecs.AttachInstanceRamRoleRequest) (*ecs.AttachInstanceRamRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachInstanceRAMRole", arg0)
	ret0, _ := ret[0].(*ecs.AttachInstanceRamRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AttachInstanceRAMRole indicates an expected call of AttachInstanceRAMRole.
func (mr *MockClientMockRecorder) AttachInstanceRAMRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstanceRAMRole", reflect.TypeOf((*MockClient)(nil).AttachInstanceRAMRole), arg0)
}

// AuthorizeSecurityGroup mocks base method.
func (m *MockClient) AuthorizeSecurityGroup(arg0 *ecs.AuthorizeSecurityGroupRequest) (*ecs.AuthorizeSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.AuthorizeSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeSecurityGroup indicates an expected call of AuthorizeSecurityGroup.
func (mr *MockClientMockRecorder) AuthorizeSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroup", reflect.TypeOf((*MockClient)(nil).AuthorizeSecurityGroup), arg0)
}

// AuthorizeSecurityGroupEgress mocks base method.
func (m *MockClient) AuthorizeSecurityGroupEgress(arg0 *ecs.AuthorizeSecurityGroupEgressRequest) (*ecs.AuthorizeSecurityGroupEgressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0)
	ret0, _ := ret[0].(*ecs.AuthorizeSecurityGroupEgressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress.
func (mr *MockClientMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockClient)(nil).AuthorizeSecurityGroupEgress), arg0)
}

// CreateDisk mocks base method.
func (m *MockClient) CreateDisk(arg0 *ecs.CreateDiskRequest) (*ecs.CreateDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDisk", arg0)
	ret0, _ := ret[0].(*ecs.CreateDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDisk indicates an expected call of CreateDisk.
func (mr *MockClientMockRecorder) CreateDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDisk", reflect.TypeOf((*MockClient)(nil).CreateDisk), arg0)
}

// CreateInstance mocks base method.
func (m *MockClient) CreateInstance(arg0 *ecs.CreateInstanceRequest) (*ecs.CreateInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateInstance", arg0)
	ret0, _ := ret[0].(*ecs.CreateInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateInstance indicates an expected call of CreateInstance.
func (mr *MockClientMockRecorder) CreateInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstance", reflect.TypeOf((*MockClient)(nil).CreateInstance), arg0)
}

// CreateLoadBalancer mocks base method.
func (m *MockClient) CreateLoadBalancer(arg0 *slb.CreateLoadBalancerRequest) (*slb.CreateLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0)
	ret0, _ := ret[0].(*slb.CreateLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancer indicates an expected call of CreateLoadBalancer.
func (mr *MockClientMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancer), arg0)
}

// CreateLoadBalancerHTTPListener mocks base method.
func (m *MockClient) CreateLoadBalancerHTTPListener(arg0 *slb.CreateLoadBalancerHTTPListenerRequest) (*slb.CreateLoadBalancerHTTPListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerHTTPListener", arg0)
	ret0, _ := ret[0].(*slb.CreateLoadBalancerHTTPListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancerHTTPListener indicates an expected call of CreateLoadBalancerHTTPListener.
func (mr *MockClientMockRecorder) CreateLoadBalancerHTTPListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerHTTPListener", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancerHTTPListener), arg0)
}

// CreateLoadBalancerHTTPSListener mocks base method.
func (m *MockClient) CreateLoadBalancerHTTPSListener(arg0 *slb.CreateLoadBalancerHTTPSListenerRequest) (*slb.CreateLoadBalancerHTTPSListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerHTTPSListener", arg0)
	ret0, _ := ret[0].(*slb.CreateLoadBalancerHTTPSListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancerHTTPSListener indicates an expected call of CreateLoadBalancerHTTPSListener.
func (mr *MockClientMockRecorder) CreateLoadBalancerHTTPSListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerHTTPSListener", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancerHTTPSListener), arg0)
}

// CreateLoadBalancerTCPListener mocks base method.
func (m *MockClient) CreateLoadBalancerTCPListener(arg0 *slb.CreateLoadBalancerTCPListenerRequest) (*slb.CreateLoadBalancerTCPListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerTCPListener", arg0)
	ret0, _ := ret[0].(*slb.CreateLoadBalancerTCPListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancerTCPListener indicates an expected call of CreateLoadBalancerTCPListener.
func (mr *MockClientMockRecorder) CreateLoadBalancerTCPListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerTCPListener", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancerTCPListener), arg0)
}

// CreateLoadBalancerUDPListener mocks base method.
func (m *MockClient) CreateLoadBalancerUDPListener(arg0 *slb.CreateLoadBalancerUDPListenerRequest) (*slb.CreateLoadBalancerUDPListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerUDPListener", arg0)
	ret0, _ := ret[0].(*slb.CreateLoadBalancerUDPListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancerUDPListener indicates an expected call of CreateLoadBalancerUDPListener.
func (mr *MockClientMockRecorder) CreateLoadBalancerUDPListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerUDPListener", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancerUDPListener), arg0)
}

// CreateNatGateway mocks base method.
func (m *MockClient) CreateNatGateway(arg0 *vpc.CreateNatGatewayRequest) (*vpc.CreateNatGatewayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNatGateway", arg0)
	ret0, _ := ret[0].(*vpc.CreateNatGatewayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNatGateway indicates an expected call of CreateNatGateway.
func (mr *MockClientMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockClient)(nil).CreateNatGateway), arg0)
}

// CreateSecurityGroup mocks base method.
func (m *MockClient) CreateSecurityGroup(arg0 *ecs.CreateSecurityGroupRequest) (*ecs.CreateSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.CreateSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecurityGroup indicates an expected call of CreateSecurityGroup.
func (mr *MockClientMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockClient)(nil).CreateSecurityGroup), arg0)
}

// CreateVServerGroup mocks base method.
func (m *MockClient) CreateVServerGroup(arg0 *slb.CreateVServerGroupRequest) (*slb.CreateVServerGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVServerGroup", arg0)
	ret0, _ := ret[0].(*slb.CreateVServerGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVServerGroup indicates an expected call of CreateVServerGroup.
func (mr *MockClientMockRecorder) CreateVServerGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVServerGroup", reflect.TypeOf((*MockClient)(nil).CreateVServerGroup), arg0)
}

// CreateVSwitch mocks base method.
func (m *MockClient) CreateVSwitch(arg0 *vpc.CreateVSwitchRequest) (*vpc.CreateVSwitchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVSwitch", arg0)
	ret0, _ := ret[0].(*vpc.CreateVSwitchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVSwitch indicates an expected call of CreateVSwitch.
func (mr *MockClientMockRecorder) CreateVSwitch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVSwitch", reflect.TypeOf((*MockClient)(nil).CreateVSwitch), arg0)
}

// CreateVpc mocks base method.
func (m *MockClient) CreateVpc(arg0 *vpc.CreateVpcRequest) (*vpc.CreateVpcResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVpc", arg0)
	ret0, _ := ret[0].(*vpc.CreateVpcResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateVpc indicates an expected call of CreateVpc.
func (mr *MockClientMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockClient)(nil).CreateVpc), arg0)
}

// DeleteDisk mocks base method.
func (m *MockClient) DeleteDisk(arg0 *ecs.DeleteDiskRequest) (*ecs.DeleteDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDisk", arg0)
	ret0, _ := ret[0].(*ecs.DeleteDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDisk indicates an expected call of DeleteDisk.
func (mr *MockClientMockRecorder) DeleteDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDisk", reflect.TypeOf((*MockClient)(nil).DeleteDisk), arg0)
}

// DeleteInstance mocks base method.
func (m *MockClient) DeleteInstance(arg0 *ecs.DeleteInstanceRequest) (*ecs.DeleteInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstance", arg0)
	ret0, _ := ret[0].(*ecs.DeleteInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInstance indicates an expected call of DeleteInstance.
func (mr *MockClientMockRecorder) DeleteInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstance", reflect.TypeOf((*MockClient)(nil).DeleteInstance), arg0)
}

// DeleteInstances mocks base method.
func (m *MockClient) DeleteInstances(arg0 *ecs.DeleteInstancesRequest) (*ecs.DeleteInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteInstances", arg0)
	ret0, _ := ret[0].(*ecs.DeleteInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteInstances indicates an expected call of DeleteInstances.
func (mr *MockClientMockRecorder) DeleteInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstances", reflect.TypeOf((*MockClient)(nil).DeleteInstances), arg0)
}

// DeleteLoadBalancer mocks base method.
func (m *MockClient) DeleteLoadBalancer(arg0 *slb.DeleteLoadBalancerRequest) (*slb.DeleteLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0)
	ret0, _ := ret[0].(*slb.DeleteLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer.
func (mr *MockClientMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockClient)(nil).DeleteLoadBalancer), arg0)
}

// DeleteLoadBalancerListener mocks base method.
func (m *MockClient) DeleteLoadBalancerListener(arg0 *slb.DeleteLoadBalancerListenerRequest) (*slb.DeleteLoadBalancerListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancerListener", arg0)
	ret0, _ := ret[0].(*slb.DeleteLoadBalancerListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLoadBalancerListener indicates an expected call of DeleteLoadBalancerListener.
func (mr *MockClientMockRecorder) DeleteLoadBalancerListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerListener", reflect.TypeOf((*MockClient)(nil).DeleteLoadBalancerListener), arg0)
}

// DeleteNatGateway mocks base method.
func (m *MockClient) DeleteNatGateway(arg0 *vpc.DeleteNatGatewayRequest) (*vpc.DeleteNatGatewayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNatGateway", arg0)
	ret0, _ := ret[0].(*vpc.DeleteNatGatewayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNatGateway indicates an expected call of DeleteNatGateway.
func (mr *MockClientMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockClient)(nil).DeleteNatGateway), arg0)
}

// DeleteSecurityGroup mocks base method.
func (m *MockClient) DeleteSecurityGroup(arg0 *ecs.DeleteSecurityGroupRequest) (*ecs.DeleteSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.DeleteSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup.
func (mr *MockClientMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockClient)(nil).DeleteSecurityGroup), arg0)
}

// DeleteVServerGroup mocks base method.
func (m *MockClient) DeleteVServerGroup(arg0 *slb.DeleteVServerGroupRequest) (*slb.DeleteVServerGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVServerGroup", arg0)
	ret0, _ := ret[0].(*slb.DeleteVServerGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVServerGroup indicates an expected call of DeleteVServerGroup.
func (mr *MockClientMockRecorder) DeleteVServerGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVServerGroup", reflect.TypeOf((*MockClient)(nil).DeleteVServerGroup), arg0)
}

// DeleteVSwitch mocks base method.
func (m *MockClient) DeleteVSwitch(arg0 *vpc.DeleteVSwitchRequest) (*vpc.DeleteVSwitchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVSwitch", arg0)
	ret0, _ := ret[0].(*vpc.DeleteVSwitchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVSwitch indicates an expected call of DeleteVSwitch.
func (mr *MockClientMockRecorder) DeleteVSwitch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVSwitch", reflect.TypeOf((*MockClient)(nil).DeleteVSwitch), arg0)
}

// DeleteVpc mocks base method.
func (m *MockClient) DeleteVpc(arg0 *vpc.DeleteVpcRequest) (*vpc.DeleteVpcResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVpc", arg0)
	ret0, _ := ret[0].(*vpc.DeleteVpcResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteVpc indicates an expected call of DeleteVpc.
func (mr *MockClientMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockClient)(nil).DeleteVpc), arg0)
}

// DescribeDisks mocks base method.
func (m *MockClient) DescribeDisks(arg0 *ecs.DescribeDisksRequest) (*ecs.DescribeDisksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDisks", arg0)
	ret0, _ := ret[0].(*ecs.DescribeDisksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeDisks indicates an expected call of DescribeDisks.
func (mr *MockClientMockRecorder) DescribeDisks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDisks", reflect.TypeOf((*MockClient)(nil).DescribeDisks), arg0)
}

// DescribeEipAddresses mocks base method.
func (m *MockClient) DescribeEipAddresses(arg0 *vpc.DescribeEipAddressesRequest) (*vpc.DescribeEipAddressesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEipAddresses", arg0)
	ret0, _ := ret[0].(*vpc.DescribeEipAddressesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEipAddresses indicates an expected call of DescribeEipAddresses.
func (mr *MockClientMockRecorder) DescribeEipAddresses(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEipAddresses", reflect.TypeOf((*MockClient)(nil).DescribeEipAddresses), arg0)
}

// DescribeHealthStatus mocks base method.
func (m *MockClient) DescribeHealthStatus(arg0 *slb.DescribeHealthStatusRequest) (*slb.DescribeHealthStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHealthStatus", arg0)
	ret0, _ := ret[0].(*slb.DescribeHealthStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHealthStatus indicates an expected call of DescribeHealthStatus.
func (mr *MockClientMockRecorder) DescribeHealthStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHealthStatus", reflect.TypeOf((*MockClient)(nil).DescribeHealthStatus), arg0)
}

// DescribeImages mocks base method.
func (m *MockClient) DescribeImages(arg0 *ecs.DescribeImagesRequest) (*ecs.DescribeImagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImages", arg0)
	ret0, _ := ret[0].(*ecs.DescribeImagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImages indicates an expected call of DescribeImages.
func (mr *MockClientMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockClient)(nil).DescribeImages), arg0)
}

// DescribeInstanceStatus mocks base method.
func (m *MockClient) DescribeInstanceStatus(arg0 *ecs.DescribeInstanceStatusRequest) (*ecs.DescribeInstanceStatusResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0)
	ret0, _ := ret[0].(*ecs.DescribeInstanceStatusResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus.
func (mr *MockClientMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockClient)(nil).DescribeInstanceStatus), arg0)
}

// DescribeInstanceTypes mocks base method.
func (m *MockClient) DescribeInstanceTypes(arg0 *ecs.DescribeInstanceTypesRequest) (*ecs.DescribeInstanceTypesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstanceTypes", arg0)
	ret0, _ := ret[0].(*ecs.DescribeInstanceTypesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes.
func (mr *MockClientMockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockClient)(nil).DescribeInstanceTypes), arg0)
}

// DescribeInstances mocks base method.
func (m *MockClient) DescribeInstances(arg0 *ecs.DescribeInstancesRequest) (*ecs.DescribeInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeInstances", arg0)
	ret0, _ := ret[0].(*ecs.DescribeInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeInstances indicates an expected call of DescribeInstances.
func (mr *MockClientMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockClient)(nil).DescribeInstances), arg0)
}

// DescribeLoadBalancerHTTPListenerAttribute mocks base method.
func (m *MockClient) DescribeLoadBalancerHTTPListenerAttribute(arg0 *slb.DescribeLoadBalancerHTTPListenerAttributeRequest) (*slb.DescribeLoadBalancerHTTPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancerHTTPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancerHTTPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancerHTTPListenerAttribute indicates an expected call of DescribeLoadBalancerHTTPListenerAttribute.
func (mr *MockClientMockRecorder) DescribeLoadBalancerHTTPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerHTTPListenerAttribute", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancerHTTPListenerAttribute), arg0)
}

// DescribeLoadBalancerHTTPSListenerAttribute mocks base method.
func (m *MockClient) DescribeLoadBalancerHTTPSListenerAttribute(arg0 *slb.DescribeLoadBalancerHTTPSListenerAttributeRequest) (*slb.DescribeLoadBalancerHTTPSListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancerHTTPSListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancerHTTPSListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancerHTTPSListenerAttribute indicates an expected call of DescribeLoadBalancerHTTPSListenerAttribute.
func (mr *MockClientMockRecorder) DescribeLoadBalancerHTTPSListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerHTTPSListenerAttribute", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancerHTTPSListenerAttribute), arg0)
}

// DescribeLoadBalancerListeners mocks base method.
func (m *MockClient) DescribeLoadBalancerListeners(arg0 *slb.DescribeLoadBalancerListenersRequest) (*slb.DescribeLoadBalancerListenersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancerListeners", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancerListenersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancerListeners indicates an expected call of DescribeLoadBalancerListeners.
func (mr *MockClientMockRecorder) DescribeLoadBalancerListeners(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerListeners", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancerListeners), arg0)
}

// DescribeLoadBalancerTCPListenerAttribute mocks base method.
func (m *MockClient) DescribeLoadBalancerTCPListenerAttribute(arg0 *slb.DescribeLoadBalancerTCPListenerAttributeRequest) (*slb.DescribeLoadBalancerTCPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancerTCPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancerTCPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancerTCPListenerAttribute indicates an expected call of DescribeLoadBalancerTCPListenerAttribute.
func (mr *MockClientMockRecorder) DescribeLoadBalancerTCPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTCPListenerAttribute", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancerTCPListenerAttribute), arg0)
}

// DescribeLoadBalancerUDPListenerAttribute mocks base method.
func (m *MockClient) DescribeLoadBalancerUDPListenerAttribute(arg0 *slb.DescribeLoadBalancerUDPListenerAttributeRequest) (*slb.DescribeLoadBalancerUDPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancerUDPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancerUDPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancerUDPListenerAttribute indicates an expected call of DescribeLoadBalancerUDPListenerAttribute.
func (mr *MockClientMockRecorder) DescribeLoadBalancerUDPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerUDPListenerAttribute", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancerUDPListenerAttribute), arg0)
}

// DescribeLoadBalancers mocks base method.
func (m *MockClient) DescribeLoadBalancers(arg0 *slb.DescribeLoadBalancersRequest) (*slb.DescribeLoadBalancersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0)
	ret0, _ := ret[0].(*slb.DescribeLoadBalancersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers.
func (mr *MockClientMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancers), arg0)
}

// DescribeNatGateways mocks base method.
func (m *MockClient) DescribeNatGateways(arg0 *vpc.DescribeNatGatewaysRequest) (*vpc.DescribeNatGatewaysResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNatGateways", arg0)
	ret0, _ := ret[0].(*vpc.DescribeNatGatewaysResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeNatGateways indicates an expected call of DescribeNatGateways.
func (mr *MockClientMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockClient)(nil).DescribeNatGateways), arg0)
}

// DescribeRegions mocks base method.
func (m *MockClient) DescribeRegions(arg0 *ecs.DescribeRegionsRequest) (*ecs.DescribeRegionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeRegions", arg0)
	ret0, _ := ret[0].(*ecs.DescribeRegionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeRegions indicates an expected call of DescribeRegions.
func (mr *MockClientMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockClient)(nil).DescribeRegions), arg0)
}

// DescribeSecurityGroupAttribute mocks base method.
func (m *MockClient) DescribeSecurityGroupAttribute(arg0 *ecs.DescribeSecurityGroupAttributeRequest) (*ecs.DescribeSecurityGroupAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupAttribute", arg0)
	ret0, _ := ret[0].(*ecs.DescribeSecurityGroupAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroupAttribute indicates an expected call of DescribeSecurityGroupAttribute.
func (mr *MockClientMockRecorder) DescribeSecurityGroupAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupAttribute", reflect.TypeOf((*MockClient)(nil).DescribeSecurityGroupAttribute), arg0)
}

// DescribeSecurityGroupReferences mocks base method.
func (m *MockClient) DescribeSecurityGroupReferences(arg0 *ecs.DescribeSecurityGroupReferencesRequest) (*ecs.DescribeSecurityGroupReferencesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0)
	ret0, _ := ret[0].(*ecs.DescribeSecurityGroupReferencesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences.
func (mr *MockClientMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockClient)(nil).DescribeSecurityGroupReferences), arg0)
}

// DescribeSecurityGroups mocks base method.
func (m *MockClient) DescribeSecurityGroups(arg0 *ecs.DescribeSecurityGroupsRequest) (*ecs.DescribeSecurityGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0)
	ret0, _ := ret[0].(*ecs.DescribeSecurityGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups.
func (mr *MockClientMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockClient)(nil).DescribeSecurityGroups), arg0)
}

// DescribeUserData mocks base method.
func (m *MockClient) DescribeUserData(arg0 *ecs.DescribeUserDataRequest) (*ecs.DescribeUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUserData", arg0)
	ret0, _ := ret[0].(*ecs.DescribeUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeUserData indicates an expected call of DescribeUserData.
func (mr *MockClientMockRecorder) DescribeUserData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserData", reflect.TypeOf((*MockClient)(nil).DescribeUserData), arg0)
}

// DescribeVServerGroupAttribute mocks base method.
func (m *MockClient) DescribeVServerGroupAttribute(arg0 *slb.DescribeVServerGroupAttributeRequest) (*slb.DescribeVServerGroupAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVServerGroupAttribute", arg0)
	ret0, _ := ret[0].(*slb.DescribeVServerGroupAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVServerGroupAttribute indicates an expected call of DescribeVServerGroupAttribute.
func (mr *MockClientMockRecorder) DescribeVServerGroupAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVServerGroupAttribute", reflect.TypeOf((*MockClient)(nil).DescribeVServerGroupAttribute), arg0)
}

// DescribeVServerGroups mocks base method.
func (m *MockClient) DescribeVServerGroups(arg0 *slb.DescribeVServerGroupsRequest) (*slb.DescribeVServerGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVServerGroups", arg0)
	ret0, _ := ret[0].(*slb.DescribeVServerGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVServerGroups indicates an expected call of DescribeVServerGroups.
func (mr *MockClientMockRecorder) DescribeVServerGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVServerGroups", reflect.TypeOf((*MockClient)(nil).DescribeVServerGroups), arg0)
}

// DescribeVSwitches mocks base method.
func (m *MockClient) DescribeVSwitches(arg0 *vpc.DescribeVSwitchesRequest) (*vpc.DescribeVSwitchesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVSwitches", arg0)
	ret0, _ := ret[0].(*vpc.DescribeVSwitchesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVSwitches indicates an expected call of DescribeVSwitches.
func (mr *MockClientMockRecorder) DescribeVSwitches(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVSwitches", reflect.TypeOf((*MockClient)(nil).DescribeVSwitches), arg0)
}

// DescribeVpcs mocks base method.
func (m *MockClient) DescribeVpcs(arg0 *vpc.DescribeVpcsRequest) (*vpc.DescribeVpcsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVpcs", arg0)
	ret0, _ := ret[0].(*vpc.DescribeVpcsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeVpcs indicates an expected call of DescribeVpcs.
func (mr *MockClientMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockClient)(nil).DescribeVpcs), arg0)
}

// DescribeZones mocks base method.
func (m *MockClient) DescribeZones(arg0 *ecs.DescribeZonesRequest) (*ecs.DescribeZonesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeZones", arg0)
	ret0, _ := ret[0].(*ecs.DescribeZonesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeZones indicates an expected call of DescribeZones.
func (mr *MockClientMockRecorder) DescribeZones(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeZones", reflect.TypeOf((*MockClient)(nil).DescribeZones), arg0)
}

// DetachDisk mocks base method.
func (m *MockClient) DetachDisk(arg0 *ecs.DetachDiskRequest) (*ecs.DetachDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachDisk", arg0)
	ret0, _ := ret[0].(*ecs.DetachDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachDisk indicates an expected call of DetachDisk.
func (mr *MockClientMockRecorder) DetachDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockClient)(nil).DetachDisk), arg0)
}

// DetachInstanceRAMRole mocks base method.
func (m *MockClient) DetachInstanceRAMRole(arg0 *ecs.DetachInstanceRamRoleRequest) (*ecs.DetachInstanceRamRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachInstanceRAMRole", arg0)
	ret0, _ := ret[0].(*ecs.DetachInstanceRamRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DetachInstanceRAMRole indicates an expected call of DetachInstanceRAMRole.
func (mr *MockClientMockRecorder) DetachInstanceRAMRole(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstanceRAMRole", reflect.TypeOf((*MockClient)(nil).DetachInstanceRAMRole), arg0)
}

// JoinSecurityGroup mocks base method.
func (m *MockClient) JoinSecurityGroup(arg0 *ecs.JoinSecurityGroupRequest) (*ecs.JoinSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JoinSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.JoinSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JoinSecurityGroup indicates an expected call of JoinSecurityGroup.
func (mr *MockClientMockRecorder) JoinSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JoinSecurityGroup", reflect.TypeOf((*MockClient)(nil).JoinSecurityGroup), arg0)
}

// LeaveSecurityGroup mocks base method.
func (m *MockClient) LeaveSecurityGroup(arg0 *ecs.LeaveSecurityGroupRequest) (*ecs.LeaveSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaveSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.LeaveSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LeaveSecurityGroup indicates an expected call of LeaveSecurityGroup.
func (mr *MockClientMockRecorder) LeaveSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaveSecurityGroup", reflect.TypeOf((*MockClient)(nil).LeaveSecurityGroup), arg0)
}

// ListResourceGroups mocks base method.
func (m *MockClient) ListResourceGroups(arg0 *resourcemanager.ListResourceGroupsRequest) (*resourcemanager.ListResourceGroupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListResourceGroups", arg0)
	ret0, _ := ret[0].(*resourcemanager.ListResourceGroupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListResourceGroups indicates an expected call of ListResourceGroups.
func (mr *MockClientMockRecorder) ListResourceGroups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceGroups", reflect.TypeOf((*MockClient)(nil).ListResourceGroups), arg0)
}

// ListTagResources mocks base method.
func (m *MockClient) ListTagResources(arg0 *ecs.ListTagResourcesRequest) (*ecs.ListTagResourcesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagResources", arg0)
	ret0, _ := ret[0].(*ecs.ListTagResourcesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagResources indicates an expected call of ListTagResources.
func (mr *MockClientMockRecorder) ListTagResources(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagResources", reflect.TypeOf((*MockClient)(nil).ListTagResources), arg0)
}

// ModifyDiskAttribute mocks base method.
func (m *MockClient) ModifyDiskAttribute(arg0 *ecs.ModifyDiskAttributeRequest) (*ecs.ModifyDiskAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyDiskAttribute", arg0)
	ret0, _ := ret[0].(*ecs.ModifyDiskAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyDiskAttribute indicates an expected call of ModifyDiskAttribute.
func (mr *MockClientMockRecorder) ModifyDiskAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDiskAttribute", reflect.TypeOf((*MockClient)(nil).ModifyDiskAttribute), arg0)
}

// ModifyDiskChargeType mocks base method.
func (m *MockClient) ModifyDiskChargeType(arg0 *ecs.ModifyDiskChargeTypeRequest) (*ecs.ModifyDiskChargeTypeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyDiskChargeType", arg0)
	ret0, _ := ret[0].(*ecs.ModifyDiskChargeTypeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyDiskChargeType indicates an expected call of ModifyDiskChargeType.
func (mr *MockClientMockRecorder) ModifyDiskChargeType(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDiskChargeType", reflect.TypeOf((*MockClient)(nil).ModifyDiskChargeType), arg0)
}

// ModifyDiskSpec mocks base method.
func (m *MockClient) ModifyDiskSpec(arg0 *ecs.ModifyDiskSpecRequest) (*ecs.ModifyDiskSpecResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyDiskSpec", arg0)
	ret0, _ := ret[0].(*ecs.ModifyDiskSpecResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyDiskSpec indicates an expected call of ModifyDiskSpec.
func (mr *MockClientMockRecorder) ModifyDiskSpec(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDiskSpec", reflect.TypeOf((*MockClient)(nil).ModifyDiskSpec), arg0)
}

// ModifyEipAddressAttribute mocks base method.
func (m *MockClient) ModifyEipAddressAttribute(arg0 *vpc.ModifyEipAddressAttributeRequest) (*vpc.ModifyEipAddressAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyEipAddressAttribute", arg0)
	ret0, _ := ret[0].(*vpc.ModifyEipAddressAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyEipAddressAttribute indicates an expected call of ModifyEipAddressAttribute.
func (mr *MockClientMockRecorder) ModifyEipAddressAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEipAddressAttribute", reflect.TypeOf((*MockClient)(nil).ModifyEipAddressAttribute), arg0)
}

// ModifyInstanceAttribute mocks base method.
func (m *MockClient) ModifyInstanceAttribute(arg0 *ecs.ModifyInstanceAttributeRequest) (*ecs.ModifyInstanceAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0)
	ret0, _ := ret[0].(*ecs.ModifyInstanceAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute.
func (mr *MockClientMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockClient)(nil).ModifyInstanceAttribute), arg0)
}

// ModifyInstanceMetadataOptions mocks base method.
func (m *MockClient) ModifyInstanceMetadataOptions(arg0 *ecs.ModifyInstanceMetadataOptionsRequest) (*ecs.ModifyInstanceMetadataOptionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", arg0)
	ret0, _ := ret[0].(*ecs.ModifyInstanceMetadataOptionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions.
func (mr *MockClientMockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockClient)(nil).ModifyInstanceMetadataOptions), arg0)
}

// ModifySecurityGroupAttribute mocks base method.
func (m *MockClient) ModifySecurityGroupAttribute(arg0 *ecs.ModifySecurityGroupAttributeRequest) (*ecs.ModifySecurityGroupAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupAttribute", arg0)
	ret0, _ := ret[0].(*ecs.ModifySecurityGroupAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySecurityGroupAttribute indicates an expected call of ModifySecurityGroupAttribute.
func (mr *MockClientMockRecorder) ModifySecurityGroupAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupAttribute", reflect.TypeOf((*MockClient)(nil).ModifySecurityGroupAttribute), arg0)
}

// ModifySecurityGroupEgressRule mocks base method.
func (m *MockClient) ModifySecurityGroupEgressRule(arg0 *ecs.ModifySecurityGroupEgressRuleRequest) (*ecs.ModifySecurityGroupEgressRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupEgressRule", arg0)
	ret0, _ := ret[0].(*ecs.ModifySecurityGroupEgressRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySecurityGroupEgressRule indicates an expected call of ModifySecurityGroupEgressRule.
func (mr *MockClientMockRecorder) ModifySecurityGroupEgressRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupEgressRule", reflect.TypeOf((*MockClient)(nil).ModifySecurityGroupEgressRule), arg0)
}

// ModifySecurityGroupPolicy mocks base method.
func (m *MockClient) ModifySecurityGroupPolicy(arg0 *ecs.ModifySecurityGroupPolicyRequest) (*ecs.ModifySecurityGroupPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupPolicy", arg0)
	ret0, _ := ret[0].(*ecs.ModifySecurityGroupPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySecurityGroupPolicy indicates an expected call of ModifySecurityGroupPolicy.
func (mr *MockClientMockRecorder) ModifySecurityGroupPolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupPolicy", reflect.TypeOf((*MockClient)(nil).ModifySecurityGroupPolicy), arg0)
}

// ModifySecurityGroupRule mocks base method.
func (m *MockClient) ModifySecurityGroupRule(arg0 *ecs.ModifySecurityGroupRuleRequest) (*ecs.ModifySecurityGroupRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifySecurityGroupRule", arg0)
	ret0, _ := ret[0].(*ecs.ModifySecurityGroupRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifySecurityGroupRule indicates an expected call of ModifySecurityGroupRule.
func (mr *MockClientMockRecorder) ModifySecurityGroupRule(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRule", reflect.TypeOf((*MockClient)(nil).ModifySecurityGroupRule), arg0)
}

// ModifyVServerGroupBackendServers mocks base method.
func (m *MockClient) ModifyVServerGroupBackendServers(arg0 *slb.ModifyVServerGroupBackendServersRequest) (*slb.ModifyVServerGroupBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModifyVServerGroupBackendServers", arg0)
	ret0, _ := ret[0].(*slb.ModifyVServerGroupBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ModifyVServerGroupBackendServers indicates an expected call of ModifyVServerGroupBackendServers.
func (mr *MockClientMockRecorder) ModifyVServerGroupBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVServerGroupBackendServers", reflect.TypeOf((*MockClient)(nil).ModifyVServerGroupBackendServers), arg0)
}

// ReActivateInstances mocks base method.
func (m *MockClient) ReActivateInstances(arg0 *ecs.ReActivateInstancesRequest) (*ecs.ReActivateInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReActivateInstances", arg0)
	ret0, _ := ret[0].(*ecs.ReActivateInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReActivateInstances indicates an expected call of ReActivateInstances.
func (mr *MockClientMockRecorder) ReActivateInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReActivateInstances", reflect.TypeOf((*MockClient)(nil).ReActivateInstances), arg0)
}

// ReInitDisk mocks base method.
func (m *MockClient) ReInitDisk(arg0 *ecs.ReInitDiskRequest) (*ecs.ReInitDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReInitDisk", arg0)
	ret0, _ := ret[0].(*ecs.ReInitDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReInitDisk indicates an expected call of ReInitDisk.
func (mr *MockClientMockRecorder) ReInitDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReInitDisk", reflect.TypeOf((*MockClient)(nil).ReInitDisk), arg0)
}

// RebootInstance mocks base method.
func (m *MockClient) RebootInstance(request *ecs.RebootInstanceRequest) (*ecs.RebootInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebootInstance", request)
	ret0, _ := ret[0].(*ecs.RebootInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebootInstance indicates an expected call of RebootInstance.
func (mr *MockClientMockRecorder) RebootInstance(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstance", reflect.TypeOf((*MockClient)(nil).RebootInstance), request)
}

// RebootInstances mocks base method.
func (m *MockClient) RebootInstances(request *ecs.RebootInstancesRequest) (*ecs.RebootInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebootInstances", request)
	ret0, _ := ret[0].(*ecs.RebootInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebootInstances indicates an expected call of RebootInstances.
func (mr *MockClientMockRecorder) RebootInstances(request interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockClient)(nil).RebootInstances), request)
}

// ReleaseEipAddress mocks base method.
func (m *MockClient) ReleaseEipAddress(arg0 *vpc.ReleaseEipAddressRequest) (*vpc.ReleaseEipAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseEipAddress", arg0)
	ret0, _ := ret[0].(*vpc.ReleaseEipAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseEipAddress indicates an expected call of ReleaseEipAddress.
func (mr *MockClientMockRecorder) ReleaseEipAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseEipAddress", reflect.TypeOf((*MockClient)(nil).ReleaseEipAddress), arg0)
}

// RemoveBackendServers mocks base method.
func (m *MockClient) RemoveBackendServers(arg0 *slb.RemoveBackendServersRequest) (*slb.RemoveBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveBackendServers", arg0)
	ret0, _ := ret[0].(*slb.RemoveBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveBackendServers indicates an expected call of RemoveBackendServers.
func (mr *MockClientMockRecorder) RemoveBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBackendServers", reflect.TypeOf((*MockClient)(nil).RemoveBackendServers), arg0)
}

// RemoveVServerGroupBackendServers mocks base method.
func (m *MockClient) RemoveVServerGroupBackendServers(arg0 *slb.RemoveVServerGroupBackendServersRequest) (*slb.RemoveVServerGroupBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveVServerGroupBackendServers", arg0)
	ret0, _ := ret[0].(*slb.RemoveVServerGroupBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveVServerGroupBackendServers indicates an expected call of RemoveVServerGroupBackendServers.
func (mr *MockClientMockRecorder) RemoveVServerGroupBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVServerGroupBackendServers", reflect.TypeOf((*MockClient)(nil).RemoveVServerGroupBackendServers), arg0)
}

// ReplaceSystemDisk mocks base method.
func (m *MockClient) ReplaceSystemDisk(arg0 *ecs.ReplaceSystemDiskRequest) (*ecs.ReplaceSystemDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceSystemDisk", arg0)
	ret0, _ := ret[0].(*ecs.ReplaceSystemDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceSystemDisk indicates an expected call of ReplaceSystemDisk.
func (mr *MockClientMockRecorder) ReplaceSystemDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceSystemDisk", reflect.TypeOf((*MockClient)(nil).ReplaceSystemDisk), arg0)
}

// ResetDisk mocks base method.
func (m *MockClient) ResetDisk(arg0 *ecs.ResetDiskRequest) (*ecs.ResetDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetDisk", arg0)
	ret0, _ := ret[0].(*ecs.ResetDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResetDisk indicates an expected call of ResetDisk.
func (mr *MockClientMockRecorder) ResetDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetDisk", reflect.TypeOf((*MockClient)(nil).ResetDisk), arg0)
}

// ResizeDisk mocks base method.
func (m *MockClient) ResizeDisk(arg0 *ecs.ResizeDiskRequest) (*ecs.ResizeDiskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResizeDisk", arg0)
	ret0, _ := ret[0].(*ecs.ResizeDiskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResizeDisk indicates an expected call of ResizeDisk.
func (mr *MockClientMockRecorder) ResizeDisk(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResizeDisk", reflect.TypeOf((*MockClient)(nil).ResizeDisk), arg0)
}

// RevokeSecurityGroup mocks base method.
func (m *MockClient) RevokeSecurityGroup(arg0 *ecs.RevokeSecurityGroupRequest) (*ecs.RevokeSecurityGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroup", arg0)
	ret0, _ := ret[0].(*ecs.RevokeSecurityGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeSecurityGroup indicates an expected call of RevokeSecurityGroup.
func (mr *MockClientMockRecorder) RevokeSecurityGroup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroup", reflect.TypeOf((*MockClient)(nil).RevokeSecurityGroup), arg0)
}

// RevokeSecurityGroupEgress mocks base method.
func (m *MockClient) RevokeSecurityGroupEgress(arg0 *ecs.RevokeSecurityGroupEgressRequest) (*ecs.RevokeSecurityGroupEgressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0)
	ret0, _ := ret[0].(*ecs.RevokeSecurityGroupEgressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress.
func (mr *MockClientMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockClient)(nil).RevokeSecurityGroupEgress), arg0)
}

// RunInstances mocks base method.
func (m *MockClient) RunInstances(arg0 *ecs.RunInstancesRequest) (*ecs.RunInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunInstances", arg0)
	ret0, _ := ret[0].(*ecs.RunInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunInstances indicates an expected call of RunInstances.
func (mr *MockClientMockRecorder) RunInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockClient)(nil).RunInstances), arg0)
}

// SetBackendServers mocks base method.
func (m *MockClient) SetBackendServers(arg0 *slb.SetBackendServersRequest) (*slb.SetBackendServersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBackendServers", arg0)
	ret0, _ := ret[0].(*slb.SetBackendServersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetBackendServers indicates an expected call of SetBackendServers.
func (mr *MockClientMockRecorder) SetBackendServers(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackendServers", reflect.TypeOf((*MockClient)(nil).SetBackendServers), arg0)
}

// SetLoadBalancerHTTPListenerAttribute mocks base method.
func (m *MockClient) SetLoadBalancerHTTPListenerAttribute(arg0 *slb.SetLoadBalancerHTTPListenerAttributeRequest) (*slb.SetLoadBalancerHTTPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerHTTPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.SetLoadBalancerHTTPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetLoadBalancerHTTPListenerAttribute indicates an expected call of SetLoadBalancerHTTPListenerAttribute.
func (mr *MockClientMockRecorder) SetLoadBalancerHTTPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerHTTPListenerAttribute", reflect.TypeOf((*MockClient)(nil).SetLoadBalancerHTTPListenerAttribute), arg0)
}

// SetLoadBalancerHTTPSListenerAttribute mocks base method.
func (m *MockClient) SetLoadBalancerHTTPSListenerAttribute(arg0 *slb.SetLoadBalancerHTTPSListenerAttributeRequest) (*slb.SetLoadBalancerHTTPSListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerHTTPSListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.SetLoadBalancerHTTPSListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetLoadBalancerHTTPSListenerAttribute indicates an expected call of SetLoadBalancerHTTPSListenerAttribute.
func (mr *MockClientMockRecorder) SetLoadBalancerHTTPSListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerHTTPSListenerAttribute", reflect.TypeOf((*MockClient)(nil).SetLoadBalancerHTTPSListenerAttribute), arg0)
}

// SetLoadBalancerTCPListenerAttribute mocks base method.
func (m *MockClient) SetLoadBalancerTCPListenerAttribute(arg0 *slb.SetLoadBalancerTCPListenerAttributeRequest) (*slb.SetLoadBalancerTCPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerTCPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.SetLoadBalancerTCPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetLoadBalancerTCPListenerAttribute indicates an expected call of SetLoadBalancerTCPListenerAttribute.
func (mr *MockClientMockRecorder) SetLoadBalancerTCPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerTCPListenerAttribute", reflect.TypeOf((*MockClient)(nil).SetLoadBalancerTCPListenerAttribute), arg0)
}

// SetLoadBalancerUDPListenerAttribute mocks base method.
func (m *MockClient) SetLoadBalancerUDPListenerAttribute(arg0 *slb.SetLoadBalancerUDPListenerAttributeRequest) (*slb.SetLoadBalancerUDPListenerAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetLoadBalancerUDPListenerAttribute", arg0)
	ret0, _ := ret[0].(*slb.SetLoadBalancerUDPListenerAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetLoadBalancerUDPListenerAttribute indicates an expected call of SetLoadBalancerUDPListenerAttribute.
func (mr *MockClientMockRecorder) SetLoadBalancerUDPListenerAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoadBalancerUDPListenerAttribute", reflect.TypeOf((*MockClient)(nil).SetLoadBalancerUDPListenerAttribute), arg0)
}

// SetVServerGroupAttribute mocks base method.
func (m *MockClient) SetVServerGroupAttribute(arg0 *slb.SetVServerGroupAttributeRequest) (*slb.SetVServerGroupAttributeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVServerGroupAttribute", arg0)
	ret0, _ := ret[0].(*slb.SetVServerGroupAttributeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SetVServerGroupAttribute indicates an expected call of SetVServerGroupAttribute.
func (mr *MockClientMockRecorder) SetVServerGroupAttribute(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVServerGroupAttribute", reflect.TypeOf((*MockClient)(nil).SetVServerGroupAttribute), arg0)
}

// StartInstance mocks base method.
func (m *MockClient) StartInstance(arg0 *ecs.StartInstanceRequest) (*ecs.StartInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInstance", arg0)
	ret0, _ := ret[0].(*ecs.StartInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartInstance indicates an expected call of StartInstance.
func (mr *MockClientMockRecorder) StartInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstance", reflect.TypeOf((*MockClient)(nil).StartInstance), arg0)
}

// StartInstances mocks base method.
func (m *MockClient) StartInstances(arg0 *ecs.StartInstancesRequest) (*ecs.StartInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartInstances", arg0)
	ret0, _ := ret[0].(*ecs.StartInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartInstances indicates an expected call of StartInstances.
func (mr *MockClientMockRecorder) StartInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockClient)(nil).StartInstances), arg0)
}

// StartLoadBalancerListener mocks base method.
func (m *MockClient) StartLoadBalancerListener(arg0 *slb.StartLoadBalancerListenerRequest) (*slb.StartLoadBalancerListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartLoadBalancerListener", arg0)
	ret0, _ := ret[0].(*slb.StartLoadBalancerListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartLoadBalancerListener indicates an expected call of StartLoadBalancerListener.
func (mr *MockClientMockRecorder) StartLoadBalancerListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartLoadBalancerListener", reflect.TypeOf((*MockClient)(nil).StartLoadBalancerListener), arg0)
}

// StopInstance mocks base method.
func (m *MockClient) StopInstance(arg0 *ecs.StopInstanceRequest) (*ecs.StopInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInstance", arg0)
	ret0, _ := ret[0].(*ecs.StopInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInstance indicates an expected call of StopInstance.
func (mr *MockClientMockRecorder) StopInstance(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstance", reflect.TypeOf((*MockClient)(nil).StopInstance), arg0)
}

// StopInstances mocks base method.
func (m *MockClient) StopInstances(arg0 *ecs.StopInstancesRequest) (*ecs.StopInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopInstances", arg0)
	ret0, _ := ret[0].(*ecs.StopInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopInstances indicates an expected call of StopInstances.
func (mr *MockClientMockRecorder) StopInstances(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockClient)(nil).StopInstances), arg0)
}

// StopLoadBalancerListener mocks base method.
func (m *MockClient) StopLoadBalancerListener(arg0 *slb.StopLoadBalancerListenerRequest) (*slb.StopLoadBalancerListenerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopLoadBalancerListener", arg0)
	ret0, _ := ret[0].(*slb.StopLoadBalancerListenerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopLoadBalancerListener indicates an expected call of StopLoadBalancerListener.
func (mr *MockClientMockRecorder) StopLoadBalancerListener(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopLoadBalancerListener", reflect.TypeOf((*MockClient)(nil).StopLoadBalancerListener), arg0)
}

// TagResources mocks base method.
func (m *MockClient) TagResources(arg0 *ecs.TagResourcesRequest) (*ecs.TagResourcesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResources", arg0)
	ret0, _ := ret[0].(*ecs.TagResourcesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResources indicates an expected call of TagResources.
func (mr *MockClientMockRecorder) TagResources(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResources", reflect.TypeOf((*MockClient)(nil).TagResources), arg0)
}

// UnassociateEipAddress mocks base method.
func (m *MockClient) UnassociateEipAddress(arg0 *vpc.UnassociateEipAddressRequest) (*vpc.UnassociateEipAddressResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnassociateEipAddress", arg0)
	ret0, _ := ret[0].(*vpc.UnassociateEipAddressResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnassociateEipAddress indicates an expected call of UnassociateEipAddress.
func (mr *MockClientMockRecorder) UnassociateEipAddress(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassociateEipAddress", reflect.TypeOf((*MockClient)(nil).UnassociateEipAddress), arg0)
}

// UntagResources mocks base method.
func (m *MockClient) UntagResources(arg0 *ecs.UntagResourcesRequest) (*ecs.UntagResourcesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResources", arg0)
	ret0, _ := ret[0].(*ecs.UntagResourcesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResources indicates an expected call of UntagResources.
func (mr *MockClientMockRecorder) UntagResources(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResources", reflect.TypeOf((*MockClient)(nil).UntagResources), arg0)
}