cloudstack/NetworkService_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/NetworkService.go

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

import (
	reflect "reflect"

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

// MockNetworkServiceIface is a mock of NetworkServiceIface interface.
type MockNetworkServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockNetworkServiceIfaceMockRecorder
}

// MockNetworkServiceIfaceMockRecorder is the mock recorder for MockNetworkServiceIface.
type MockNetworkServiceIfaceMockRecorder struct {
	mock *MockNetworkServiceIface
}

// NewMockNetworkServiceIface creates a new mock instance.
func NewMockNetworkServiceIface(ctrl *gomock.Controller) *MockNetworkServiceIface {
	mock := &MockNetworkServiceIface{ctrl: ctrl}
	mock.recorder = &MockNetworkServiceIfaceMockRecorder{mock}
	return mock
}

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

// AddNetworkServiceProvider mocks base method.
func (m *MockNetworkServiceIface) AddNetworkServiceProvider(p *AddNetworkServiceProviderParams) (*AddNetworkServiceProviderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddNetworkServiceProvider", p)
	ret0, _ := ret[0].(*AddNetworkServiceProviderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddOpenDaylightController mocks base method.
func (m *MockNetworkServiceIface) AddOpenDaylightController(p *AddOpenDaylightControllerParams) (*AddOpenDaylightControllerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOpenDaylightController", p)
	ret0, _ := ret[0].(*AddOpenDaylightControllerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateGuestNetworkIpv6Prefix mocks base method.
func (m *MockNetworkServiceIface) CreateGuestNetworkIpv6Prefix(p *CreateGuestNetworkIpv6PrefixParams) (*CreateGuestNetworkIpv6PrefixResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGuestNetworkIpv6Prefix", p)
	ret0, _ := ret[0].(*CreateGuestNetworkIpv6PrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetwork mocks base method.
func (m *MockNetworkServiceIface) CreateNetwork(p *CreateNetworkParams) (*CreateNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetwork", p)
	ret0, _ := ret[0].(*CreateNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNetworkPermissions mocks base method.
func (m *MockNetworkServiceIface) CreateNetworkPermissions(p *CreateNetworkPermissionsParams) (*CreateNetworkPermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetworkPermissions", p)
	ret0, _ := ret[0].(*CreateNetworkPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePhysicalNetwork mocks base method.
func (m *MockNetworkServiceIface) CreatePhysicalNetwork(p *CreatePhysicalNetworkParams) (*CreatePhysicalNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePhysicalNetwork", p)
	ret0, _ := ret[0].(*CreatePhysicalNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateServiceInstance mocks base method.
func (m *MockNetworkServiceIface) CreateServiceInstance(p *CreateServiceInstanceParams) (*CreateServiceInstanceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServiceInstance", p)
	ret0, _ := ret[0].(*CreateServiceInstanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStorageNetworkIpRange mocks base method.
func (m *MockNetworkServiceIface) CreateStorageNetworkIpRange(p *CreateStorageNetworkIpRangeParams) (*CreateStorageNetworkIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStorageNetworkIpRange", p)
	ret0, _ := ret[0].(*CreateStorageNetworkIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DedicatePublicIpRange mocks base method.
func (m *MockNetworkServiceIface) DedicatePublicIpRange(p *DedicatePublicIpRangeParams) (*DedicatePublicIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DedicatePublicIpRange", p)
	ret0, _ := ret[0].(*DedicatePublicIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteGuestNetworkIpv6Prefix mocks base method.
func (m *MockNetworkServiceIface) DeleteGuestNetworkIpv6Prefix(p *DeleteGuestNetworkIpv6PrefixParams) (*DeleteGuestNetworkIpv6PrefixResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGuestNetworkIpv6Prefix", p)
	ret0, _ := ret[0].(*DeleteGuestNetworkIpv6PrefixResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetwork mocks base method.
func (m *MockNetworkServiceIface) DeleteNetwork(p *DeleteNetworkParams) (*DeleteNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetwork", p)
	ret0, _ := ret[0].(*DeleteNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNetworkServiceProvider mocks base method.
func (m *MockNetworkServiceIface) DeleteNetworkServiceProvider(p *DeleteNetworkServiceProviderParams) (*DeleteNetworkServiceProviderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNetworkServiceProvider", p)
	ret0, _ := ret[0].(*DeleteNetworkServiceProviderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteOpenDaylightController mocks base method.
func (m *MockNetworkServiceIface) DeleteOpenDaylightController(p *DeleteOpenDaylightControllerParams) (*DeleteOpenDaylightControllerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOpenDaylightController", p)
	ret0, _ := ret[0].(*DeleteOpenDaylightControllerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePhysicalNetwork mocks base method.
func (m *MockNetworkServiceIface) DeletePhysicalNetwork(p *DeletePhysicalNetworkParams) (*DeletePhysicalNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePhysicalNetwork", p)
	ret0, _ := ret[0].(*DeletePhysicalNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteStorageNetworkIpRange mocks base method.
func (m *MockNetworkServiceIface) DeleteStorageNetworkIpRange(p *DeleteStorageNetworkIpRangeParams) (*DeleteStorageNetworkIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStorageNetworkIpRange", p)
	ret0, _ := ret[0].(*DeleteStorageNetworkIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// GetNetworkID mocks base method.
func (m *MockNetworkServiceIface) GetNetworkID(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, "GetNetworkID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// GetNetworkServiceProviderID mocks base method.
func (m *MockNetworkServiceIface) GetNetworkServiceProviderID(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, "GetNetworkServiceProviderID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

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

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

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

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

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

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

// GetPhysicalNetworkID mocks base method.
func (m *MockNetworkServiceIface) GetPhysicalNetworkID(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, "GetPhysicalNetworkID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// ListGuestNetworkIpv6Prefixes mocks base method.
func (m *MockNetworkServiceIface) ListGuestNetworkIpv6Prefixes(p *ListGuestNetworkIpv6PrefixesParams) (*ListGuestNetworkIpv6PrefixesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGuestNetworkIpv6Prefixes", p)
	ret0, _ := ret[0].(*ListGuestNetworkIpv6PrefixesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetscalerLoadBalancerNetworks mocks base method.
func (m *MockNetworkServiceIface) ListNetscalerLoadBalancerNetworks(p *ListNetscalerLoadBalancerNetworksParams) (*ListNetscalerLoadBalancerNetworksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetscalerLoadBalancerNetworks", p)
	ret0, _ := ret[0].(*ListNetscalerLoadBalancerNetworksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworkIsolationMethods mocks base method.
func (m *MockNetworkServiceIface) ListNetworkIsolationMethods(p *ListNetworkIsolationMethodsParams) (*ListNetworkIsolationMethodsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkIsolationMethods", p)
	ret0, _ := ret[0].(*ListNetworkIsolationMethodsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworkPermissions mocks base method.
func (m *MockNetworkServiceIface) ListNetworkPermissions(p *ListNetworkPermissionsParams) (*ListNetworkPermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkPermissions", p)
	ret0, _ := ret[0].(*ListNetworkPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworkServiceProviders mocks base method.
func (m *MockNetworkServiceIface) ListNetworkServiceProviders(p *ListNetworkServiceProvidersParams) (*ListNetworkServiceProvidersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworkServiceProviders", p)
	ret0, _ := ret[0].(*ListNetworkServiceProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNetworks mocks base method.
func (m *MockNetworkServiceIface) ListNetworks(p *ListNetworksParams) (*ListNetworksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworks", p)
	ret0, _ := ret[0].(*ListNetworksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNiciraNvpDeviceNetworks mocks base method.
func (m *MockNetworkServiceIface) ListNiciraNvpDeviceNetworks(p *ListNiciraNvpDeviceNetworksParams) (*ListNiciraNvpDeviceNetworksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNiciraNvpDeviceNetworks", p)
	ret0, _ := ret[0].(*ListNiciraNvpDeviceNetworksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListOpenDaylightControllers mocks base method.
func (m *MockNetworkServiceIface) ListOpenDaylightControllers(p *ListOpenDaylightControllersParams) (*ListOpenDaylightControllersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOpenDaylightControllers", p)
	ret0, _ := ret[0].(*ListOpenDaylightControllersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPaloAltoFirewallNetworks mocks base method.
func (m *MockNetworkServiceIface) ListPaloAltoFirewallNetworks(p *ListPaloAltoFirewallNetworksParams) (*ListPaloAltoFirewallNetworksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPaloAltoFirewallNetworks", p)
	ret0, _ := ret[0].(*ListPaloAltoFirewallNetworksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPhysicalNetworks mocks base method.
func (m *MockNetworkServiceIface) ListPhysicalNetworks(p *ListPhysicalNetworksParams) (*ListPhysicalNetworksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPhysicalNetworks", p)
	ret0, _ := ret[0].(*ListPhysicalNetworksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStorageNetworkIpRange mocks base method.
func (m *MockNetworkServiceIface) ListStorageNetworkIpRange(p *ListStorageNetworkIpRangeParams) (*ListStorageNetworkIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStorageNetworkIpRange", p)
	ret0, _ := ret[0].(*ListStorageNetworkIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSupportedNetworkServices mocks base method.
func (m *MockNetworkServiceIface) ListSupportedNetworkServices(p *ListSupportedNetworkServicesParams) (*ListSupportedNetworkServicesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSupportedNetworkServices", p)
	ret0, _ := ret[0].(*ListSupportedNetworkServicesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// NewAddNetworkServiceProviderParams indicates an expected call of NewAddNetworkServiceProviderParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewAddNetworkServiceProviderParams(name, physicalnetworkid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddNetworkServiceProviderParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewAddNetworkServiceProviderParams), name, physicalnetworkid)
}

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

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

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

// NewCreateGuestNetworkIpv6PrefixParams indicates an expected call of NewCreateGuestNetworkIpv6PrefixParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreateGuestNetworkIpv6PrefixParams(prefix, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateGuestNetworkIpv6PrefixParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreateGuestNetworkIpv6PrefixParams), prefix, zoneid)
}

// NewCreateNetworkParams mocks base method.
func (m *MockNetworkServiceIface) NewCreateNetworkParams(name, networkofferingid, zoneid string) *CreateNetworkParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateNetworkParams", name, networkofferingid, zoneid)
	ret0, _ := ret[0].(*CreateNetworkParams)
	return ret0
}

// NewCreateNetworkParams indicates an expected call of NewCreateNetworkParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreateNetworkParams(name, networkofferingid, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateNetworkParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreateNetworkParams), name, networkofferingid, zoneid)
}

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

// NewCreateNetworkPermissionsParams indicates an expected call of NewCreateNetworkPermissionsParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreateNetworkPermissionsParams(networkid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateNetworkPermissionsParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreateNetworkPermissionsParams), networkid)
}

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

// NewCreatePhysicalNetworkParams indicates an expected call of NewCreatePhysicalNetworkParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreatePhysicalNetworkParams(name, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreatePhysicalNetworkParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreatePhysicalNetworkParams), name, zoneid)
}

// NewCreateServiceInstanceParams mocks base method.
func (m *MockNetworkServiceIface) NewCreateServiceInstanceParams(leftnetworkid, name, rightnetworkid, serviceofferingid, templateid, zoneid string) *CreateServiceInstanceParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateServiceInstanceParams", leftnetworkid, name, rightnetworkid, serviceofferingid, templateid, zoneid)
	ret0, _ := ret[0].(*CreateServiceInstanceParams)
	return ret0
}

// NewCreateServiceInstanceParams indicates an expected call of NewCreateServiceInstanceParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreateServiceInstanceParams(leftnetworkid, name, rightnetworkid, serviceofferingid, templateid, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateServiceInstanceParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreateServiceInstanceParams), leftnetworkid, name, rightnetworkid, serviceofferingid, templateid, zoneid)
}

// NewCreateStorageNetworkIpRangeParams mocks base method.
func (m *MockNetworkServiceIface) NewCreateStorageNetworkIpRangeParams(gateway, netmask, podid, startip string) *CreateStorageNetworkIpRangeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateStorageNetworkIpRangeParams", gateway, netmask, podid, startip)
	ret0, _ := ret[0].(*CreateStorageNetworkIpRangeParams)
	return ret0
}

// NewCreateStorageNetworkIpRangeParams indicates an expected call of NewCreateStorageNetworkIpRangeParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewCreateStorageNetworkIpRangeParams(gateway, netmask, podid, startip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateStorageNetworkIpRangeParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewCreateStorageNetworkIpRangeParams), gateway, netmask, podid, startip)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewListNetworkPermissionsParams indicates an expected call of NewListNetworkPermissionsParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewListNetworkPermissionsParams(networkid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListNetworkPermissionsParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewListNetworkPermissionsParams), networkid)
}

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

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

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

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

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

// NewListNiciraNvpDeviceNetworksParams indicates an expected call of NewListNiciraNvpDeviceNetworksParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewListNiciraNvpDeviceNetworksParams(nvpdeviceid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListNiciraNvpDeviceNetworksParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewListNiciraNvpDeviceNetworksParams), nvpdeviceid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewRemoveNetworkPermissionsParams indicates an expected call of NewRemoveNetworkPermissionsParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewRemoveNetworkPermissionsParams(networkid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRemoveNetworkPermissionsParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewRemoveNetworkPermissionsParams), networkid)
}

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

// NewResetNetworkPermissionsParams indicates an expected call of NewResetNetworkPermissionsParams.
func (mr *MockNetworkServiceIfaceMockRecorder) NewResetNetworkPermissionsParams(networkid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewResetNetworkPermissionsParams", reflect.TypeOf((*MockNetworkServiceIface)(nil).NewResetNetworkPermissionsParams), networkid)
}

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

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

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

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

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

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

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

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

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

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

// ReleasePublicIpRange mocks base method.
func (m *MockNetworkServiceIface) ReleasePublicIpRange(p *ReleasePublicIpRangeParams) (*ReleasePublicIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleasePublicIpRange", p)
	ret0, _ := ret[0].(*ReleasePublicIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveNetworkPermissions mocks base method.
func (m *MockNetworkServiceIface) RemoveNetworkPermissions(p *RemoveNetworkPermissionsParams) (*RemoveNetworkPermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveNetworkPermissions", p)
	ret0, _ := ret[0].(*RemoveNetworkPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResetNetworkPermissions mocks base method.
func (m *MockNetworkServiceIface) ResetNetworkPermissions(p *ResetNetworkPermissionsParams) (*ResetNetworkPermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResetNetworkPermissions", p)
	ret0, _ := ret[0].(*ResetNetworkPermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestartNetwork mocks base method.
func (m *MockNetworkServiceIface) RestartNetwork(p *RestartNetworkParams) (*RestartNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestartNetwork", p)
	ret0, _ := ret[0].(*RestartNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNetwork mocks base method.
func (m *MockNetworkServiceIface) UpdateNetwork(p *UpdateNetworkParams) (*UpdateNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNetwork", p)
	ret0, _ := ret[0].(*UpdateNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNetworkServiceProvider mocks base method.
func (m *MockNetworkServiceIface) UpdateNetworkServiceProvider(p *UpdateNetworkServiceProviderParams) (*UpdateNetworkServiceProviderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNetworkServiceProvider", p)
	ret0, _ := ret[0].(*UpdateNetworkServiceProviderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePhysicalNetwork mocks base method.
func (m *MockNetworkServiceIface) UpdatePhysicalNetwork(p *UpdatePhysicalNetworkParams) (*UpdatePhysicalNetworkResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePhysicalNetwork", p)
	ret0, _ := ret[0].(*UpdatePhysicalNetworkResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateStorageNetworkIpRange mocks base method.
func (m *MockNetworkServiceIface) UpdateStorageNetworkIpRange(p *UpdateStorageNetworkIpRangeParams) (*UpdateStorageNetworkIpRangeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStorageNetworkIpRange", p)
	ret0, _ := ret[0].(*UpdateStorageNetworkIpRangeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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