LoadBalancerService_mock.go

//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//

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

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockLoadBalancerServiceIface is a mock of LoadBalancerServiceIface interface.
type MockLoadBalancerServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancerServiceIfaceMockRecorder
}

// MockLoadBalancerServiceIfaceMockRecorder is the mock recorder for MockLoadBalancerServiceIface.
type MockLoadBalancerServiceIfaceMockRecorder struct {
	mock *MockLoadBalancerServiceIface
}

// NewMockLoadBalancerServiceIface creates a new mock instance.
func NewMockLoadBalancerServiceIface(ctrl *gomock.Controller) *MockLoadBalancerServiceIface {
	mock := &MockLoadBalancerServiceIface{ctrl: ctrl}
	mock.recorder = &MockLoadBalancerServiceIfaceMockRecorder{mock}
	return mock
}

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

// AddNetscalerLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) AddNetscalerLoadBalancer(p *AddNetscalerLoadBalancerParams) (*AddNetscalerLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNetscalerLoadBalancer", p)
	ret0, _ := ret[0].(*AddNetscalerLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddNetscalerLoadBalancer indicates an expected call of AddNetscalerLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) AddNetscalerLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNetscalerLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).AddNetscalerLoadBalancer), p)
}

// AssignCertToLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) AssignCertToLoadBalancer(p *AssignCertToLoadBalancerParams) (*AssignCertToLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignCertToLoadBalancer", p)
	ret0, _ := ret[0].(*AssignCertToLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignCertToLoadBalancer indicates an expected call of AssignCertToLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) AssignCertToLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignCertToLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).AssignCertToLoadBalancer), p)
}

// AssignToGlobalLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) AssignToGlobalLoadBalancerRule(p *AssignToGlobalLoadBalancerRuleParams) (*AssignToGlobalLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignToGlobalLoadBalancerRule", p)
	ret0, _ := ret[0].(*AssignToGlobalLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignToGlobalLoadBalancerRule indicates an expected call of AssignToGlobalLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) AssignToGlobalLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignToGlobalLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).AssignToGlobalLoadBalancerRule), p)
}

// AssignToLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) AssignToLoadBalancerRule(p *AssignToLoadBalancerRuleParams) (*AssignToLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignToLoadBalancerRule", p)
	ret0, _ := ret[0].(*AssignToLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignToLoadBalancerRule indicates an expected call of AssignToLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) AssignToLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignToLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).AssignToLoadBalancerRule), p)
}

// ConfigureNetscalerLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) ConfigureNetscalerLoadBalancer(p *ConfigureNetscalerLoadBalancerParams) (*NetscalerLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigureNetscalerLoadBalancer", p)
	ret0, _ := ret[0].(*NetscalerLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConfigureNetscalerLoadBalancer indicates an expected call of ConfigureNetscalerLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ConfigureNetscalerLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigureNetscalerLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ConfigureNetscalerLoadBalancer), p)
}

// CreateGlobalLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) CreateGlobalLoadBalancerRule(p *CreateGlobalLoadBalancerRuleParams) (*CreateGlobalLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGlobalLoadBalancerRule", p)
	ret0, _ := ret[0].(*CreateGlobalLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGlobalLoadBalancerRule indicates an expected call of CreateGlobalLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) CreateGlobalLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).CreateGlobalLoadBalancerRule), p)
}

// CreateLBHealthCheckPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) CreateLBHealthCheckPolicy(p *CreateLBHealthCheckPolicyParams) (*CreateLBHealthCheckPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLBHealthCheckPolicy", p)
	ret0, _ := ret[0].(*CreateLBHealthCheckPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLBHealthCheckPolicy indicates an expected call of CreateLBHealthCheckPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) CreateLBHealthCheckPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBHealthCheckPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).CreateLBHealthCheckPolicy), p)
}

// CreateLBStickinessPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) CreateLBStickinessPolicy(p *CreateLBStickinessPolicyParams) (*CreateLBStickinessPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLBStickinessPolicy", p)
	ret0, _ := ret[0].(*CreateLBStickinessPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLBStickinessPolicy indicates an expected call of CreateLBStickinessPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) CreateLBStickinessPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLBStickinessPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).CreateLBStickinessPolicy), p)
}

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

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

// CreateLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) CreateLoadBalancerRule(p *CreateLoadBalancerRuleParams) (*CreateLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLoadBalancerRule", p)
	ret0, _ := ret[0].(*CreateLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLoadBalancerRule indicates an expected call of CreateLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) CreateLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).CreateLoadBalancerRule), p)
}

// DeleteGlobalLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteGlobalLoadBalancerRule(p *DeleteGlobalLoadBalancerRuleParams) (*DeleteGlobalLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGlobalLoadBalancerRule", p)
	ret0, _ := ret[0].(*DeleteGlobalLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGlobalLoadBalancerRule indicates an expected call of DeleteGlobalLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteGlobalLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGlobalLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteGlobalLoadBalancerRule), p)
}

// DeleteLBHealthCheckPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteLBHealthCheckPolicy(p *DeleteLBHealthCheckPolicyParams) (*DeleteLBHealthCheckPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLBHealthCheckPolicy", p)
	ret0, _ := ret[0].(*DeleteLBHealthCheckPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLBHealthCheckPolicy indicates an expected call of DeleteLBHealthCheckPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteLBHealthCheckPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLBHealthCheckPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteLBHealthCheckPolicy), p)
}

// DeleteLBStickinessPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteLBStickinessPolicy(p *DeleteLBStickinessPolicyParams) (*DeleteLBStickinessPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLBStickinessPolicy", p)
	ret0, _ := ret[0].(*DeleteLBStickinessPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLBStickinessPolicy indicates an expected call of DeleteLBStickinessPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteLBStickinessPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLBStickinessPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteLBStickinessPolicy), p)
}

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

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

// DeleteLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteLoadBalancerRule(p *DeleteLoadBalancerRuleParams) (*DeleteLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLoadBalancerRule", p)
	ret0, _ := ret[0].(*DeleteLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteLoadBalancerRule indicates an expected call of DeleteLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteLoadBalancerRule), p)
}

// DeleteNetscalerLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteNetscalerLoadBalancer(p *DeleteNetscalerLoadBalancerParams) (*DeleteNetscalerLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetscalerLoadBalancer", p)
	ret0, _ := ret[0].(*DeleteNetscalerLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNetscalerLoadBalancer indicates an expected call of DeleteNetscalerLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteNetscalerLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetscalerLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteNetscalerLoadBalancer), p)
}

// DeleteSslCert mocks base method.
func (m *MockLoadBalancerServiceIface) DeleteSslCert(p *DeleteSslCertParams) (*DeleteSslCertResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSslCert", p)
	ret0, _ := ret[0].(*DeleteSslCertResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSslCert indicates an expected call of DeleteSslCert.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteSslCert(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSslCert", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteSslCert), p)
}

// GetGlobalLoadBalancerRuleByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetGlobalLoadBalancerRuleByID(id string, opts ...OptionFunc) (*GlobalLoadBalancerRule, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalLoadBalancerRuleByID", varargs...)
	ret0, _ := ret[0].(*GlobalLoadBalancerRule)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGlobalLoadBalancerRuleByID indicates an expected call of GetGlobalLoadBalancerRuleByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetGlobalLoadBalancerRuleByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalLoadBalancerRuleByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetGlobalLoadBalancerRuleByID), varargs...)
}

// GetGlobalLoadBalancerRuleByName mocks base method.
func (m *MockLoadBalancerServiceIface) GetGlobalLoadBalancerRuleByName(name string, opts ...OptionFunc) (*GlobalLoadBalancerRule, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalLoadBalancerRuleByName", varargs...)
	ret0, _ := ret[0].(*GlobalLoadBalancerRule)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGlobalLoadBalancerRuleByName indicates an expected call of GetGlobalLoadBalancerRuleByName.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetGlobalLoadBalancerRuleByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalLoadBalancerRuleByName", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetGlobalLoadBalancerRuleByName), varargs...)
}

