github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/apiserver/common/crossmodel/mocks/crossmodel_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/apiserver/common/crossmodel (interfaces: OfferBakeryInterface,Backend)
//
// Generated by this command:
//
//	mockgen -package mocks -destination mocks/crossmodel_mock.go github.com/juju/juju/apiserver/common/crossmodel OfferBakeryInterface,Backend
//

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

import (
	context "context"
	reflect "reflect"

	bakery "github.com/go-macaroon-bakery/macaroon-bakery/v3/bakery"
	checkers "github.com/go-macaroon-bakery/macaroon-bakery/v3/bakery/checkers"
	clock "github.com/juju/clock"
	authentication "github.com/juju/juju/apiserver/authentication"
	crossmodel "github.com/juju/juju/apiserver/common/crossmodel"
	crossmodel0 "github.com/juju/juju/core/crossmodel"
	permission "github.com/juju/juju/core/permission"
	secrets "github.com/juju/juju/core/secrets"
	config "github.com/juju/juju/environs/config"
	state "github.com/juju/juju/state"
	names "github.com/juju/names/v5"
	gomock "go.uber.org/mock/gomock"
	macaroon "gopkg.in/macaroon.v2"
)

// MockOfferBakeryInterface is a mock of OfferBakeryInterface interface.
type MockOfferBakeryInterface struct {
	ctrl     *gomock.Controller
	recorder *MockOfferBakeryInterfaceMockRecorder
}

// MockOfferBakeryInterfaceMockRecorder is the mock recorder for MockOfferBakeryInterface.
type MockOfferBakeryInterfaceMockRecorder struct {
	mock *MockOfferBakeryInterface
}

// NewMockOfferBakeryInterface creates a new mock instance.
func NewMockOfferBakeryInterface(ctrl *gomock.Controller) *MockOfferBakeryInterface {
	mock := &MockOfferBakeryInterface{ctrl: ctrl}
	mock.recorder = &MockOfferBakeryInterfaceMockRecorder{mock}
	return mock
}

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

// CreateDischargeMacaroon mocks base method.
func (m *MockOfferBakeryInterface) CreateDischargeMacaroon(arg0 context.Context, arg1, arg2 string, arg3, arg4 map[string]string, arg5 bakery.Op, arg6 bakery.Version) (*bakery.Macaroon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDischargeMacaroon", arg0, arg1, arg2, arg3, arg4, arg5, arg6)
	ret0, _ := ret[0].(*bakery.Macaroon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDischargeMacaroon indicates an expected call of CreateDischargeMacaroon.
func (mr *MockOfferBakeryInterfaceMockRecorder) CreateDischargeMacaroon(arg0, arg1, arg2, arg3, arg4, arg5, arg6 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDischargeMacaroon", reflect.TypeOf((*MockOfferBakeryInterface)(nil).CreateDischargeMacaroon), arg0, arg1, arg2, arg3, arg4, arg5, arg6)
}

// GetConsumeOfferCaveats mocks base method.
func (m *MockOfferBakeryInterface) GetConsumeOfferCaveats(arg0, arg1, arg2 string) []checkers.Caveat {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsumeOfferCaveats", arg0, arg1, arg2)
	ret0, _ := ret[0].([]checkers.Caveat)
	return ret0
}

// GetConsumeOfferCaveats indicates an expected call of GetConsumeOfferCaveats.
func (mr *MockOfferBakeryInterfaceMockRecorder) GetConsumeOfferCaveats(arg0, arg1, arg2 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsumeOfferCaveats", reflect.TypeOf((*MockOfferBakeryInterface)(nil).GetConsumeOfferCaveats), arg0, arg1, arg2)
}

// InferDeclaredFromMacaroon mocks base method.
func (m *MockOfferBakeryInterface) InferDeclaredFromMacaroon(arg0 macaroon.Slice, arg1 map[string]string) map[string]string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InferDeclaredFromMacaroon", arg0, arg1)
	ret0, _ := ret[0].(map[string]string)
	return ret0
}

// InferDeclaredFromMacaroon indicates an expected call of InferDeclaredFromMacaroon.
func (mr *MockOfferBakeryInterfaceMockRecorder) InferDeclaredFromMacaroon(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InferDeclaredFromMacaroon", reflect.TypeOf((*MockOfferBakeryInterface)(nil).InferDeclaredFromMacaroon), arg0, arg1)
}

// RefreshDischargeURL mocks base method.
func (m *MockOfferBakeryInterface) RefreshDischargeURL(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshDischargeURL", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RefreshDischargeURL indicates an expected call of RefreshDischargeURL.
func (mr *MockOfferBakeryInterfaceMockRecorder) RefreshDischargeURL(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshDischargeURL", reflect.TypeOf((*MockOfferBakeryInterface)(nil).RefreshDischargeURL), arg0)
}

// getBakery mocks base method.
func (m *MockOfferBakeryInterface) getBakery() authentication.ExpirableStorageBakery {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "getBakery")
	ret0, _ := ret[0].(authentication.ExpirableStorageBakery)
	return ret0
}

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

// getClock mocks base method.
func (m *MockOfferBakeryInterface) getClock() clock.Clock {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "getClock")
	ret0, _ := ret[0].(clock.Clock)
	return ret0
}

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

