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

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

import (
	reflect "reflect"

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

// MockSharedFileSystemServiceIface is a mock of SharedFileSystemServiceIface interface.
type MockSharedFileSystemServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockSharedFileSystemServiceIfaceMockRecorder
	isgomock struct{}
}

// MockSharedFileSystemServiceIfaceMockRecorder is the mock recorder for MockSharedFileSystemServiceIface.
type MockSharedFileSystemServiceIfaceMockRecorder struct {
	mock *MockSharedFileSystemServiceIface
}

// NewMockSharedFileSystemServiceIface creates a new mock instance.
func NewMockSharedFileSystemServiceIface(ctrl *gomock.Controller) *MockSharedFileSystemServiceIface {
	mock := &MockSharedFileSystemServiceIface{ctrl: ctrl}
	mock.recorder = &MockSharedFileSystemServiceIfaceMockRecorder{mock}
	return mock
}

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

// ChangeSharedFileSystemDiskOffering mocks base method.
func (m *MockSharedFileSystemServiceIface) ChangeSharedFileSystemDiskOffering(p *ChangeSharedFileSystemDiskOfferingParams) (*ChangeSharedFileSystemDiskOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeSharedFileSystemDiskOffering", p)
	ret0, _ := ret[0].(*ChangeSharedFileSystemDiskOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeSharedFileSystemServiceOffering mocks base method.
func (m *MockSharedFileSystemServiceIface) ChangeSharedFileSystemServiceOffering(p *ChangeSharedFileSystemServiceOfferingParams) (*ChangeSharedFileSystemServiceOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeSharedFileSystemServiceOffering", p)
	ret0, _ := ret[0].(*ChangeSharedFileSystemServiceOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) CreateSharedFileSystem(p *CreateSharedFileSystemParams) (*CreateSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSharedFileSystem", p)
	ret0, _ := ret[0].(*CreateSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DestroySharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) DestroySharedFileSystem(p *DestroySharedFileSystemParams) (*DestroySharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroySharedFileSystem", p)
	ret0, _ := ret[0].(*DestroySharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExpungeSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) ExpungeSharedFileSystem(p *ExpungeSharedFileSystemParams) (*ExpungeSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpungeSharedFileSystem", p)
	ret0, _ := ret[0].(*ExpungeSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// ListSharedFileSystemProviders mocks base method.
func (m *MockSharedFileSystemServiceIface) ListSharedFileSystemProviders(p *ListSharedFileSystemProvidersParams) (*ListSharedFileSystemProvidersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSharedFileSystemProviders", p)
	ret0, _ := ret[0].(*ListSharedFileSystemProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSharedFileSystems mocks base method.
func (m *MockSharedFileSystemServiceIface) ListSharedFileSystems(p *ListSharedFileSystemsParams) (*ListSharedFileSystemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSharedFileSystems", p)
	ret0, _ := ret[0].(*ListSharedFileSystemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// NewCreateSharedFileSystemParams mocks base method.
func (m *MockSharedFileSystemServiceIface) NewCreateSharedFileSystemParams(diskofferingid, filesystem, name, networkid, serviceofferingid, zoneid string) *CreateSharedFileSystemParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateSharedFileSystemParams", diskofferingid, filesystem, name, networkid, serviceofferingid, zoneid)
	ret0, _ := ret[0].(*CreateSharedFileSystemParams)
	return ret0
}

// NewCreateSharedFileSystemParams indicates an expected call of NewCreateSharedFileSystemParams.
func (mr *MockSharedFileSystemServiceIfaceMockRecorder) NewCreateSharedFileSystemParams(diskofferingid, filesystem, name, networkid, serviceofferingid, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateSharedFileSystemParams", reflect.TypeOf((*MockSharedFileSystemServiceIface)(nil).NewCreateSharedFileSystemParams), diskofferingid, filesystem, name, networkid, serviceofferingid, zoneid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RecoverSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) RecoverSharedFileSystem(p *RecoverSharedFileSystemParams) (*RecoverSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecoverSharedFileSystem", p)
	ret0, _ := ret[0].(*RecoverSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RestartSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) RestartSharedFileSystem(p *RestartSharedFileSystemParams) (*RestartSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestartSharedFileSystem", p)
	ret0, _ := ret[0].(*RestartSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) StartSharedFileSystem(p *StartSharedFileSystemParams) (*StartSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartSharedFileSystem", p)
	ret0, _ := ret[0].(*StartSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) StopSharedFileSystem(p *StopSharedFileSystemParams) (*StopSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopSharedFileSystem", p)
	ret0, _ := ret[0].(*StopSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateSharedFileSystem mocks base method.
func (m *MockSharedFileSystemServiceIface) UpdateSharedFileSystem(p *UpdateSharedFileSystemParams) (*UpdateSharedFileSystemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSharedFileSystem", p)
	ret0, _ := ret[0].(*UpdateSharedFileSystemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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