// GetGlobalLoadBalancerRuleID mocks base method.
func (m *MockLoadBalancerServiceIface) GetGlobalLoadBalancerRuleID(keyword string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{keyword}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGlobalLoadBalancerRuleID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetGlobalLoadBalancerRuleID indicates an expected call of GetGlobalLoadBalancerRuleID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetGlobalLoadBalancerRuleID(keyword interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{keyword}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalLoadBalancerRuleID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetGlobalLoadBalancerRuleID), varargs...)
}

// GetLBHealthCheckPolicyByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLBHealthCheckPolicyByID(id string, opts ...OptionFunc) (*LBHealthCheckPolicy, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLBHealthCheckPolicyByID", varargs...)
	ret0, _ := ret[0].(*LBHealthCheckPolicy)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLBHealthCheckPolicyByID indicates an expected call of GetLBHealthCheckPolicyByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLBHealthCheckPolicyByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLBHealthCheckPolicyByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLBHealthCheckPolicyByID), varargs...)
}

// GetLBStickinessPolicyByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLBStickinessPolicyByID(id string, opts ...OptionFunc) (*LBStickinessPolicy, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLBStickinessPolicyByID", varargs...)
	ret0, _ := ret[0].(*LBStickinessPolicy)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLBStickinessPolicyByID indicates an expected call of GetLBStickinessPolicyByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLBStickinessPolicyByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLBStickinessPolicyByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLBStickinessPolicyByID), varargs...)
}

// GetLoadBalancerByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerByID(id string, opts ...OptionFunc) (*LoadBalancer, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerByID", varargs...)
	ret0, _ := ret[0].(*LoadBalancer)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerByID indicates an expected call of GetLoadBalancerByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerByID), varargs...)
}

// GetLoadBalancerByName mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerByName(name string, opts ...OptionFunc) (*LoadBalancer, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerByName", varargs...)
	ret0, _ := ret[0].(*LoadBalancer)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerByName indicates an expected call of GetLoadBalancerByName.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerByName", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerByName), varargs...)
}

// GetLoadBalancerID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerID indicates an expected call of GetLoadBalancerID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerID), varargs...)
}

// GetLoadBalancerRuleByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerRuleByID(id string, opts ...OptionFunc) (*LoadBalancerRule, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerRuleByID", varargs...)
	ret0, _ := ret[0].(*LoadBalancerRule)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerRuleByID indicates an expected call of GetLoadBalancerRuleByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerRuleByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRuleByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerRuleByID), varargs...)
}

// GetLoadBalancerRuleByName mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerRuleByName(name string, opts ...OptionFunc) (*LoadBalancerRule, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerRuleByName", varargs...)
	ret0, _ := ret[0].(*LoadBalancerRule)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerRuleByName indicates an expected call of GetLoadBalancerRuleByName.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerRuleByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRuleByName", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerRuleByName), varargs...)
}

// GetLoadBalancerRuleID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerRuleID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerRuleID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerRuleID indicates an expected call of GetLoadBalancerRuleID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerRuleID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRuleID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerRuleID), varargs...)
}

// GetLoadBalancerRuleInstanceByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetLoadBalancerRuleInstanceByID(id string, opts ...OptionFunc) (*VirtualMachine, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetLoadBalancerRuleInstanceByID", varargs...)
	ret0, _ := ret[0].(*VirtualMachine)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetLoadBalancerRuleInstanceByID indicates an expected call of GetLoadBalancerRuleInstanceByID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetLoadBalancerRuleInstanceByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRuleInstanceByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerRuleInstanceByID), varargs...)
}

