cloudstack/VPCService_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/VPCService.go

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

import (
	reflect "reflect"

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

// MockVPCServiceIface is a mock of VPCServiceIface interface.
type MockVPCServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockVPCServiceIfaceMockRecorder
}

// MockVPCServiceIfaceMockRecorder is the mock recorder for MockVPCServiceIface.
type MockVPCServiceIfaceMockRecorder struct {
	mock *MockVPCServiceIface
}

// NewMockVPCServiceIface creates a new mock instance.
func NewMockVPCServiceIface(ctrl *gomock.Controller) *MockVPCServiceIface {
	mock := &MockVPCServiceIface{ctrl: ctrl}
	mock.recorder = &MockVPCServiceIfaceMockRecorder{mock}
	return mock
}

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

// CreatePrivateGateway mocks base method.
func (m *MockVPCServiceIface) CreatePrivateGateway(p *CreatePrivateGatewayParams) (*CreatePrivateGatewayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePrivateGateway", p)
	ret0, _ := ret[0].(*CreatePrivateGatewayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateStaticRoute mocks base method.
func (m *MockVPCServiceIface) CreateStaticRoute(p *CreateStaticRouteParams) (*CreateStaticRouteResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateStaticRoute", p)
	ret0, _ := ret[0].(*CreateStaticRouteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVPC mocks base method.
func (m *MockVPCServiceIface) CreateVPC(p *CreateVPCParams) (*CreateVPCResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVPC", p)
	ret0, _ := ret[0].(*CreateVPCResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVPCOffering mocks base method.
func (m *MockVPCServiceIface) CreateVPCOffering(p *CreateVPCOfferingParams) (*CreateVPCOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVPCOffering", p)
	ret0, _ := ret[0].(*CreateVPCOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePrivateGateway mocks base method.
func (m *MockVPCServiceIface) DeletePrivateGateway(p *DeletePrivateGatewayParams) (*DeletePrivateGatewayResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePrivateGateway", p)
	ret0, _ := ret[0].(*DeletePrivateGatewayResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteStaticRoute mocks base method.
func (m *MockVPCServiceIface) DeleteStaticRoute(p *DeleteStaticRouteParams) (*DeleteStaticRouteResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteStaticRoute", p)
	ret0, _ := ret[0].(*DeleteStaticRouteResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVPC mocks base method.
func (m *MockVPCServiceIface) DeleteVPC(p *DeleteVPCParams) (*DeleteVPCResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVPC", p)
	ret0, _ := ret[0].(*DeleteVPCResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVPCOffering mocks base method.
func (m *MockVPCServiceIface) DeleteVPCOffering(p *DeleteVPCOfferingParams) (*DeleteVPCOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVPCOffering", p)
	ret0, _ := ret[0].(*DeleteVPCOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListPrivateGateways mocks base method.
func (m *MockVPCServiceIface) ListPrivateGateways(p *ListPrivateGatewaysParams) (*ListPrivateGatewaysResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPrivateGateways", p)
	ret0, _ := ret[0].(*ListPrivateGatewaysResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListStaticRoutes mocks base method.
func (m *MockVPCServiceIface) ListStaticRoutes(p *ListStaticRoutesParams) (*ListStaticRoutesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListStaticRoutes", p)
	ret0, _ := ret[0].(*ListStaticRoutesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVPCOfferings mocks base method.
func (m *MockVPCServiceIface) ListVPCOfferings(p *ListVPCOfferingsParams) (*ListVPCOfferingsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVPCOfferings", p)
	ret0, _ := ret[0].(*ListVPCOfferingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVPCs mocks base method.
func (m *MockVPCServiceIface) ListVPCs(p *ListVPCsParams) (*ListVPCsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVPCs", p)
	ret0, _ := ret[0].(*ListVPCsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewCreatePrivateGatewayParams mocks base method.
func (m *MockVPCServiceIface) NewCreatePrivateGatewayParams(gateway, ipaddress, netmask, vlan, vpcid string) *CreatePrivateGatewayParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreatePrivateGatewayParams", gateway, ipaddress, netmask, vlan, vpcid)
	ret0, _ := ret[0].(*CreatePrivateGatewayParams)
	return ret0
}

// NewCreatePrivateGatewayParams indicates an expected call of NewCreatePrivateGatewayParams.
func (mr *MockVPCServiceIfaceMockRecorder) NewCreatePrivateGatewayParams(gateway, ipaddress, netmask, vlan, vpcid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreatePrivateGatewayParams", reflect.TypeOf((*MockVPCServiceIface)(nil).NewCreatePrivateGatewayParams), gateway, ipaddress, netmask, vlan, vpcid)
}

// NewCreateStaticRouteParams mocks base method.
func (m *MockVPCServiceIface) NewCreateStaticRouteParams(cidr, gatewayid string) *CreateStaticRouteParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateStaticRouteParams", cidr, gatewayid)
	ret0, _ := ret[0].(*CreateStaticRouteParams)
	return ret0
}

// NewCreateStaticRouteParams indicates an expected call of NewCreateStaticRouteParams.
func (mr *MockVPCServiceIfaceMockRecorder) NewCreateStaticRouteParams(cidr, gatewayid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateStaticRouteParams", reflect.TypeOf((*MockVPCServiceIface)(nil).NewCreateStaticRouteParams), cidr, gatewayid)
}

// NewCreateVPCOfferingParams mocks base method.
func (m *MockVPCServiceIface) NewCreateVPCOfferingParams(displaytext, name string, supportedservices []string) *CreateVPCOfferingParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateVPCOfferingParams", displaytext, name, supportedservices)
	ret0, _ := ret[0].(*CreateVPCOfferingParams)
	return ret0
}

// NewCreateVPCOfferingParams indicates an expected call of NewCreateVPCOfferingParams.
func (mr *MockVPCServiceIfaceMockRecorder) NewCreateVPCOfferingParams(displaytext, name, supportedservices interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateVPCOfferingParams", reflect.TypeOf((*MockVPCServiceIface)(nil).NewCreateVPCOfferingParams), displaytext, name, supportedservices)
}

// NewCreateVPCParams mocks base method.
func (m *MockVPCServiceIface) NewCreateVPCParams(cidr, displaytext, name, vpcofferingid, zoneid string) *CreateVPCParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateVPCParams", cidr, displaytext, name, vpcofferingid, zoneid)
	ret0, _ := ret[0].(*CreateVPCParams)
	return ret0
}

// NewCreateVPCParams indicates an expected call of NewCreateVPCParams.
func (mr *MockVPCServiceIfaceMockRecorder) NewCreateVPCParams(cidr, displaytext, name, vpcofferingid, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateVPCParams", reflect.TypeOf((*MockVPCServiceIface)(nil).NewCreateVPCParams), cidr, displaytext, name, vpcofferingid, zoneid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RestartVPC mocks base method.
func (m *MockVPCServiceIface) RestartVPC(p *RestartVPCParams) (*RestartVPCResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestartVPC", p)
	ret0, _ := ret[0].(*RestartVPCResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVPC mocks base method.
func (m *MockVPCServiceIface) UpdateVPC(p *UpdateVPCParams) (*UpdateVPCResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVPC", p)
	ret0, _ := ret[0].(*UpdateVPCResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVPCOffering mocks base method.
func (m *MockVPCServiceIface) UpdateVPCOffering(p *UpdateVPCOfferingParams) (*UpdateVPCOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVPCOffering", p)
	ret0, _ := ret[0].(*UpdateVPCOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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