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

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

import (
	reflect "reflect"

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

// MockVolumeServiceIface is a mock of VolumeServiceIface interface.
type MockVolumeServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockVolumeServiceIfaceMockRecorder
	isgomock struct{}
}

// MockVolumeServiceIfaceMockRecorder is the mock recorder for MockVolumeServiceIface.
type MockVolumeServiceIfaceMockRecorder struct {
	mock *MockVolumeServiceIface
}

// NewMockVolumeServiceIface creates a new mock instance.
func NewMockVolumeServiceIface(ctrl *gomock.Controller) *MockVolumeServiceIface {
	mock := &MockVolumeServiceIface{ctrl: ctrl}
	mock.recorder = &MockVolumeServiceIfaceMockRecorder{mock}
	return mock
}

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

// AssignVolume mocks base method.
func (m *MockVolumeServiceIface) AssignVolume(p *AssignVolumeParams) (*AssignVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignVolume", p)
	ret0, _ := ret[0].(*AssignVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AttachVolume mocks base method.
func (m *MockVolumeServiceIface) AttachVolume(p *AttachVolumeParams) (*AttachVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AttachVolume", p)
	ret0, _ := ret[0].(*AttachVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeOfferingForVolume mocks base method.
func (m *MockVolumeServiceIface) ChangeOfferingForVolume(p *ChangeOfferingForVolumeParams) (*ChangeOfferingForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChangeOfferingForVolume", p)
	ret0, _ := ret[0].(*ChangeOfferingForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckVolume mocks base method.
func (m *MockVolumeServiceIface) CheckVolume(p *CheckVolumeParams) (*CheckVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckVolume", p)
	ret0, _ := ret[0].(*CheckVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVolume mocks base method.
func (m *MockVolumeServiceIface) CreateVolume(p *CreateVolumeParams) (*CreateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolume", p)
	ret0, _ := ret[0].(*CreateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteVolume mocks base method.
func (m *MockVolumeServiceIface) DeleteVolume(p *DeleteVolumeParams) (*DeleteVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteVolume", p)
	ret0, _ := ret[0].(*DeleteVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DestroyVolume mocks base method.
func (m *MockVolumeServiceIface) DestroyVolume(p *DestroyVolumeParams) (*DestroyVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DestroyVolume", p)
	ret0, _ := ret[0].(*DestroyVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DetachVolume mocks base method.
func (m *MockVolumeServiceIface) DetachVolume(p *DetachVolumeParams) (*DetachVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DetachVolume", p)
	ret0, _ := ret[0].(*DetachVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExtractVolume mocks base method.
func (m *MockVolumeServiceIface) ExtractVolume(p *ExtractVolumeParams) (*ExtractVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractVolume", p)
	ret0, _ := ret[0].(*ExtractVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetPathForVolume mocks base method.
func (m *MockVolumeServiceIface) GetPathForVolume(p *GetPathForVolumeParams) (*GetPathForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPathForVolume", p)
	ret0, _ := ret[0].(*GetPathForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUploadParamsForVolume mocks base method.
func (m *MockVolumeServiceIface) GetUploadParamsForVolume(p *GetUploadParamsForVolumeParams) (*GetUploadParamsForVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUploadParamsForVolume", p)
	ret0, _ := ret[0].(*GetUploadParamsForVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// GetVolumeiScsiName mocks base method.
func (m *MockVolumeServiceIface) GetVolumeiScsiName(p *GetVolumeiScsiNameParams) (*GetVolumeiScsiNameResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVolumeiScsiName", p)
	ret0, _ := ret[0].(*GetVolumeiScsiNameResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ImportVolume mocks base method.
func (m *MockVolumeServiceIface) ImportVolume(p *ImportVolumeParams) (*ImportVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportVolume", p)
	ret0, _ := ret[0].(*ImportVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListElastistorVolume mocks base method.
func (m *MockVolumeServiceIface) ListElastistorVolume(p *ListElastistorVolumeParams) (*ListElastistorVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListElastistorVolume", p)
	ret0, _ := ret[0].(*ListElastistorVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVolumes mocks base method.
func (m *MockVolumeServiceIface) ListVolumes(p *ListVolumesParams) (*ListVolumesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumes", p)
	ret0, _ := ret[0].(*ListVolumesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVolumesForImport mocks base method.
func (m *MockVolumeServiceIface) ListVolumesForImport(p *ListVolumesForImportParams) (*ListVolumesForImportResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumesForImport", p)
	ret0, _ := ret[0].(*ListVolumesForImportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVolumesMetrics mocks base method.
func (m *MockVolumeServiceIface) ListVolumesMetrics(p *ListVolumesMetricsParams) (*ListVolumesMetricsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumesMetrics", p)
	ret0, _ := ret[0].(*ListVolumesMetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListVolumesUsageHistory mocks base method.
func (m *MockVolumeServiceIface) ListVolumesUsageHistory(p *ListVolumesUsageHistoryParams) (*ListVolumesUsageHistoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVolumesUsageHistory", p)
	ret0, _ := ret[0].(*ListVolumesUsageHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MigrateVolume mocks base method.
func (m *MockVolumeServiceIface) MigrateVolume(p *MigrateVolumeParams) (*MigrateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MigrateVolume", p)
	ret0, _ := ret[0].(*MigrateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewAssignVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewAssignVolumeParams(volumeid string) *AssignVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAssignVolumeParams", volumeid)
	ret0, _ := ret[0].(*AssignVolumeParams)
	return ret0
}

// NewAssignVolumeParams indicates an expected call of NewAssignVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewAssignVolumeParams(volumeid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAssignVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewAssignVolumeParams), volumeid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewExtractVolumeParams indicates an expected call of NewExtractVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewExtractVolumeParams(id, mode, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewExtractVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewExtractVolumeParams), id, mode, zoneid)
}

// NewGetPathForVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewGetPathForVolumeParams(volumeid string) *GetPathForVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetPathForVolumeParams", volumeid)
	ret0, _ := ret[0].(*GetPathForVolumeParams)
	return ret0
}

// NewGetPathForVolumeParams indicates an expected call of NewGetPathForVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetPathForVolumeParams(volumeid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetPathForVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetPathForVolumeParams), volumeid)
}

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

// NewGetUploadParamsForVolumeParams indicates an expected call of NewGetUploadParamsForVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetUploadParamsForVolumeParams(format, name, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetUploadParamsForVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetUploadParamsForVolumeParams), format, name, zoneid)
}

// NewGetVolumeiScsiNameParams mocks base method.
func (m *MockVolumeServiceIface) NewGetVolumeiScsiNameParams(volumeid string) *GetVolumeiScsiNameParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewGetVolumeiScsiNameParams", volumeid)
	ret0, _ := ret[0].(*GetVolumeiScsiNameParams)
	return ret0
}

// NewGetVolumeiScsiNameParams indicates an expected call of NewGetVolumeiScsiNameParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewGetVolumeiScsiNameParams(volumeid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewGetVolumeiScsiNameParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewGetVolumeiScsiNameParams), volumeid)
}

// NewImportVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewImportVolumeParams(path, storageid string) *ImportVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewImportVolumeParams", path, storageid)
	ret0, _ := ret[0].(*ImportVolumeParams)
	return ret0
}

// NewImportVolumeParams indicates an expected call of NewImportVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewImportVolumeParams(path, storageid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewImportVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewImportVolumeParams), path, storageid)
}

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

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

// NewListVolumesForImportParams mocks base method.
func (m *MockVolumeServiceIface) NewListVolumesForImportParams(storageid string) *ListVolumesForImportParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewListVolumesForImportParams", storageid)
	ret0, _ := ret[0].(*ListVolumesForImportParams)
	return ret0
}

// NewListVolumesForImportParams indicates an expected call of NewListVolumesForImportParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewListVolumesForImportParams(storageid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListVolumesForImportParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewListVolumesForImportParams), storageid)
}

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

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

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

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

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

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

// NewMigrateVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewMigrateVolumeParams(storageid, volumeid string) *MigrateVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewMigrateVolumeParams", storageid, volumeid)
	ret0, _ := ret[0].(*MigrateVolumeParams)
	return ret0
}

// NewMigrateVolumeParams indicates an expected call of NewMigrateVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewMigrateVolumeParams(storageid, volumeid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMigrateVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewMigrateVolumeParams), storageid, volumeid)
}

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

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

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

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

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

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

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

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

// NewUploadVolumeParams mocks base method.
func (m *MockVolumeServiceIface) NewUploadVolumeParams(format, name, url, zoneid string) *UploadVolumeParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUploadVolumeParams", format, name, url, zoneid)
	ret0, _ := ret[0].(*UploadVolumeParams)
	return ret0
}

// NewUploadVolumeParams indicates an expected call of NewUploadVolumeParams.
func (mr *MockVolumeServiceIfaceMockRecorder) NewUploadVolumeParams(format, name, url, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUploadVolumeParams", reflect.TypeOf((*MockVolumeServiceIface)(nil).NewUploadVolumeParams), format, name, url, zoneid)
}

// RecoverVolume mocks base method.
func (m *MockVolumeServiceIface) RecoverVolume(p *RecoverVolumeParams) (*RecoverVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecoverVolume", p)
	ret0, _ := ret[0].(*RecoverVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResizeVolume mocks base method.
func (m *MockVolumeServiceIface) ResizeVolume(p *ResizeVolumeParams) (*ResizeVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResizeVolume", p)
	ret0, _ := ret[0].(*ResizeVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnmanageVolume mocks base method.
func (m *MockVolumeServiceIface) UnmanageVolume(p *UnmanageVolumeParams) (*UnmanageVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnmanageVolume", p)
	ret0, _ := ret[0].(*UnmanageVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateVolume mocks base method.
func (m *MockVolumeServiceIface) UpdateVolume(p *UpdateVolumeParams) (*UpdateVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVolume", p)
	ret0, _ := ret[0].(*UpdateVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UploadVolume mocks base method.
func (m *MockVolumeServiceIface) UploadVolume(p *UploadVolumeParams) (*UploadVolumeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UploadVolume", p)
	ret0, _ := ret[0].(*UploadVolumeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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