// ListGlobalLoadBalancerRules mocks base method.
func (m *MockLoadBalancerServiceIface) ListGlobalLoadBalancerRules(p *ListGlobalLoadBalancerRulesParams) (*ListGlobalLoadBalancerRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGlobalLoadBalancerRules", p)
	ret0, _ := ret[0].(*ListGlobalLoadBalancerRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGlobalLoadBalancerRules indicates an expected call of ListGlobalLoadBalancerRules.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListGlobalLoadBalancerRules(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalLoadBalancerRules", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListGlobalLoadBalancerRules), p)
}

// ListLBHealthCheckPolicies mocks base method.
func (m *MockLoadBalancerServiceIface) ListLBHealthCheckPolicies(p *ListLBHealthCheckPoliciesParams) (*ListLBHealthCheckPoliciesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLBHealthCheckPolicies", p)
	ret0, _ := ret[0].(*ListLBHealthCheckPoliciesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLBHealthCheckPolicies indicates an expected call of ListLBHealthCheckPolicies.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListLBHealthCheckPolicies(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLBHealthCheckPolicies", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLBHealthCheckPolicies), p)
}

// ListLBStickinessPolicies mocks base method.
func (m *MockLoadBalancerServiceIface) ListLBStickinessPolicies(p *ListLBStickinessPoliciesParams) (*ListLBStickinessPoliciesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLBStickinessPolicies", p)
	ret0, _ := ret[0].(*ListLBStickinessPoliciesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLBStickinessPolicies indicates an expected call of ListLBStickinessPolicies.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListLBStickinessPolicies(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLBStickinessPolicies", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLBStickinessPolicies), p)
}

// ListLoadBalancerRuleInstances mocks base method.
func (m *MockLoadBalancerServiceIface) ListLoadBalancerRuleInstances(p *ListLoadBalancerRuleInstancesParams) (*ListLoadBalancerRuleInstancesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancerRuleInstances", p)
	ret0, _ := ret[0].(*ListLoadBalancerRuleInstancesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancerRuleInstances indicates an expected call of ListLoadBalancerRuleInstances.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListLoadBalancerRuleInstances(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancerRuleInstances", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLoadBalancerRuleInstances), p)
}

// ListLoadBalancerRules mocks base method.
func (m *MockLoadBalancerServiceIface) ListLoadBalancerRules(p *ListLoadBalancerRulesParams) (*ListLoadBalancerRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancerRules", p)
	ret0, _ := ret[0].(*ListLoadBalancerRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancerRules indicates an expected call of ListLoadBalancerRules.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListLoadBalancerRules(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancerRules", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLoadBalancerRules), p)
}

// ListLoadBalancers mocks base method.
func (m *MockLoadBalancerServiceIface) ListLoadBalancers(p *ListLoadBalancersParams) (*ListLoadBalancersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLoadBalancers", p)
	ret0, _ := ret[0].(*ListLoadBalancersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLoadBalancers indicates an expected call of ListLoadBalancers.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListLoadBalancers(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancers", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLoadBalancers), p)
}

// ListNetscalerLoadBalancers mocks base method.
func (m *MockLoadBalancerServiceIface) ListNetscalerLoadBalancers(p *ListNetscalerLoadBalancersParams) (*ListNetscalerLoadBalancersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetscalerLoadBalancers", p)
	ret0, _ := ret[0].(*ListNetscalerLoadBalancersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNetscalerLoadBalancers indicates an expected call of ListNetscalerLoadBalancers.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListNetscalerLoadBalancers(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNetscalerLoadBalancers", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListNetscalerLoadBalancers), p)
}

// ListSslCerts mocks base method.
func (m *MockLoadBalancerServiceIface) ListSslCerts(p *ListSslCertsParams) (*ListSslCertsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSslCerts", p)
	ret0, _ := ret[0].(*ListSslCertsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSslCerts indicates an expected call of ListSslCerts.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListSslCerts(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSslCerts", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListSslCerts), p)
}

// NewAddNetscalerLoadBalancerParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewAddNetscalerLoadBalancerParams(networkdevicetype, password, physicalnetworkid, url, username string) *AddNetscalerLoadBalancerParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddNetscalerLoadBalancerParams", networkdevicetype, password, physicalnetworkid, url, username)
	ret0, _ := ret[0].(*AddNetscalerLoadBalancerParams)
	return ret0
}

// NewAddNetscalerLoadBalancerParams indicates an expected call of NewAddNetscalerLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewAddNetscalerLoadBalancerParams(networkdevicetype, password, physicalnetworkid, url, username interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddNetscalerLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewAddNetscalerLoadBalancerParams), networkdevicetype, password, physicalnetworkid, url, username)
}

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

// NewAssignCertToLoadBalancerParams indicates an expected call of NewAssignCertToLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewAssignCertToLoadBalancerParams(certid, lbruleid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAssignCertToLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewAssignCertToLoadBalancerParams), certid, lbruleid)
}

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

// NewAssignToGlobalLoadBalancerRuleParams indicates an expected call of NewAssignToGlobalLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewAssignToGlobalLoadBalancerRuleParams(id, loadbalancerrulelist interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAssignToGlobalLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewAssignToGlobalLoadBalancerRuleParams), id, loadbalancerrulelist)
}

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

// NewAssignToLoadBalancerRuleParams indicates an expected call of NewAssignToLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewAssignToLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAssignToLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewAssignToLoadBalancerRuleParams), id)
}

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

// NewConfigureNetscalerLoadBalancerParams indicates an expected call of NewConfigureNetscalerLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewConfigureNetscalerLoadBalancerParams(lbdeviceid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConfigureNetscalerLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewConfigureNetscalerLoadBalancerParams), lbdeviceid)
}

// NewCreateGlobalLoadBalancerRuleParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewCreateGlobalLoadBalancerRuleParams(gslbdomainname, gslbservicetype, name string, regionid int) *CreateGlobalLoadBalancerRuleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateGlobalLoadBalancerRuleParams", gslbdomainname, gslbservicetype, name, regionid)
	ret0, _ := ret[0].(*CreateGlobalLoadBalancerRuleParams)
	return ret0
}

// NewCreateGlobalLoadBalancerRuleParams indicates an expected call of NewCreateGlobalLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewCreateGlobalLoadBalancerRuleParams(gslbdomainname, gslbservicetype, name, regionid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateGlobalLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewCreateGlobalLoadBalancerRuleParams), gslbdomainname, gslbservicetype, name, regionid)
}

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

// NewCreateLBHealthCheckPolicyParams indicates an expected call of NewCreateLBHealthCheckPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewCreateLBHealthCheckPolicyParams(lbruleid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateLBHealthCheckPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewCreateLBHealthCheckPolicyParams), lbruleid)
}

// NewCreateLBStickinessPolicyParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewCreateLBStickinessPolicyParams(lbruleid, methodname, name string) *CreateLBStickinessPolicyParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateLBStickinessPolicyParams", lbruleid, methodname, name)
	ret0, _ := ret[0].(*CreateLBStickinessPolicyParams)
	return ret0
}

// NewCreateLBStickinessPolicyParams indicates an expected call of NewCreateLBStickinessPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewCreateLBStickinessPolicyParams(lbruleid, methodname, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateLBStickinessPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewCreateLBStickinessPolicyParams), lbruleid, methodname, name)
}

// NewCreateLoadBalancerParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewCreateLoadBalancerParams(algorithm string, instanceport int, name, networkid, scheme, sourceipaddressnetworkid string, sourceport int) *CreateLoadBalancerParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateLoadBalancerParams", algorithm, instanceport, name, networkid, scheme, sourceipaddressnetworkid, sourceport)
	ret0, _ := ret[0].(*CreateLoadBalancerParams)
	return ret0
}

// NewCreateLoadBalancerParams indicates an expected call of NewCreateLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewCreateLoadBalancerParams(algorithm, instanceport, name, networkid, scheme, sourceipaddressnetworkid, sourceport interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewCreateLoadBalancerParams), algorithm, instanceport, name, networkid, scheme, sourceipaddressnetworkid, sourceport)
}

// NewCreateLoadBalancerRuleParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewCreateLoadBalancerRuleParams(algorithm, name string, privateport, publicport int) *CreateLoadBalancerRuleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateLoadBalancerRuleParams", algorithm, name, privateport, publicport)
	ret0, _ := ret[0].(*CreateLoadBalancerRuleParams)
	return ret0
}

// NewCreateLoadBalancerRuleParams indicates an expected call of NewCreateLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewCreateLoadBalancerRuleParams(algorithm, name, privateport, publicport interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewCreateLoadBalancerRuleParams), algorithm, name, privateport, publicport)
}

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

// NewDeleteGlobalLoadBalancerRuleParams indicates an expected call of NewDeleteGlobalLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteGlobalLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteGlobalLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteGlobalLoadBalancerRuleParams), id)
}

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

