types_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./types.go

package cloud

import (
	context "context"
	reflect "reflect"

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

// MockInterface is a mock of Interface interface.
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// CreateAPI mocks base method.
func (m *MockInterface) CreateAPI(ctx context.Context, api *API, opts *ResourceCreateOptions) (*API, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAPI", ctx, api, opts)
	ret0, _ := ret[0].(*API)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAPI indicates an expected call of CreateAPI.
func (mr *MockInterfaceMockRecorder) CreateAPI(ctx, api, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAPI", reflect.TypeOf((*MockInterface)(nil).CreateAPI), ctx, api, opts)
}

// CreateAccessToken mocks base method.
func (m *MockInterface) CreateAccessToken(ctx context.Context, token *AccessToken) (*AccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccessToken", ctx, token)
	ret0, _ := ret[0].(*AccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAccessToken indicates an expected call of CreateAccessToken.
func (mr *MockInterfaceMockRecorder) CreateAccessToken(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccessToken", reflect.TypeOf((*MockInterface)(nil).CreateAccessToken), ctx, token)
}

// CreateApplication mocks base method.
func (m *MockInterface) CreateApplication(ctx context.Context, app *Application, opts *ResourceCreateOptions) (*Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateApplication", ctx, app, opts)
	ret0, _ := ret[0].(*Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateApplication indicates an expected call of CreateApplication.
func (mr *MockInterfaceMockRecorder) CreateApplication(ctx, app, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApplication", reflect.TypeOf((*MockInterface)(nil).CreateApplication), ctx, app, opts)
}

// CreateCanaryRelease mocks base method.
func (m *MockInterface) CreateCanaryRelease(ctx context.Context, cr *CanaryRelease, opts *ResourceCreateOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCanaryRelease", ctx, cr, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCanaryRelease indicates an expected call of CreateCanaryRelease.
func (mr *MockInterfaceMockRecorder) CreateCanaryRelease(ctx, cr, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCanaryRelease", reflect.TypeOf((*MockInterface)(nil).CreateCanaryRelease), ctx, cr, opts)
}

// CreateCertificate mocks base method.
func (m *MockInterface) CreateCertificate(ctx context.Context, cert *Certificate, opts *ResourceCreateOptions) (*CertificateDetails, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCertificate", ctx, cert, opts)
	ret0, _ := ret[0].(*CertificateDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCertificate indicates an expected call of CreateCertificate.
func (mr *MockInterfaceMockRecorder) CreateCertificate(ctx, cert, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCertificate", reflect.TypeOf((*MockInterface)(nil).CreateCertificate), ctx, cert, opts)
}

// CreateConsumer mocks base method.
func (m *MockInterface) CreateConsumer(ctx context.Context, consumer *Consumer, opts *ResourceCreateOptions) (*Consumer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateConsumer", ctx, consumer, opts)
	ret0, _ := ret[0].(*Consumer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateConsumer indicates an expected call of CreateConsumer.
func (mr *MockInterfaceMockRecorder) CreateConsumer(ctx, consumer, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConsumer", reflect.TypeOf((*MockInterface)(nil).CreateConsumer), ctx, consumer, opts)
}

// CreateLogCollection mocks base method.
func (m *MockInterface) CreateLogCollection(ctx context.Context, lc *LogCollection, opts *ResourceCreateOptions) (*LogCollection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateLogCollection", ctx, lc, opts)
	ret0, _ := ret[0].(*LogCollection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateLogCollection indicates an expected call of CreateLogCollection.
func (mr *MockInterfaceMockRecorder) CreateLogCollection(ctx, lc, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLogCollection", reflect.TypeOf((*MockInterface)(nil).CreateLogCollection), ctx, lc, opts)
}

// CreateServiceRegistry mocks base method.
func (m *MockInterface) CreateServiceRegistry(ctx context.Context, registry *ServiceRegistry, opts *ResourceCreateOptions) (*ServiceRegistry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateServiceRegistry", ctx, registry, opts)
	ret0, _ := ret[0].(*ServiceRegistry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServiceRegistry indicates an expected call of CreateServiceRegistry.
func (mr *MockInterfaceMockRecorder) CreateServiceRegistry(ctx, registry, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceRegistry", reflect.TypeOf((*MockInterface)(nil).CreateServiceRegistry), ctx, registry, opts)
}

// DebugAPIResources mocks base method.
func (m *MockInterface) DebugAPIResources(ctx context.Context, apiID ID, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugAPIResources", ctx, apiID, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugAPIResources indicates an expected call of DebugAPIResources.
func (mr *MockInterfaceMockRecorder) DebugAPIResources(ctx, apiID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugAPIResources", reflect.TypeOf((*MockInterface)(nil).DebugAPIResources), ctx, apiID, opts)
}

// DebugApplicationResources mocks base method.
func (m *MockInterface) DebugApplicationResources(ctx context.Context, appID ID, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugApplicationResources", ctx, appID, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugApplicationResources indicates an expected call of DebugApplicationResources.
func (mr *MockInterfaceMockRecorder) DebugApplicationResources(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugApplicationResources", reflect.TypeOf((*MockInterface)(nil).DebugApplicationResources), ctx, appID, opts)
}

// DebugCertificateResources mocks base method.
func (m *MockInterface) DebugCertificateResources(ctx context.Context, appID ID, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugCertificateResources", ctx, appID, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugCertificateResources indicates an expected call of DebugCertificateResources.
func (mr *MockInterfaceMockRecorder) DebugCertificateResources(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugCertificateResources", reflect.TypeOf((*MockInterface)(nil).DebugCertificateResources), ctx, appID, opts)
}

// DebugClusterSettings mocks base method.
func (m *MockInterface) DebugClusterSettings(ctx context.Context, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugClusterSettings", ctx, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugClusterSettings indicates an expected call of DebugClusterSettings.
func (mr *MockInterfaceMockRecorder) DebugClusterSettings(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugClusterSettings", reflect.TypeOf((*MockInterface)(nil).DebugClusterSettings), ctx, opts)
}

// DebugConsumerResources mocks base method.
func (m *MockInterface) DebugConsumerResources(ctx context.Context, consumerID ID, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugConsumerResources", ctx, consumerID, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugConsumerResources indicates an expected call of DebugConsumerResources.
func (mr *MockInterfaceMockRecorder) DebugConsumerResources(ctx, consumerID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugConsumerResources", reflect.TypeOf((*MockInterface)(nil).DebugConsumerResources), ctx, consumerID, opts)
}

// DeleteAPI mocks base method.
func (m *MockInterface) DeleteAPI(ctx context.Context, apiID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAPI", ctx, apiID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAPI indicates an expected call of DeleteAPI.
func (mr *MockInterfaceMockRecorder) DeleteAPI(ctx, apiID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAPI", reflect.TypeOf((*MockInterface)(nil).DeleteAPI), ctx, apiID, opts)
}

// DeleteAccessToken mocks base method.
func (m *MockInterface) DeleteAccessToken(ctx context.Context, token *AccessToken) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccessToken", ctx, token)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAccessToken indicates an expected call of DeleteAccessToken.
func (mr *MockInterfaceMockRecorder) DeleteAccessToken(ctx, token interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccessToken", reflect.TypeOf((*MockInterface)(nil).DeleteAccessToken), ctx, token)
}

// DeleteApplication mocks base method.
func (m *MockInterface) DeleteApplication(ctx context.Context, appID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteApplication", ctx, appID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteApplication indicates an expected call of DeleteApplication.
func (mr *MockInterfaceMockRecorder) DeleteApplication(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteApplication", reflect.TypeOf((*MockInterface)(nil).DeleteApplication), ctx, appID, opts)
}

// DeleteCanaryRelease mocks base method.
func (m *MockInterface) DeleteCanaryRelease(ctx context.Context, crID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCanaryRelease", ctx, crID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCanaryRelease indicates an expected call of DeleteCanaryRelease.
func (mr *MockInterfaceMockRecorder) DeleteCanaryRelease(ctx, crID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCanaryRelease", reflect.TypeOf((*MockInterface)(nil).DeleteCanaryRelease), ctx, crID, opts)
}

// DeleteCertificate mocks base method.
func (m *MockInterface) DeleteCertificate(ctx context.Context, certID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCertificate", ctx, certID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCertificate indicates an expected call of DeleteCertificate.
func (mr *MockInterfaceMockRecorder) DeleteCertificate(ctx, certID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockInterface)(nil).DeleteCertificate), ctx, certID, opts)
}

// DeleteConsumer mocks base method.
func (m *MockInterface) DeleteConsumer(ctx context.Context, consumerID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConsumer", ctx, consumerID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConsumer indicates an expected call of DeleteConsumer.
func (mr *MockInterfaceMockRecorder) DeleteConsumer(ctx, consumerID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConsumer", reflect.TypeOf((*MockInterface)(nil).DeleteConsumer), ctx, consumerID, opts)
}

// DeleteLogCollection mocks base method.
func (m *MockInterface) DeleteLogCollection(ctx context.Context, lcID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLogCollection", ctx, lcID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteLogCollection indicates an expected call of DeleteLogCollection.
func (mr *MockInterfaceMockRecorder) DeleteLogCollection(ctx, lcID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLogCollection", reflect.TypeOf((*MockInterface)(nil).DeleteLogCollection), ctx, lcID, opts)
}

// DeleteServiceRegistry mocks base method.
func (m *MockInterface) DeleteServiceRegistry(ctx context.Context, registryID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteServiceRegistry", ctx, registryID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServiceRegistry indicates an expected call of DeleteServiceRegistry.
func (mr *MockInterfaceMockRecorder) DeleteServiceRegistry(ctx, registryID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceRegistry", reflect.TypeOf((*MockInterface)(nil).DeleteServiceRegistry), ctx, registryID, opts)
}

// FinishCanaryRelease mocks base method.
func (m *MockInterface) FinishCanaryRelease(ctx context.Context, cr *CanaryRelease, opts *ResourceUpdateOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinishCanaryRelease", ctx, cr, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FinishCanaryRelease indicates an expected call of FinishCanaryRelease.
func (mr *MockInterfaceMockRecorder) FinishCanaryRelease(ctx, cr, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishCanaryRelease", reflect.TypeOf((*MockInterface)(nil).FinishCanaryRelease), ctx, cr, opts)
}

// GenerateGatewaySideCertificate mocks base method.
func (m *MockInterface) GenerateGatewaySideCertificate(ctx context.Context, clusterID ID, opts *ResourceCreateOptions) (*TLSBundle, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateGatewaySideCertificate", ctx, clusterID, opts)
	ret0, _ := ret[0].(*TLSBundle)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateGatewaySideCertificate indicates an expected call of GenerateGatewaySideCertificate.
func (mr *MockInterfaceMockRecorder) GenerateGatewaySideCertificate(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateGatewaySideCertificate", reflect.TypeOf((*MockInterface)(nil).GenerateGatewaySideCertificate), ctx, clusterID, opts)
}

// GetAPI mocks base method.
func (m *MockInterface) GetAPI(ctx context.Context, apiID ID, opts *ResourceGetOptions) (*API, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPI", ctx, apiID, opts)
	ret0, _ := ret[0].(*API)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPI indicates an expected call of GetAPI.
func (mr *MockInterfaceMockRecorder) GetAPI(ctx, apiID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPI", reflect.TypeOf((*MockInterface)(nil).GetAPI), ctx, apiID, opts)
}

// GetApplication mocks base method.
func (m *MockInterface) GetApplication(ctx context.Context, appID ID, opts *ResourceGetOptions) (*Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplication", ctx, appID, opts)
	ret0, _ := ret[0].(*Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetApplication indicates an expected call of GetApplication.
func (mr *MockInterfaceMockRecorder) GetApplication(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApplication", reflect.TypeOf((*MockInterface)(nil).GetApplication), ctx, appID, opts)
}

// GetCanaryRelease mocks base method.
func (m *MockInterface) GetCanaryRelease(ctx context.Context, crID ID, opts *ResourceGetOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCanaryRelease", ctx, crID, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCanaryRelease indicates an expected call of GetCanaryRelease.
func (mr *MockInterfaceMockRecorder) GetCanaryRelease(ctx, crID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCanaryRelease", reflect.TypeOf((*MockInterface)(nil).GetCanaryRelease), ctx, crID, opts)
}

// GetCertificate mocks base method.
func (m *MockInterface) GetCertificate(ctx context.Context, certID ID, opts *ResourceGetOptions) (*CertificateDetails, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCertificate", ctx, certID, opts)
	ret0, _ := ret[0].(*CertificateDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCertificate indicates an expected call of GetCertificate.
func (mr *MockInterfaceMockRecorder) GetCertificate(ctx, certID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockInterface)(nil).GetCertificate), ctx, certID, opts)
}

// GetCluster mocks base method.
func (m *MockInterface) GetCluster(ctx context.Context, clusterID ID, opts *ResourceGetOptions) (*Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCluster", ctx, clusterID, opts)
	ret0, _ := ret[0].(*Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockInterfaceMockRecorder) GetCluster(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockInterface)(nil).GetCluster), ctx, clusterID, opts)
}

// GetConsumer mocks base method.
func (m *MockInterface) GetConsumer(ctx context.Context, consumerID ID, opts *ResourceGetOptions) (*Consumer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConsumer", ctx, consumerID, opts)
	ret0, _ := ret[0].(*Consumer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConsumer indicates an expected call of GetConsumer.
func (mr *MockInterfaceMockRecorder) GetConsumer(ctx, consumerID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsumer", reflect.TypeOf((*MockInterface)(nil).GetConsumer), ctx, consumerID, opts)
}

// GetGatewayInstanceStartupConfigTemplate mocks base method.
func (m *MockInterface) GetGatewayInstanceStartupConfigTemplate(ctx context.Context, clusterID ID, configType string, opts *ResourceGetOptions) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGatewayInstanceStartupConfigTemplate", ctx, clusterID, configType, opts)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGatewayInstanceStartupConfigTemplate indicates an expected call of GetGatewayInstanceStartupConfigTemplate.
func (mr *MockInterfaceMockRecorder) GetGatewayInstanceStartupConfigTemplate(ctx, clusterID, configType, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGatewayInstanceStartupConfigTemplate", reflect.TypeOf((*MockInterface)(nil).GetGatewayInstanceStartupConfigTemplate), ctx, clusterID, configType, opts)
}

// GetLogCollection mocks base method.
func (m *MockInterface) GetLogCollection(ctx context.Context, lcID ID, opts *ResourceGetOptions) (*LogCollection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogCollection", ctx, lcID, opts)
	ret0, _ := ret[0].(*LogCollection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLogCollection indicates an expected call of GetLogCollection.
func (mr *MockInterfaceMockRecorder) GetLogCollection(ctx, lcID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogCollection", reflect.TypeOf((*MockInterface)(nil).GetLogCollection), ctx, lcID, opts)
}

// GetMember mocks base method.
func (m *MockInterface) GetMember(ctx context.Context, memberID ID, opts *ResourceGetOptions) (*Member, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMember", ctx, memberID, opts)
	ret0, _ := ret[0].(*Member)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMember indicates an expected call of GetMember.
func (mr *MockInterfaceMockRecorder) GetMember(ctx, memberID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMember", reflect.TypeOf((*MockInterface)(nil).GetMember), ctx, memberID, opts)
}

// GetOrganization mocks base method.
func (m *MockInterface) GetOrganization(ctx context.Context, orgID ID, opts *ResourceGetOptions) (*Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganization", ctx, orgID, opts)
	ret0, _ := ret[0].(*Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganization indicates an expected call of GetOrganization.
func (mr *MockInterfaceMockRecorder) GetOrganization(ctx, orgID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganization", reflect.TypeOf((*MockInterface)(nil).GetOrganization), ctx, orgID, opts)
}

// GetServiceRegistry mocks base method.
func (m *MockInterface) GetServiceRegistry(ctx context.Context, registryID ID, opts *ResourceGetOptions) (*ServiceRegistry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceRegistry", ctx, registryID, opts)
	ret0, _ := ret[0].(*ServiceRegistry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceRegistry indicates an expected call of GetServiceRegistry.
func (mr *MockInterfaceMockRecorder) GetServiceRegistry(ctx, registryID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceRegistry", reflect.TypeOf((*MockInterface)(nil).GetServiceRegistry), ctx, registryID, opts)
}

// InviteMember mocks base method.
func (m *MockInterface) InviteMember(ctx context.Context, email string, role *Role, opts *ResourceCreateOptions) (*Member, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InviteMember", ctx, email, role, opts)
	ret0, _ := ret[0].(*Member)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InviteMember indicates an expected call of InviteMember.
func (mr *MockInterfaceMockRecorder) InviteMember(ctx, email, role, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteMember", reflect.TypeOf((*MockInterface)(nil).InviteMember), ctx, email, role, opts)
}

// ListAPIs mocks base method.
func (m *MockInterface) ListAPIs(ctx context.Context, opts *ResourceListOptions) (APIListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAPIs", ctx, opts)
	ret0, _ := ret[0].(APIListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAPIs indicates an expected call of ListAPIs.
func (mr *MockInterfaceMockRecorder) ListAPIs(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAPIs", reflect.TypeOf((*MockInterface)(nil).ListAPIs), ctx, opts)
}

// ListAllAPILabels mocks base method.
func (m *MockInterface) ListAllAPILabels(ctx context.Context, clusterID ID, opts *ResourceListOptions) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllAPILabels", ctx, clusterID, opts)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllAPILabels indicates an expected call of ListAllAPILabels.
func (mr *MockInterfaceMockRecorder) ListAllAPILabels(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllAPILabels", reflect.TypeOf((*MockInterface)(nil).ListAllAPILabels), ctx, clusterID, opts)
}

// ListAllApplicationLabels mocks base method.
func (m *MockInterface) ListAllApplicationLabels(ctx context.Context, clusterID ID, opts *ResourceListOptions) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllApplicationLabels", ctx, clusterID, opts)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllApplicationLabels indicates an expected call of ListAllApplicationLabels.
func (mr *MockInterfaceMockRecorder) ListAllApplicationLabels(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllApplicationLabels", reflect.TypeOf((*MockInterface)(nil).ListAllApplicationLabels), ctx, clusterID, opts)
}

// ListAllCertificateLabels mocks base method.
func (m *MockInterface) ListAllCertificateLabels(ctx context.Context, clusterID ID, opts *ResourceListOptions) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllCertificateLabels", ctx, clusterID, opts)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllCertificateLabels indicates an expected call of ListAllCertificateLabels.
func (mr *MockInterfaceMockRecorder) ListAllCertificateLabels(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllCertificateLabels", reflect.TypeOf((*MockInterface)(nil).ListAllCertificateLabels), ctx, clusterID, opts)
}

// ListAllConsumerLabels mocks base method.
func (m *MockInterface) ListAllConsumerLabels(ctx context.Context, clusterID ID, opts *ResourceListOptions) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllConsumerLabels", ctx, clusterID, opts)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllConsumerLabels indicates an expected call of ListAllConsumerLabels.
func (mr *MockInterfaceMockRecorder) ListAllConsumerLabels(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllConsumerLabels", reflect.TypeOf((*MockInterface)(nil).ListAllConsumerLabels), ctx, clusterID, opts)
}

// ListAllGatewayInstances mocks base method.
func (m *MockInterface) ListAllGatewayInstances(ctx context.Context, clusterID ID, opts *ResourceListOptions) ([]GatewayInstance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllGatewayInstances", ctx, clusterID, opts)
	ret0, _ := ret[0].([]GatewayInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAllGatewayInstances indicates an expected call of ListAllGatewayInstances.
func (mr *MockInterfaceMockRecorder) ListAllGatewayInstances(ctx, clusterID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllGatewayInstances", reflect.TypeOf((*MockInterface)(nil).ListAllGatewayInstances), ctx, clusterID, opts)
}

// ListApplications mocks base method.
func (m *MockInterface) ListApplications(ctx context.Context, opts *ResourceListOptions) (ApplicationListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApplications", ctx, opts)
	ret0, _ := ret[0].(ApplicationListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListApplications indicates an expected call of ListApplications.
func (mr *MockInterfaceMockRecorder) ListApplications(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListApplications", reflect.TypeOf((*MockInterface)(nil).ListApplications), ctx, opts)
}

// ListCanaryReleases mocks base method.
func (m *MockInterface) ListCanaryReleases(ctx context.Context, opts *ResourceListOptions) (CanaryReleaseListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCanaryReleases", ctx, opts)
	ret0, _ := ret[0].(CanaryReleaseListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCanaryReleases indicates an expected call of ListCanaryReleases.
func (mr *MockInterfaceMockRecorder) ListCanaryReleases(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCanaryReleases", reflect.TypeOf((*MockInterface)(nil).ListCanaryReleases), ctx, opts)
}

// ListCertificates mocks base method.
func (m *MockInterface) ListCertificates(ctx context.Context, opts *ResourceListOptions) (CertificateListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCertificates", ctx, opts)
	ret0, _ := ret[0].(CertificateListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCertificates indicates an expected call of ListCertificates.
func (mr *MockInterfaceMockRecorder) ListCertificates(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificates", reflect.TypeOf((*MockInterface)(nil).ListCertificates), ctx, opts)
}

// ListClusters mocks base method.
func (m *MockInterface) ListClusters(ctx context.Context, opts *ResourceListOptions) (ClusterListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", ctx, opts)
	ret0, _ := ret[0].(ClusterListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockInterfaceMockRecorder) ListClusters(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockInterface)(nil).ListClusters), ctx, opts)
}

// ListConsumers mocks base method.
func (m *MockInterface) ListConsumers(ctx context.Context, opts *ResourceListOptions) (ConsumerListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConsumers", ctx, opts)
	ret0, _ := ret[0].(ConsumerListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConsumers indicates an expected call of ListConsumers.
func (mr *MockInterfaceMockRecorder) ListConsumers(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConsumers", reflect.TypeOf((*MockInterface)(nil).ListConsumers), ctx, opts)
}

// ListLogCollections mocks base method.
func (m *MockInterface) ListLogCollections(ctx context.Context, opts *ResourceListOptions) (LogCollectionIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListLogCollections", ctx, opts)
	ret0, _ := ret[0].(LogCollectionIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListLogCollections indicates an expected call of ListLogCollections.
func (mr *MockInterfaceMockRecorder) ListLogCollections(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogCollections", reflect.TypeOf((*MockInterface)(nil).ListLogCollections), ctx, opts)
}

// ListMembers mocks base method.
func (m *MockInterface) ListMembers(ctx context.Context, opts *ResourceListOptions) (MemberListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMembers", ctx, opts)
	ret0, _ := ret[0].(MemberListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMembers indicates an expected call of ListMembers.
func (mr *MockInterfaceMockRecorder) ListMembers(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMembers", reflect.TypeOf((*MockInterface)(nil).ListMembers), ctx, opts)
}

// ListRegions mocks base method.
func (m *MockInterface) ListRegions(ctx context.Context, opts *ResourceListOptions) (RegionListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRegions", ctx, opts)
	ret0, _ := ret[0].(RegionListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRegions indicates an expected call of ListRegions.
func (mr *MockInterfaceMockRecorder) ListRegions(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRegions", reflect.TypeOf((*MockInterface)(nil).ListRegions), ctx, opts)
}

// ListRoles mocks base method.
func (m *MockInterface) ListRoles(ctx context.Context, opts *ResourceListOptions) (RoleListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRoles", ctx, opts)
	ret0, _ := ret[0].(RoleListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListRoles indicates an expected call of ListRoles.
func (mr *MockInterfaceMockRecorder) ListRoles(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRoles", reflect.TypeOf((*MockInterface)(nil).ListRoles), ctx, opts)
}

// ListServiceRegistries mocks base method.
func (m *MockInterface) ListServiceRegistries(ctx context.Context, opts *ResourceListOptions) (ServiceRegistryListIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServiceRegistries", ctx, opts)
	ret0, _ := ret[0].(ServiceRegistryListIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServiceRegistries indicates an expected call of ListServiceRegistries.
func (mr *MockInterfaceMockRecorder) ListServiceRegistries(ctx, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceRegistries", reflect.TypeOf((*MockInterface)(nil).ListServiceRegistries), ctx, opts)
}

// Me mocks base method.
func (m *MockInterface) Me(ctx context.Context) (*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Me", ctx)
	ret0, _ := ret[0].(*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Me indicates an expected call of Me.
func (mr *MockInterfaceMockRecorder) Me(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Me", reflect.TypeOf((*MockInterface)(nil).Me), ctx)
}

// PauseCanaryRelease mocks base method.
func (m *MockInterface) PauseCanaryRelease(ctx context.Context, cr *CanaryRelease, opts *ResourceUpdateOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseCanaryRelease", ctx, cr, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PauseCanaryRelease indicates an expected call of PauseCanaryRelease.
func (mr *MockInterfaceMockRecorder) PauseCanaryRelease(ctx, cr, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseCanaryRelease", reflect.TypeOf((*MockInterface)(nil).PauseCanaryRelease), ctx, cr, opts)
}

// PublishAPI mocks base method.
func (m *MockInterface) PublishAPI(ctx context.Context, apiID ID, opts *ResourceUpdateOptions) (*API, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishAPI", ctx, apiID, opts)
	ret0, _ := ret[0].(*API)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublishAPI indicates an expected call of PublishAPI.
func (mr *MockInterfaceMockRecorder) PublishAPI(ctx, apiID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishAPI", reflect.TypeOf((*MockInterface)(nil).PublishAPI), ctx, apiID, opts)
}

// PublishApplication mocks base method.
func (m *MockInterface) PublishApplication(ctx context.Context, appID ID, opts *ResourceUpdateOptions) (*Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishApplication", ctx, appID, opts)
	ret0, _ := ret[0].(*Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PublishApplication indicates an expected call of PublishApplication.
func (mr *MockInterfaceMockRecorder) PublishApplication(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishApplication", reflect.TypeOf((*MockInterface)(nil).PublishApplication), ctx, appID, opts)
}

// ReInviteMember mocks base method.
func (m *MockInterface) ReInviteMember(ctx context.Context, memberID ID, opts *ResourceUpdateOptions) (*Member, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReInviteMember", ctx, memberID, opts)
	ret0, _ := ret[0].(*Member)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReInviteMember indicates an expected call of ReInviteMember.
func (mr *MockInterfaceMockRecorder) ReInviteMember(ctx, memberID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReInviteMember", reflect.TypeOf((*MockInterface)(nil).ReInviteMember), ctx, memberID, opts)
}

// RemoveMember mocks base method.
func (m *MockInterface) RemoveMember(ctx context.Context, memberID ID, opts *ResourceDeleteOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMember", ctx, memberID, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveMember indicates an expected call of RemoveMember.
func (mr *MockInterfaceMockRecorder) RemoveMember(ctx, memberID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMember", reflect.TypeOf((*MockInterface)(nil).RemoveMember), ctx, memberID, opts)
}

// SetGlobalClusterID mocks base method.
func (m *MockInterface) SetGlobalClusterID(id ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGlobalClusterID", id)
}

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

// StartCanaryRelease mocks base method.
func (m *MockInterface) StartCanaryRelease(ctx context.Context, cr *CanaryRelease, opts *ResourceUpdateOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCanaryRelease", ctx, cr, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartCanaryRelease indicates an expected call of StartCanaryRelease.
func (mr *MockInterfaceMockRecorder) StartCanaryRelease(ctx, cr, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCanaryRelease", reflect.TypeOf((*MockInterface)(nil).StartCanaryRelease), ctx, cr, opts)
}

// TraceChan mocks base method.
func (m *MockInterface) TraceChan() <-chan *TraceSeries {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TraceChan")
	ret0, _ := ret[0].(<-chan *TraceSeries)
	return ret0
}

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

// TransferOwnership mocks base method.
func (m *MockInterface) TransferOwnership(ctx context.Context, toMember ID, opts *ResourceUpdateOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransferOwnership", ctx, toMember, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// TransferOwnership indicates an expected call of TransferOwnership.
func (mr *MockInterfaceMockRecorder) TransferOwnership(ctx, toMember, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransferOwnership", reflect.TypeOf((*MockInterface)(nil).TransferOwnership), ctx, toMember, opts)
}

// UnpublishAPI mocks base method.
func (m *MockInterface) UnpublishAPI(ctx context.Context, apiID ID, opts *ResourceUpdateOptions) (*API, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpublishAPI", ctx, apiID, opts)
	ret0, _ := ret[0].(*API)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnpublishAPI indicates an expected call of UnpublishAPI.
func (mr *MockInterfaceMockRecorder) UnpublishAPI(ctx, apiID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpublishAPI", reflect.TypeOf((*MockInterface)(nil).UnpublishAPI), ctx, apiID, opts)
}

// UnpublishApplication mocks base method.
func (m *MockInterface) UnpublishApplication(ctx context.Context, appID ID, opts *ResourceUpdateOptions) (*Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpublishApplication", ctx, appID, opts)
	ret0, _ := ret[0].(*Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnpublishApplication indicates an expected call of UnpublishApplication.
func (mr *MockInterfaceMockRecorder) UnpublishApplication(ctx, appID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpublishApplication", reflect.TypeOf((*MockInterface)(nil).UnpublishApplication), ctx, appID, opts)
}

// UpdateAPI mocks base method.
func (m *MockInterface) UpdateAPI(ctx context.Context, api *API, opts *ResourceUpdateOptions) (*API, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAPI", ctx, api, opts)
	ret0, _ := ret[0].(*API)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAPI indicates an expected call of UpdateAPI.
func (mr *MockInterfaceMockRecorder) UpdateAPI(ctx, api, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAPI", reflect.TypeOf((*MockInterface)(nil).UpdateAPI), ctx, api, opts)
}

// UpdateApplication mocks base method.
func (m *MockInterface) UpdateApplication(ctx context.Context, app *Application, opts *ResourceUpdateOptions) (*Application, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateApplication", ctx, app, opts)
	ret0, _ := ret[0].(*Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateApplication indicates an expected call of UpdateApplication.
func (mr *MockInterfaceMockRecorder) UpdateApplication(ctx, app, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplication", reflect.TypeOf((*MockInterface)(nil).UpdateApplication), ctx, app, opts)
}

// UpdateCanaryRelease mocks base method.
func (m *MockInterface) UpdateCanaryRelease(ctx context.Context, cr *CanaryRelease, opts *ResourceUpdateOptions) (*CanaryRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCanaryRelease", ctx, cr, opts)
	ret0, _ := ret[0].(*CanaryRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCanaryRelease indicates an expected call of UpdateCanaryRelease.
func (mr *MockInterfaceMockRecorder) UpdateCanaryRelease(ctx, cr, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCanaryRelease", reflect.TypeOf((*MockInterface)(nil).UpdateCanaryRelease), ctx, cr, opts)
}

// UpdateCertificate mocks base method.
func (m *MockInterface) UpdateCertificate(ctx context.Context, cert *Certificate, opts *ResourceUpdateOptions) (*CertificateDetails, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCertificate", ctx, cert, opts)
	ret0, _ := ret[0].(*CertificateDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCertificate indicates an expected call of UpdateCertificate.
func (mr *MockInterfaceMockRecorder) UpdateCertificate(ctx, cert, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificate", reflect.TypeOf((*MockInterface)(nil).UpdateCertificate), ctx, cert, opts)
}

// UpdateClusterPlugins mocks base method.
func (m *MockInterface) UpdateClusterPlugins(ctx context.Context, clusterID ID, plugins Plugins, opts *ResourceUpdateOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterPlugins", ctx, clusterID, plugins, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterPlugins indicates an expected call of UpdateClusterPlugins.
func (mr *MockInterfaceMockRecorder) UpdateClusterPlugins(ctx, clusterID, plugins, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterPlugins", reflect.TypeOf((*MockInterface)(nil).UpdateClusterPlugins), ctx, clusterID, plugins, opts)
}

// UpdateClusterSettings mocks base method.
func (m *MockInterface) UpdateClusterSettings(ctx context.Context, clusterID ID, settings *ClusterSettings, opts *ResourceUpdateOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterSettings", ctx, clusterID, settings, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateClusterSettings indicates an expected call of UpdateClusterSettings.
func (mr *MockInterfaceMockRecorder) UpdateClusterSettings(ctx, clusterID, settings, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterSettings", reflect.TypeOf((*MockInterface)(nil).UpdateClusterSettings), ctx, clusterID, settings, opts)
}

// UpdateConsumer mocks base method.
func (m *MockInterface) UpdateConsumer(ctx context.Context, consumer *Consumer, opts *ResourceUpdateOptions) (*Consumer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateConsumer", ctx, consumer, opts)
	ret0, _ := ret[0].(*Consumer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateConsumer indicates an expected call of UpdateConsumer.
func (mr *MockInterfaceMockRecorder) UpdateConsumer(ctx, consumer, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateConsumer", reflect.TypeOf((*MockInterface)(nil).UpdateConsumer), ctx, consumer, opts)
}

// UpdateLogCollection mocks base method.
func (m *MockInterface) UpdateLogCollection(ctx context.Context, lc *LogCollection, opts *ResourceUpdateOptions) (*LogCollection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateLogCollection", ctx, lc, opts)
	ret0, _ := ret[0].(*LogCollection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateLogCollection indicates an expected call of UpdateLogCollection.
func (mr *MockInterfaceMockRecorder) UpdateLogCollection(ctx, lc, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLogCollection", reflect.TypeOf((*MockInterface)(nil).UpdateLogCollection), ctx, lc, opts)
}

// UpdateMemberRoles mocks base method.
func (m *MockInterface) UpdateMemberRoles(ctx context.Context, memberID ID, roleBindings []RoleBinding, opts *ResourceUpdateOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMemberRoles", ctx, memberID, roleBindings, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMemberRoles indicates an expected call of UpdateMemberRoles.
func (mr *MockInterfaceMockRecorder) UpdateMemberRoles(ctx, memberID, roleBindings, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMemberRoles", reflect.TypeOf((*MockInterface)(nil).UpdateMemberRoles), ctx, memberID, roleBindings, opts)
}

// UpdateServiceRegistry mocks base method.
func (m *MockInterface) UpdateServiceRegistry(ctx context.Context, registry *ServiceRegistry, opts *ResourceUpdateOptions) (*ServiceRegistry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateServiceRegistry", ctx, registry, opts)
	ret0, _ := ret[0].(*ServiceRegistry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceRegistry indicates an expected call of UpdateServiceRegistry.
func (mr *MockInterfaceMockRecorder) UpdateServiceRegistry(ctx, registry, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceRegistry", reflect.TypeOf((*MockInterface)(nil).UpdateServiceRegistry), ctx, registry, opts)
}

// sendSeries mocks base method.
func (m *MockInterface) sendSeries(series *TraceSeries) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "sendSeries", series)
}

// sendSeries indicates an expected call of sendSeries.
func (mr *MockInterfaceMockRecorder) sendSeries(series interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "sendSeries", reflect.TypeOf((*MockInterface)(nil).sendSeries), series)
}