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

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

import (
	reflect "reflect"

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

// MockBackupServiceIface is a mock of BackupServiceIface interface.
type MockBackupServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockBackupServiceIfaceMockRecorder
	isgomock struct{}
}

// MockBackupServiceIfaceMockRecorder is the mock recorder for MockBackupServiceIface.
type MockBackupServiceIfaceMockRecorder struct {
	mock *MockBackupServiceIface
}

// NewMockBackupServiceIface creates a new mock instance.
func NewMockBackupServiceIface(ctrl *gomock.Controller) *MockBackupServiceIface {
	mock := &MockBackupServiceIface{ctrl: ctrl}
	mock.recorder = &MockBackupServiceIfaceMockRecorder{mock}
	return mock
}

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

// AddBackupRepository mocks base method.
func (m *MockBackupServiceIface) AddBackupRepository(p *AddBackupRepositoryParams) (*AddBackupRepositoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBackupRepository", p)
	ret0, _ := ret[0].(*AddBackupRepositoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBackup mocks base method.
func (m *MockBackupServiceIface) CreateBackup(p *CreateBackupParams) (*CreateBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBackup", p)
	ret0, _ := ret[0].(*CreateBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateBackupSchedule mocks base method.
func (m *MockBackupServiceIface) CreateBackupSchedule(p *CreateBackupScheduleParams) (*CreateBackupScheduleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBackupSchedule", p)
	ret0, _ := ret[0].(*CreateBackupScheduleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateVMFromBackup mocks base method.
func (m *MockBackupServiceIface) CreateVMFromBackup(p *CreateVMFromBackupParams) (*CreateVMFromBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVMFromBackup", p)
	ret0, _ := ret[0].(*CreateVMFromBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBackup mocks base method.
func (m *MockBackupServiceIface) DeleteBackup(p *DeleteBackupParams) (*DeleteBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackup", p)
	ret0, _ := ret[0].(*DeleteBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBackupOffering mocks base method.
func (m *MockBackupServiceIface) DeleteBackupOffering(p *DeleteBackupOfferingParams) (*DeleteBackupOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackupOffering", p)
	ret0, _ := ret[0].(*DeleteBackupOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBackupRepository mocks base method.
func (m *MockBackupServiceIface) DeleteBackupRepository(p *DeleteBackupRepositoryParams) (*DeleteBackupRepositoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackupRepository", p)
	ret0, _ := ret[0].(*DeleteBackupRepositoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteBackupSchedule mocks base method.
func (m *MockBackupServiceIface) DeleteBackupSchedule(p *DeleteBackupScheduleParams) (*DeleteBackupScheduleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackupSchedule", p)
	ret0, _ := ret[0].(*DeleteBackupScheduleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetBackupProviderOfferingID indicates an expected call of GetBackupProviderOfferingID.
func (mr *MockBackupServiceIfaceMockRecorder) GetBackupProviderOfferingID(keyword, zoneid any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keyword, zoneid}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBackupProviderOfferingID", reflect.TypeOf((*MockBackupServiceIface)(nil).GetBackupProviderOfferingID), varargs...)
}

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

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

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

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

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

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

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

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

// ImportBackupOffering mocks base method.
func (m *MockBackupServiceIface) ImportBackupOffering(p *ImportBackupOfferingParams) (*ImportBackupOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportBackupOffering", p)
	ret0, _ := ret[0].(*ImportBackupOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackupOfferings mocks base method.
func (m *MockBackupServiceIface) ListBackupOfferings(p *ListBackupOfferingsParams) (*ListBackupOfferingsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupOfferings", p)
	ret0, _ := ret[0].(*ListBackupOfferingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackupProviderOfferings mocks base method.
func (m *MockBackupServiceIface) ListBackupProviderOfferings(p *ListBackupProviderOfferingsParams) (*ListBackupProviderOfferingsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupProviderOfferings", p)
	ret0, _ := ret[0].(*ListBackupProviderOfferingsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackupProviders mocks base method.
func (m *MockBackupServiceIface) ListBackupProviders(p *ListBackupProvidersParams) (*ListBackupProvidersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupProviders", p)
	ret0, _ := ret[0].(*ListBackupProvidersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackupRepositories mocks base method.
func (m *MockBackupServiceIface) ListBackupRepositories(p *ListBackupRepositoriesParams) (*ListBackupRepositoriesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupRepositories", p)
	ret0, _ := ret[0].(*ListBackupRepositoriesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackupSchedule mocks base method.
func (m *MockBackupServiceIface) ListBackupSchedule(p *ListBackupScheduleParams) (*ListBackupScheduleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupSchedule", p)
	ret0, _ := ret[0].(*ListBackupScheduleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListBackups mocks base method.
func (m *MockBackupServiceIface) ListBackups(p *ListBackupsParams) (*ListBackupsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackups", p)
	ret0, _ := ret[0].(*ListBackupsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NewAddBackupRepositoryParams mocks base method.
func (m *MockBackupServiceIface) NewAddBackupRepositoryParams(address, name, backupType, zoneid string) *AddBackupRepositoryParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddBackupRepositoryParams", address, name, backupType, zoneid)
	ret0, _ := ret[0].(*AddBackupRepositoryParams)
	return ret0
}

// NewAddBackupRepositoryParams indicates an expected call of NewAddBackupRepositoryParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewAddBackupRepositoryParams(address, name, backupType, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddBackupRepositoryParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewAddBackupRepositoryParams), address, name, backupType, zoneid)
}

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

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

// NewCreateBackupScheduleParams mocks base method.
func (m *MockBackupServiceIface) NewCreateBackupScheduleParams(intervaltype, schedule, timezone, virtualmachineid string) *CreateBackupScheduleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateBackupScheduleParams", intervaltype, schedule, timezone, virtualmachineid)
	ret0, _ := ret[0].(*CreateBackupScheduleParams)
	return ret0
}

// NewCreateBackupScheduleParams indicates an expected call of NewCreateBackupScheduleParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewCreateBackupScheduleParams(intervaltype, schedule, timezone, virtualmachineid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateBackupScheduleParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewCreateBackupScheduleParams), intervaltype, schedule, timezone, virtualmachineid)
}

// NewCreateVMFromBackupParams mocks base method.
func (m *MockBackupServiceIface) NewCreateVMFromBackupParams(backupid, zoneid string) *CreateVMFromBackupParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewCreateVMFromBackupParams", backupid, zoneid)
	ret0, _ := ret[0].(*CreateVMFromBackupParams)
	return ret0
}

// NewCreateVMFromBackupParams indicates an expected call of NewCreateVMFromBackupParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewCreateVMFromBackupParams(backupid, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCreateVMFromBackupParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewCreateVMFromBackupParams), backupid, zoneid)
}

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

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

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

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

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

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

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

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

// NewImportBackupOfferingParams mocks base method.
func (m *MockBackupServiceIface) NewImportBackupOfferingParams(allowuserdrivenbackups bool, description, externalid, name, zoneid string) *ImportBackupOfferingParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewImportBackupOfferingParams", allowuserdrivenbackups, description, externalid, name, zoneid)
	ret0, _ := ret[0].(*ImportBackupOfferingParams)
	return ret0
}

// NewImportBackupOfferingParams indicates an expected call of NewImportBackupOfferingParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewImportBackupOfferingParams(allowuserdrivenbackups, description, externalid, name, zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewImportBackupOfferingParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewImportBackupOfferingParams), allowuserdrivenbackups, description, externalid, name, zoneid)
}

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

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

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

// NewListBackupProviderOfferingsParams indicates an expected call of NewListBackupProviderOfferingsParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewListBackupProviderOfferingsParams(zoneid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListBackupProviderOfferingsParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewListBackupProviderOfferingsParams), zoneid)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewUpdateBackupScheduleParams mocks base method.
func (m *MockBackupServiceIface) NewUpdateBackupScheduleParams(intervaltype, schedule, timezone, virtualmachineid string) *UpdateBackupScheduleParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateBackupScheduleParams", intervaltype, schedule, timezone, virtualmachineid)
	ret0, _ := ret[0].(*UpdateBackupScheduleParams)
	return ret0
}

// NewUpdateBackupScheduleParams indicates an expected call of NewUpdateBackupScheduleParams.
func (mr *MockBackupServiceIfaceMockRecorder) NewUpdateBackupScheduleParams(intervaltype, schedule, timezone, virtualmachineid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateBackupScheduleParams", reflect.TypeOf((*MockBackupServiceIface)(nil).NewUpdateBackupScheduleParams), intervaltype, schedule, timezone, virtualmachineid)
}

// RestoreBackup mocks base method.
func (m *MockBackupServiceIface) RestoreBackup(p *RestoreBackupParams) (*RestoreBackupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreBackup", p)
	ret0, _ := ret[0].(*RestoreBackupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBackupOffering mocks base method.
func (m *MockBackupServiceIface) UpdateBackupOffering(p *UpdateBackupOfferingParams) (*UpdateBackupOfferingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBackupOffering", p)
	ret0, _ := ret[0].(*UpdateBackupOfferingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBackupRepository mocks base method.
func (m *MockBackupServiceIface) UpdateBackupRepository(p *UpdateBackupRepositoryParams) (*UpdateBackupRepositoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBackupRepository", p)
	ret0, _ := ret[0].(*UpdateBackupRepositoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBackupSchedule mocks base method.
func (m *MockBackupServiceIface) UpdateBackupSchedule(p *UpdateBackupScheduleParams) (*UpdateBackupScheduleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBackupSchedule", p)
	ret0, _ := ret[0].(*UpdateBackupScheduleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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