// NewDeleteLBHealthCheckPolicyParams indicates an expected call of NewDeleteLBHealthCheckPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteLBHealthCheckPolicyParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteLBHealthCheckPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteLBHealthCheckPolicyParams), id)
}

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

// NewDeleteLBStickinessPolicyParams indicates an expected call of NewDeleteLBStickinessPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteLBStickinessPolicyParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteLBStickinessPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteLBStickinessPolicyParams), id)
}

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

// NewDeleteLoadBalancerParams indicates an expected call of NewDeleteLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteLoadBalancerParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteLoadBalancerParams), id)
}

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

// NewDeleteLoadBalancerRuleParams indicates an expected call of NewDeleteLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteLoadBalancerRuleParams), id)
}

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

// NewDeleteNetscalerLoadBalancerParams indicates an expected call of NewDeleteNetscalerLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteNetscalerLoadBalancerParams(lbdeviceid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteNetscalerLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteNetscalerLoadBalancerParams), lbdeviceid)
}

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

// NewDeleteSslCertParams indicates an expected call of NewDeleteSslCertParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewDeleteSslCertParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteSslCertParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteSslCertParams), id)
}

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

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

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

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

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

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

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

// NewListLoadBalancerRuleInstancesParams indicates an expected call of NewListLoadBalancerRuleInstancesParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewListLoadBalancerRuleInstancesParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListLoadBalancerRuleInstancesParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewListLoadBalancerRuleInstancesParams), id)
}

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

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

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

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

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

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

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

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

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