// setClock mocks base method.
func (m *MockOfferBakeryInterface) setClock(arg0 clock.Clock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setClock", arg0)
}

// setClock indicates an expected call of setClock.
func (mr *MockOfferBakeryInterfaceMockRecorder) setClock(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setClock", reflect.TypeOf((*MockOfferBakeryInterface)(nil).setClock), arg0)
}

// MockBackend is a mock of Backend interface.
type MockBackend struct {
	ctrl     *gomock.Controller
	recorder *MockBackendMockRecorder
}

// MockBackendMockRecorder is the mock recorder for MockBackend.
type MockBackendMockRecorder struct {
	mock *MockBackend
}

// NewMockBackend creates a new mock instance.
func NewMockBackend(ctrl *gomock.Controller) *MockBackend {
	mock := &MockBackend{ctrl: ctrl}
	mock.recorder = &MockBackendMockRecorder{mock}
	return mock
}

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

// AddRelation mocks base method.
func (m *MockBackend) AddRelation(arg0 ...state.Endpoint) (crossmodel.Relation, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddRelation", varargs...)
	ret0, _ := ret[0].(crossmodel.Relation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddRelation indicates an expected call of AddRelation.
func (mr *MockBackendMockRecorder) AddRelation(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRelation", reflect.TypeOf((*MockBackend)(nil).AddRelation), arg0...)
}

// AddRemoteApplication mocks base method.
func (m *MockBackend) AddRemoteApplication(arg0 state.AddRemoteApplicationParams) (crossmodel.RemoteApplication, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRemoteApplication", arg0)
	ret0, _ := ret[0].(crossmodel.RemoteApplication)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddRemoteApplication indicates an expected call of AddRemoteApplication.
func (mr *MockBackendMockRecorder) AddRemoteApplication(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRemoteApplication", reflect.TypeOf((*MockBackend)(nil).AddRemoteApplication), arg0)
}

// AllModelUUIDs mocks base method.
func (m *MockBackend) AllModelUUIDs() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllModelUUIDs")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Application mocks base method.
func (m *MockBackend) Application(arg0 string) (crossmodel.Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Application", arg0)
	ret0, _ := ret[0].(crossmodel.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Application indicates an expected call of Application.
func (mr *MockBackendMockRecorder) Application(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Application", reflect.TypeOf((*MockBackend)(nil).Application), arg0)
}

// ApplicationOfferForUUID mocks base method.
func (m *MockBackend) ApplicationOfferForUUID(arg0 string) (*crossmodel0.ApplicationOffer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplicationOfferForUUID", arg0)
	ret0, _ := ret[0].(*crossmodel0.ApplicationOffer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplicationOfferForUUID indicates an expected call of ApplicationOfferForUUID.
func (mr *MockBackendMockRecorder) ApplicationOfferForUUID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplicationOfferForUUID", reflect.TypeOf((*MockBackend)(nil).ApplicationOfferForUUID), arg0)
}

// ApplyOperation mocks base method.
func (m *MockBackend) ApplyOperation(arg0 state.ModelOperation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyOperation", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyOperation indicates an expected call of ApplyOperation.
func (mr *MockBackendMockRecorder) ApplyOperation(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyOperation", reflect.TypeOf((*MockBackend)(nil).ApplyOperation), arg0)
}

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

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

// EndpointsRelation mocks base method.
func (m *MockBackend) EndpointsRelation(arg0 ...state.Endpoint) (crossmodel.Relation, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EndpointsRelation", varargs...)
	ret0, _ := ret[0].(crossmodel.Relation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EndpointsRelation indicates an expected call of EndpointsRelation.
func (mr *MockBackendMockRecorder) EndpointsRelation(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndpointsRelation", reflect.TypeOf((*MockBackend)(nil).EndpointsRelation), arg0...)
}

// ExportLocalEntity mocks base method.
func (m *MockBackend) ExportLocalEntity(arg0 names.Tag) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportLocalEntity", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportLocalEntity indicates an expected call of ExportLocalEntity.
func (mr *MockBackendMockRecorder) ExportLocalEntity(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportLocalEntity", reflect.TypeOf((*MockBackend)(nil).ExportLocalEntity), arg0)
}

// GetOfferAccess mocks base method.
func (m *MockBackend) GetOfferAccess(arg0 string, arg1 names.UserTag) (permission.Access, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOfferAccess", arg0, arg1)
	ret0, _ := ret[0].(permission.Access)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOfferAccess indicates an expected call of GetOfferAccess.
func (mr *MockBackendMockRecorder) GetOfferAccess(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOfferAccess", reflect.TypeOf((*MockBackend)(nil).GetOfferAccess), arg0, arg1)
}

// GetRemoteEntity mocks base method.
func (m *MockBackend) GetRemoteEntity(arg0 string) (names.Tag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRemoteEntity", arg0)
	ret0, _ := ret[0].(names.Tag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRemoteEntity indicates an expected call of GetRemoteEntity.
func (mr *MockBackendMockRecorder) GetRemoteEntity(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteEntity", reflect.TypeOf((*MockBackend)(nil).GetRemoteEntity), arg0)
}

// GetToken mocks base method.
func (m *MockBackend) GetToken(arg0 names.Tag) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetToken", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetToken indicates an expected call of GetToken.
func (mr *MockBackendMockRecorder) GetToken(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetToken", reflect.TypeOf((*MockBackend)(nil).GetToken), arg0)
}

// ImportRemoteEntity mocks base method.
func (m *MockBackend) ImportRemoteEntity(arg0 names.Tag, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportRemoteEntity", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ImportRemoteEntity indicates an expected call of ImportRemoteEntity.
func (mr *MockBackendMockRecorder) ImportRemoteEntity(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportRemoteEntity", reflect.TypeOf((*MockBackend)(nil).ImportRemoteEntity), arg0, arg1)
}

// IngressNetworks mocks base method.
func (m *MockBackend) IngressNetworks(arg0 string) (state.RelationNetworks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IngressNetworks", arg0)
	ret0, _ := ret[0].(state.RelationNetworks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IngressNetworks indicates an expected call of IngressNetworks.
func (mr *MockBackendMockRecorder) IngressNetworks(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IngressNetworks", reflect.TypeOf((*MockBackend)(nil).IngressNetworks), arg0)
}

// KeyRelation mocks base method.
func (m *MockBackend) KeyRelation(arg0 string) (crossmodel.Relation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "KeyRelation", arg0)
	ret0, _ := ret[0].(crossmodel.Relation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// KeyRelation indicates an expected call of KeyRelation.
func (mr *MockBackendMockRecorder) KeyRelation(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyRelation", reflect.TypeOf((*MockBackend)(nil).KeyRelation), arg0)
}

// ModelConfig mocks base method.
func (m *MockBackend) ModelConfig() (*config.Config, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModelConfig")
	ret0, _ := ret[0].(*config.Config)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// OfferConnectionForRelation mocks base method.
func (m *MockBackend) OfferConnectionForRelation(arg0 string) (crossmodel.OfferConnection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OfferConnectionForRelation", arg0)
	ret0, _ := ret[0].(crossmodel.OfferConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfferConnectionForRelation indicates an expected call of OfferConnectionForRelation.
func (mr *MockBackendMockRecorder) OfferConnectionForRelation(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfferConnectionForRelation", reflect.TypeOf((*MockBackend)(nil).OfferConnectionForRelation), arg0)
}

// OfferUUIDForRelation mocks base method.
func (m *MockBackend) OfferUUIDForRelation(arg0 string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OfferUUIDForRelation", arg0)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfferUUIDForRelation indicates an expected call of OfferUUIDForRelation.
func (mr *MockBackendMockRecorder) OfferUUIDForRelation(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfferUUIDForRelation", reflect.TypeOf((*MockBackend)(nil).OfferUUIDForRelation), arg0)
}

// RemoteApplication mocks base method.
func (m *MockBackend) RemoteApplication(arg0 string) (crossmodel.RemoteApplication, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoteApplication", arg0)
	ret0, _ := ret[0].(crossmodel.RemoteApplication)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoteApplication indicates an expected call of RemoteApplication.
func (mr *MockBackendMockRecorder) RemoteApplication(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteApplication", reflect.TypeOf((*MockBackend)(nil).RemoteApplication), arg0)
}

// RemoveSecretConsumer mocks base method.
func (m *MockBackend) RemoveSecretConsumer(arg0 names.Tag) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveSecretConsumer", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveSecretConsumer indicates an expected call of RemoveSecretConsumer.
func (mr *MockBackendMockRecorder) RemoveSecretConsumer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSecretConsumer", reflect.TypeOf((*MockBackend)(nil).RemoveSecretConsumer), arg0)
}

// SaveIngressNetworks mocks base method.
func (m *MockBackend) SaveIngressNetworks(arg0 string, arg1 []string) (state.RelationNetworks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveIngressNetworks", arg0, arg1)
	ret0, _ := ret[0].(state.RelationNetworks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveIngressNetworks indicates an expected call of SaveIngressNetworks.
func (mr *MockBackendMockRecorder) SaveIngressNetworks(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveIngressNetworks", reflect.TypeOf((*MockBackend)(nil).SaveIngressNetworks), arg0, arg1)
}

// UpdateSecretConsumerOperation mocks base method.
func (m *MockBackend) UpdateSecretConsumerOperation(arg0 *secrets.URI, arg1 int) (state.ModelOperation, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecretConsumerOperation", arg0, arg1)
	ret0, _ := ret[0].(state.ModelOperation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecretConsumerOperation indicates an expected call of UpdateSecretConsumerOperation.
func (mr *MockBackendMockRecorder) UpdateSecretConsumerOperation(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecretConsumerOperation", reflect.TypeOf((*MockBackend)(nil).UpdateSecretConsumerOperation), arg0, arg1)
}

// UserPermission mocks base method.
func (m *MockBackend) UserPermission(arg0 names.UserTag, arg1 names.Tag) (permission.Access, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserPermission", arg0, arg1)
	ret0, _ := ret[0].(permission.Access)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UserPermission indicates an expected call of UserPermission.
func (mr *MockBackendMockRecorder) UserPermission(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserPermission", reflect.TypeOf((*MockBackend)(nil).UserPermission), arg0, arg1)
}

// WatchOffer mocks base method.
func (m *MockBackend) WatchOffer(arg0 string) state.NotifyWatcher {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchOffer", arg0)
	ret0, _ := ret[0].(state.NotifyWatcher)
	return ret0
}

// WatchOffer indicates an expected call of WatchOffer.
func (mr *MockBackendMockRecorder) WatchOffer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchOffer", reflect.TypeOf((*MockBackend)(nil).WatchOffer), arg0)
}

// WatchOfferStatus mocks base method.
func (m *MockBackend) WatchOfferStatus(arg0 string) (state.NotifyWatcher, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchOfferStatus", arg0)
	ret0, _ := ret[0].(state.NotifyWatcher)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WatchOfferStatus indicates an expected call of WatchOfferStatus.
func (mr *MockBackendMockRecorder) WatchOfferStatus(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchOfferStatus", reflect.TypeOf((*MockBackend)(nil).WatchOfferStatus), arg0)
}