cloudstack/TemplateService_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/TemplateService.go

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

import (
	reflect "reflect"

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

// MockTemplateServiceIface is a mock of TemplateServiceIface interface.
type MockTemplateServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockTemplateServiceIfaceMockRecorder
}

// MockTemplateServiceIfaceMockRecorder is the mock recorder for MockTemplateServiceIface.
type MockTemplateServiceIfaceMockRecorder struct {
	mock *MockTemplateServiceIface
}

// NewMockTemplateServiceIface creates a new mock instance.
func NewMockTemplateServiceIface(ctrl *gomock.Controller) *MockTemplateServiceIface {
	mock := &MockTemplateServiceIface{ctrl: ctrl}
	mock.recorder = &MockTemplateServiceIfaceMockRecorder{mock}
	return mock
}

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

// CopyTemplate mocks base method.
func (m *MockTemplateServiceIface) CopyTemplate(p *CopyTemplateParams) (*CopyTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyTemplate", p)
	ret0, _ := ret[0].(*CopyTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateTemplate mocks base method.
func (m *MockTemplateServiceIface) CreateTemplate(p *CreateTemplateParams) (*CreateTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTemplate", p)
	ret0, _ := ret[0].(*CreateTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteTemplate mocks base method.
func (m *MockTemplateServiceIface) DeleteTemplate(p *DeleteTemplateParams) (*DeleteTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTemplate", p)
	ret0, _ := ret[0].(*DeleteTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExtractTemplate mocks base method.
func (m *MockTemplateServiceIface) ExtractTemplate(p *ExtractTemplateParams) (*ExtractTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractTemplate", p)
	ret0, _ := ret[0].(*ExtractTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// GetUploadParamsForTemplate mocks base method.
func (m *MockTemplateServiceIface) GetUploadParamsForTemplate(p *GetUploadParamsForTemplateParams) (*GetUploadParamsForTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUploadParamsForTemplate", p)
	ret0, _ := ret[0].(*GetUploadParamsForTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplatePermissions mocks base method.
func (m *MockTemplateServiceIface) ListTemplatePermissions(p *ListTemplatePermissionsParams) (*ListTemplatePermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplatePermissions", p)
	ret0, _ := ret[0].(*ListTemplatePermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTemplates mocks base method.
func (m *MockTemplateServiceIface) ListTemplates(p *ListTemplatesParams) (*ListTemplatesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTemplates", p)
	ret0, _ := ret[0].(*ListTemplatesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewCreateTemplateParams mocks base method.
func (m *MockTemplateServiceIface) NewCreateTemplateParams(displaytext, name, ostypeid string) *CreateTemplateParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateTemplateParams", displaytext, name, ostypeid)
	ret0, _ := ret[0].(*CreateTemplateParams)
	return ret0
}

// NewCreateTemplateParams indicates an expected call of NewCreateTemplateParams.
func (mr *MockTemplateServiceIfaceMockRecorder) NewCreateTemplateParams(displaytext, name, ostypeid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateTemplateParams", reflect.TypeOf((*MockTemplateServiceIface)(nil).NewCreateTemplateParams), displaytext, name, ostypeid)
}

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

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

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

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

// NewGetUploadParamsForTemplateParams mocks base method.
func (m *MockTemplateServiceIface) NewGetUploadParamsForTemplateParams(displaytext, format, hypervisor, name, zoneid string) *GetUploadParamsForTemplateParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetUploadParamsForTemplateParams", displaytext, format, hypervisor, name, zoneid)
	ret0, _ := ret[0].(*GetUploadParamsForTemplateParams)
	return ret0
}

// NewGetUploadParamsForTemplateParams indicates an expected call of NewGetUploadParamsForTemplateParams.
func (mr *MockTemplateServiceIfaceMockRecorder) NewGetUploadParamsForTemplateParams(displaytext, format, hypervisor, name, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetUploadParamsForTemplateParams", reflect.TypeOf((*MockTemplateServiceIface)(nil).NewGetUploadParamsForTemplateParams), displaytext, format, hypervisor, name, zoneid)
}

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

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

// NewListTemplatesParams mocks base method.
func (m *MockTemplateServiceIface) NewListTemplatesParams(templatefilter string) *ListTemplatesParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListTemplatesParams", templatefilter)
	ret0, _ := ret[0].(*ListTemplatesParams)
	return ret0
}

// NewListTemplatesParams indicates an expected call of NewListTemplatesParams.
func (mr *MockTemplateServiceIfaceMockRecorder) NewListTemplatesParams(templatefilter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListTemplatesParams", reflect.TypeOf((*MockTemplateServiceIface)(nil).NewListTemplatesParams), templatefilter)
}

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

// NewPrepareTemplateParams indicates an expected call of NewPrepareTemplateParams.
func (mr *MockTemplateServiceIfaceMockRecorder) NewPrepareTemplateParams(templateid, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPrepareTemplateParams", reflect.TypeOf((*MockTemplateServiceIface)(nil).NewPrepareTemplateParams), templateid, zoneid)
}

// NewRegisterTemplateParams mocks base method.
func (m *MockTemplateServiceIface) NewRegisterTemplateParams(displaytext, format, hypervisor, name, url string) *RegisterTemplateParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRegisterTemplateParams", displaytext, format, hypervisor, name, url)
	ret0, _ := ret[0].(*RegisterTemplateParams)
	return ret0
}

// NewRegisterTemplateParams indicates an expected call of NewRegisterTemplateParams.
func (mr *MockTemplateServiceIfaceMockRecorder) NewRegisterTemplateParams(displaytext, format, hypervisor, name, url interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRegisterTemplateParams", reflect.TypeOf((*MockTemplateServiceIface)(nil).NewRegisterTemplateParams), displaytext, format, hypervisor, name, url)
}

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

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

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

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

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

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

// PrepareTemplate mocks base method.
func (m *MockTemplateServiceIface) PrepareTemplate(p *PrepareTemplateParams) (*PrepareTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PrepareTemplate", p)
	ret0, _ := ret[0].(*PrepareTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterTemplate mocks base method.
func (m *MockTemplateServiceIface) RegisterTemplate(p *RegisterTemplateParams) (*RegisterTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterTemplate", p)
	ret0, _ := ret[0].(*RegisterTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplate mocks base method.
func (m *MockTemplateServiceIface) UpdateTemplate(p *UpdateTemplateParams) (*UpdateTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplate", p)
	ret0, _ := ret[0].(*UpdateTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTemplatePermissions mocks base method.
func (m *MockTemplateServiceIface) UpdateTemplatePermissions(p *UpdateTemplatePermissionsParams) (*UpdateTemplatePermissionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplatePermissions", p)
	ret0, _ := ret[0].(*UpdateTemplatePermissionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpgradeRouterTemplate mocks base method.
func (m *MockTemplateServiceIface) UpgradeRouterTemplate(p *UpgradeRouterTemplateParams) (*UpgradeRouterTemplateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpgradeRouterTemplate", p)
	ret0, _ := ret[0].(*UpgradeRouterTemplateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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