// NewRemoveCertFromLoadBalancerParams indicates an expected call of NewRemoveCertFromLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewRemoveCertFromLoadBalancerParams(lbruleid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRemoveCertFromLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewRemoveCertFromLoadBalancerParams), lbruleid)
}

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

// NewRemoveFromGlobalLoadBalancerRuleParams indicates an expected call of NewRemoveFromGlobalLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewRemoveFromGlobalLoadBalancerRuleParams(id, loadbalancerrulelist interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRemoveFromGlobalLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewRemoveFromGlobalLoadBalancerRuleParams), id, loadbalancerrulelist)
}

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

// NewRemoveFromLoadBalancerRuleParams indicates an expected call of NewRemoveFromLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewRemoveFromLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRemoveFromLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewRemoveFromLoadBalancerRuleParams), id)
}

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

// NewUpdateGlobalLoadBalancerRuleParams indicates an expected call of NewUpdateGlobalLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUpdateGlobalLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateGlobalLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUpdateGlobalLoadBalancerRuleParams), id)
}

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

// NewUpdateLBHealthCheckPolicyParams indicates an expected call of NewUpdateLBHealthCheckPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUpdateLBHealthCheckPolicyParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateLBHealthCheckPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUpdateLBHealthCheckPolicyParams), id)
}

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

// NewUpdateLBStickinessPolicyParams indicates an expected call of NewUpdateLBStickinessPolicyParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUpdateLBStickinessPolicyParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateLBStickinessPolicyParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUpdateLBStickinessPolicyParams), id)
}

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

// NewUpdateLoadBalancerParams indicates an expected call of NewUpdateLoadBalancerParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUpdateLoadBalancerParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateLoadBalancerParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUpdateLoadBalancerParams), id)
}

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

// NewUpdateLoadBalancerRuleParams indicates an expected call of NewUpdateLoadBalancerRuleParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUpdateLoadBalancerRuleParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUpdateLoadBalancerRuleParams), id)
}

// NewUploadSslCertParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewUploadSslCertParams(certificate, name, privatekey string) *UploadSslCertParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUploadSslCertParams", certificate, name, privatekey)
	ret0, _ := ret[0].(*UploadSslCertParams)
	return ret0
}

// NewUploadSslCertParams indicates an expected call of NewUploadSslCertParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewUploadSslCertParams(certificate, name, privatekey interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUploadSslCertParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewUploadSslCertParams), certificate, name, privatekey)
}

// RemoveCertFromLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) RemoveCertFromLoadBalancer(p *RemoveCertFromLoadBalancerParams) (*RemoveCertFromLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveCertFromLoadBalancer", p)
	ret0, _ := ret[0].(*RemoveCertFromLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveCertFromLoadBalancer indicates an expected call of RemoveCertFromLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) RemoveCertFromLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveCertFromLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).RemoveCertFromLoadBalancer), p)
}

// RemoveFromGlobalLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) RemoveFromGlobalLoadBalancerRule(p *RemoveFromGlobalLoadBalancerRuleParams) (*RemoveFromGlobalLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFromGlobalLoadBalancerRule", p)
	ret0, _ := ret[0].(*RemoveFromGlobalLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveFromGlobalLoadBalancerRule indicates an expected call of RemoveFromGlobalLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) RemoveFromGlobalLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromGlobalLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).RemoveFromGlobalLoadBalancerRule), p)
}

// RemoveFromLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) RemoveFromLoadBalancerRule(p *RemoveFromLoadBalancerRuleParams) (*RemoveFromLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveFromLoadBalancerRule", p)
	ret0, _ := ret[0].(*RemoveFromLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveFromLoadBalancerRule indicates an expected call of RemoveFromLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) RemoveFromLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).RemoveFromLoadBalancerRule), p)
}

// UpdateGlobalLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) UpdateGlobalLoadBalancerRule(p *UpdateGlobalLoadBalancerRuleParams) (*UpdateGlobalLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalLoadBalancerRule", p)
	ret0, _ := ret[0].(*UpdateGlobalLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGlobalLoadBalancerRule indicates an expected call of UpdateGlobalLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UpdateGlobalLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UpdateGlobalLoadBalancerRule), p)
}

// UpdateLBHealthCheckPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) UpdateLBHealthCheckPolicy(p *UpdateLBHealthCheckPolicyParams) (*UpdateLBHealthCheckPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLBHealthCheckPolicy", p)
	ret0, _ := ret[0].(*UpdateLBHealthCheckPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLBHealthCheckPolicy indicates an expected call of UpdateLBHealthCheckPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UpdateLBHealthCheckPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLBHealthCheckPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UpdateLBHealthCheckPolicy), p)
}

// UpdateLBStickinessPolicy mocks base method.
func (m *MockLoadBalancerServiceIface) UpdateLBStickinessPolicy(p *UpdateLBStickinessPolicyParams) (*UpdateLBStickinessPolicyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLBStickinessPolicy", p)
	ret0, _ := ret[0].(*UpdateLBStickinessPolicyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLBStickinessPolicy indicates an expected call of UpdateLBStickinessPolicy.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UpdateLBStickinessPolicy(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLBStickinessPolicy", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UpdateLBStickinessPolicy), p)
}

// UpdateLoadBalancer mocks base method.
func (m *MockLoadBalancerServiceIface) UpdateLoadBalancer(p *UpdateLoadBalancerParams) (*UpdateLoadBalancerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLoadBalancer", p)
	ret0, _ := ret[0].(*UpdateLoadBalancerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLoadBalancer indicates an expected call of UpdateLoadBalancer.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UpdateLoadBalancer(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoadBalancer", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UpdateLoadBalancer), p)
}

// UpdateLoadBalancerRule mocks base method.
func (m *MockLoadBalancerServiceIface) UpdateLoadBalancerRule(p *UpdateLoadBalancerRuleParams) (*UpdateLoadBalancerRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLoadBalancerRule", p)
	ret0, _ := ret[0].(*UpdateLoadBalancerRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLoadBalancerRule indicates an expected call of UpdateLoadBalancerRule.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UpdateLoadBalancerRule(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UpdateLoadBalancerRule), p)
}

// UploadSslCert mocks base method.
func (m *MockLoadBalancerServiceIface) UploadSslCert(p *UploadSslCertParams) (*UploadSslCertResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadSslCert", p)
	ret0, _ := ret[0].(*UploadSslCertResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UploadSslCert indicates an expected call of UploadSslCert.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) UploadSslCert(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSslCert", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UploadSslCert), p)
}