cloudstack/FirewallService_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/FirewallService.go

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

import (
	reflect "reflect"

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

// MockFirewallServiceIface is a mock of FirewallServiceIface interface.
type MockFirewallServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockFirewallServiceIfaceMockRecorder
}

// MockFirewallServiceIfaceMockRecorder is the mock recorder for MockFirewallServiceIface.
type MockFirewallServiceIfaceMockRecorder struct {
	mock *MockFirewallServiceIface
}

// NewMockFirewallServiceIface creates a new mock instance.
func NewMockFirewallServiceIface(ctrl *gomock.Controller) *MockFirewallServiceIface {
	mock := &MockFirewallServiceIface{ctrl: ctrl}
	mock.recorder = &MockFirewallServiceIfaceMockRecorder{mock}
	return mock
}

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

// AddPaloAltoFirewall mocks base method.
func (m *MockFirewallServiceIface) AddPaloAltoFirewall(p *AddPaloAltoFirewallParams) (*AddPaloAltoFirewallResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddPaloAltoFirewall", p)
	ret0, _ := ret[0].(*AddPaloAltoFirewallResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ConfigurePaloAltoFirewall mocks base method.
func (m *MockFirewallServiceIface) ConfigurePaloAltoFirewall(p *ConfigurePaloAltoFirewallParams) (*PaloAltoFirewallResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigurePaloAltoFirewall", p)
	ret0, _ := ret[0].(*PaloAltoFirewallResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateEgressFirewallRule mocks base method.
func (m *MockFirewallServiceIface) CreateEgressFirewallRule(p *CreateEgressFirewallRuleParams) (*CreateEgressFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEgressFirewallRule", p)
	ret0, _ := ret[0].(*CreateEgressFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFirewallRule mocks base method.
func (m *MockFirewallServiceIface) CreateFirewallRule(p *CreateFirewallRuleParams) (*CreateFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFirewallRule", p)
	ret0, _ := ret[0].(*CreateFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePortForwardingRule mocks base method.
func (m *MockFirewallServiceIface) CreatePortForwardingRule(p *CreatePortForwardingRuleParams) (*CreatePortForwardingRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePortForwardingRule", p)
	ret0, _ := ret[0].(*CreatePortForwardingRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteEgressFirewallRule mocks base method.
func (m *MockFirewallServiceIface) DeleteEgressFirewallRule(p *DeleteEgressFirewallRuleParams) (*DeleteEgressFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteEgressFirewallRule", p)
	ret0, _ := ret[0].(*DeleteEgressFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFirewallRule mocks base method.
func (m *MockFirewallServiceIface) DeleteFirewallRule(p *DeleteFirewallRuleParams) (*DeleteFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFirewallRule", p)
	ret0, _ := ret[0].(*DeleteFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePaloAltoFirewall mocks base method.
func (m *MockFirewallServiceIface) DeletePaloAltoFirewall(p *DeletePaloAltoFirewallParams) (*DeletePaloAltoFirewallResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePaloAltoFirewall", p)
	ret0, _ := ret[0].(*DeletePaloAltoFirewallResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePortForwardingRule mocks base method.
func (m *MockFirewallServiceIface) DeletePortForwardingRule(p *DeletePortForwardingRuleParams) (*DeletePortForwardingRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePortForwardingRule", p)
	ret0, _ := ret[0].(*DeletePortForwardingRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// ListEgressFirewallRules mocks base method.
func (m *MockFirewallServiceIface) ListEgressFirewallRules(p *ListEgressFirewallRulesParams) (*ListEgressFirewallRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEgressFirewallRules", p)
	ret0, _ := ret[0].(*ListEgressFirewallRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFirewallRules mocks base method.
func (m *MockFirewallServiceIface) ListFirewallRules(p *ListFirewallRulesParams) (*ListFirewallRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFirewallRules", p)
	ret0, _ := ret[0].(*ListFirewallRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPaloAltoFirewalls mocks base method.
func (m *MockFirewallServiceIface) ListPaloAltoFirewalls(p *ListPaloAltoFirewallsParams) (*ListPaloAltoFirewallsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPaloAltoFirewalls", p)
	ret0, _ := ret[0].(*ListPaloAltoFirewallsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPortForwardingRules mocks base method.
func (m *MockFirewallServiceIface) ListPortForwardingRules(p *ListPortForwardingRulesParams) (*ListPortForwardingRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPortForwardingRules", p)
	ret0, _ := ret[0].(*ListPortForwardingRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewConfigurePaloAltoFirewallParams mocks base method.
func (m *MockFirewallServiceIface) NewConfigurePaloAltoFirewallParams(fwdeviceid string) *ConfigurePaloAltoFirewallParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewConfigurePaloAltoFirewallParams", fwdeviceid)
	ret0, _ := ret[0].(*ConfigurePaloAltoFirewallParams)
	return ret0
}

// NewConfigurePaloAltoFirewallParams indicates an expected call of NewConfigurePaloAltoFirewallParams.
func (mr *MockFirewallServiceIfaceMockRecorder) NewConfigurePaloAltoFirewallParams(fwdeviceid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConfigurePaloAltoFirewallParams", reflect.TypeOf((*MockFirewallServiceIface)(nil).NewConfigurePaloAltoFirewallParams), fwdeviceid)
}

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

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

// NewCreateFirewallRuleParams mocks base method.
func (m *MockFirewallServiceIface) NewCreateFirewallRuleParams(ipaddressid, protocol string) *CreateFirewallRuleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateFirewallRuleParams", ipaddressid, protocol)
	ret0, _ := ret[0].(*CreateFirewallRuleParams)
	return ret0
}

// NewCreateFirewallRuleParams indicates an expected call of NewCreateFirewallRuleParams.
func (mr *MockFirewallServiceIfaceMockRecorder) NewCreateFirewallRuleParams(ipaddressid, protocol interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateFirewallRuleParams", reflect.TypeOf((*MockFirewallServiceIface)(nil).NewCreateFirewallRuleParams), ipaddressid, protocol)
}

// NewCreatePortForwardingRuleParams mocks base method.
func (m *MockFirewallServiceIface) NewCreatePortForwardingRuleParams(ipaddressid string, privateport int, protocol string, publicport int, virtualmachineid string) *CreatePortForwardingRuleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreatePortForwardingRuleParams", ipaddressid, privateport, protocol, publicport, virtualmachineid)
	ret0, _ := ret[0].(*CreatePortForwardingRuleParams)
	return ret0
}

// NewCreatePortForwardingRuleParams indicates an expected call of NewCreatePortForwardingRuleParams.
func (mr *MockFirewallServiceIfaceMockRecorder) NewCreatePortForwardingRuleParams(ipaddressid, privateport, protocol, publicport, virtualmachineid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreatePortForwardingRuleParams", reflect.TypeOf((*MockFirewallServiceIface)(nil).NewCreatePortForwardingRuleParams), ipaddressid, privateport, protocol, publicport, virtualmachineid)
}

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

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

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

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

// NewDeletePaloAltoFirewallParams mocks base method.
func (m *MockFirewallServiceIface) NewDeletePaloAltoFirewallParams(fwdeviceid string) *DeletePaloAltoFirewallParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeletePaloAltoFirewallParams", fwdeviceid)
	ret0, _ := ret[0].(*DeletePaloAltoFirewallParams)
	return ret0
}

// NewDeletePaloAltoFirewallParams indicates an expected call of NewDeletePaloAltoFirewallParams.
func (mr *MockFirewallServiceIfaceMockRecorder) NewDeletePaloAltoFirewallParams(fwdeviceid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeletePaloAltoFirewallParams", reflect.TypeOf((*MockFirewallServiceIface)(nil).NewDeletePaloAltoFirewallParams), fwdeviceid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateEgressFirewallRule mocks base method.
func (m *MockFirewallServiceIface) UpdateEgressFirewallRule(p *UpdateEgressFirewallRuleParams) (*UpdateEgressFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEgressFirewallRule", p)
	ret0, _ := ret[0].(*UpdateEgressFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFirewallRule mocks base method.
func (m *MockFirewallServiceIface) UpdateFirewallRule(p *UpdateFirewallRuleParams) (*UpdateFirewallRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFirewallRule", p)
	ret0, _ := ret[0].(*UpdateFirewallRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePortForwardingRule mocks base method.
func (m *MockFirewallServiceIface) UpdatePortForwardingRule(p *UpdatePortForwardingRuleParams) (*UpdatePortForwardingRuleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePortForwardingRule", p)
	ret0, _ := ret[0].(*UpdatePortForwardingRuleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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