//
// 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
//
// Generated by this command:
//
//	mockgen -destination=./cloudstack/LoadBalancerService_mock.go -package=cloudstack -copyright_file=header.txt -source=./cloudstack/LoadBalancerService.go
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

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

// 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
}

// 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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignToLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).AssignToLoadBalancerRule), 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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteLoadBalancerRule), p)
}

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

// DeleteServicePackageOffering indicates an expected call of DeleteServicePackageOffering.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) DeleteServicePackageOffering(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServicePackageOffering", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteServicePackageOffering), 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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSslCert", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).DeleteSslCert), p)
}

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

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

// GetGlobalLoadBalancerRuleByID mocks base method.
func (m *MockLoadBalancerServiceIface) GetGlobalLoadBalancerRuleByID(id string, opts ...OptionFunc) (*GlobalLoadBalancerRule, int, error) {
	m.ctrl.T.Helper()
	varargs := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{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 := []any{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 any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoadBalancerRuleInstanceByID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetLoadBalancerRuleInstanceByID), varargs...)
}

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

// GetRegisteredServicePackageID indicates an expected call of GetRegisteredServicePackageID.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) GetRegisteredServicePackageID(keyword any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keyword}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRegisteredServicePackageID", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).GetRegisteredServicePackageID), 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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLoadBalancers", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListLoadBalancers), p)
}

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

// ListRegisteredServicePackages indicates an expected call of ListRegisteredServicePackages.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) ListRegisteredServicePackages(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegisteredServicePackages", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListRegisteredServicePackages), 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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSslCerts", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).ListSslCerts), p)
}

// 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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAssignToLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewAssignToLoadBalancerRuleParams), id)
}

// 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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteLoadBalancerRuleParams), id)
}

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

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

// 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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteSslCertParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewDeleteSslCertParams), id)
}

// NewDeployNetscalerVpxParams mocks base method.
func (m *MockLoadBalancerServiceIface) NewDeployNetscalerVpxParams(serviceofferingid, templateid, zoneid string) *DeployNetscalerVpxParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeployNetscalerVpxParams", serviceofferingid, templateid, zoneid)
	ret0, _ := ret[0].(*DeployNetscalerVpxParams)
	return ret0
}

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

// 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 any) *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))
}

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

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

// 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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRemoveFromLoadBalancerRuleParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewRemoveFromLoadBalancerRuleParams), id)
}

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

// NewStopNetScalerVpxParams indicates an expected call of NewStopNetScalerVpxParams.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) NewStopNetScalerVpxParams(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewStopNetScalerVpxParams", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).NewStopNetScalerVpxParams), 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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromLoadBalancerRule", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).RemoveFromLoadBalancerRule), p)
}

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

// StopNetScalerVpx indicates an expected call of StopNetScalerVpx.
func (mr *MockLoadBalancerServiceIfaceMockRecorder) StopNetScalerVpx(p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopNetScalerVpx", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).StopNetScalerVpx), 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 any) *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 any) *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 any) *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 any) *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 any) *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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadSslCert", reflect.TypeOf((*MockLoadBalancerServiceIface)(nil).UploadSslCert), p)
}