description_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/description/v5 (interfaces: Application,Machine,PortRanges,UnitPortRanges)
//
// Generated by this command:
//
//	mockgen -package mocks -destination mocks/description_mock.go github.com/juju/description/v5 Application,Machine,PortRanges,UnitPortRanges
//

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

import (
	reflect "reflect"

	description "github.com/juju/description/v5"
	names "github.com/juju/names/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockApplication is a mock of Application interface.
type MockApplication struct {
	ctrl     *gomock.Controller
	recorder *MockApplicationMockRecorder
}

// MockApplicationMockRecorder is the mock recorder for MockApplication.
type MockApplicationMockRecorder struct {
	mock *MockApplication
}

// NewMockApplication creates a new mock instance.
func NewMockApplication(ctrl *gomock.Controller) *MockApplication {
	mock := &MockApplication{ctrl: ctrl}
	mock.recorder = &MockApplicationMockRecorder{mock}
	return mock
}

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

// AddOffer mocks base method.
func (m *MockApplication) AddOffer(arg0 description.ApplicationOfferArgs) description.ApplicationOffer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOffer", arg0)
	ret0, _ := ret[0].(description.ApplicationOffer)
	return ret0
}

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

// AddOpenedPortRange mocks base method.
func (m *MockApplication) AddOpenedPortRange(arg0 description.OpenedPortRangeArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddOpenedPortRange", arg0)
}

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

// AddResource mocks base method.
func (m *MockApplication) AddResource(arg0 description.ResourceArgs) description.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddResource", arg0)
	ret0, _ := ret[0].(description.Resource)
	return ret0
}

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

// AddUnit mocks base method.
func (m *MockApplication) AddUnit(arg0 description.UnitArgs) description.Unit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddUnit", arg0)
	ret0, _ := ret[0].(description.Unit)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Offers mocks base method.
func (m *MockApplication) Offers() []description.ApplicationOffer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Offers")
	ret0, _ := ret[0].([]description.ApplicationOffer)
	return ret0
}

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

// OpenedPortRanges mocks base method.
func (m *MockApplication) OpenedPortRanges() description.PortRanges {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenedPortRanges")
	ret0, _ := ret[0].(description.PortRanges)
	return ret0
}

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

// OperatorStatus mocks base method.
func (m *MockApplication) OperatorStatus() description.Status {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OperatorStatus")
	ret0, _ := ret[0].(description.Status)
	return ret0
}

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

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

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

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

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

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

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

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

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

// Resources mocks base method.
func (m *MockApplication) Resources() []description.Resource {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Resources")
	ret0, _ := ret[0].([]description.Resource)
	return ret0
}

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

// SetAnnotations mocks base method.
func (m *MockApplication) SetAnnotations(arg0 map[string]string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAnnotations", arg0)
}

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

// SetCharmOrigin mocks base method.
func (m *MockApplication) SetCharmOrigin(arg0 description.CharmOriginArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCharmOrigin", arg0)
}

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

// SetCloudService mocks base method.
func (m *MockApplication) SetCloudService(arg0 description.CloudServiceArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCloudService", arg0)
}

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

// SetConstraints mocks base method.
func (m *MockApplication) SetConstraints(arg0 description.ConstraintsArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConstraints", arg0)
}

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

// SetOperatorStatus mocks base method.
func (m *MockApplication) SetOperatorStatus(arg0 description.StatusArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOperatorStatus", arg0)
}

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

// SetStatus mocks base method.
func (m *MockApplication) SetStatus(arg0 description.StatusArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStatus", arg0)
}

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

// SetStatusHistory mocks base method.
func (m *MockApplication) SetStatusHistory(arg0 []description.StatusArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStatusHistory", arg0)
}

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

// SetTools mocks base method.
func (m *MockApplication) SetTools(arg0 description.AgentToolsArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTools", arg0)
}

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

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

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

// StatusHistory mocks base method.
func (m *MockApplication) StatusHistory() []description.Status {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatusHistory")
	ret0, _ := ret[0].([]description.Status)
	return ret0
}

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

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

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

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

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

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

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

// Tools mocks base method.
func (m *MockApplication) Tools() description.AgentTools {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tools")
	ret0, _ := ret[0].(description.AgentTools)
	return ret0
}

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

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

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

// Units mocks base method.
func (m *MockApplication) Units() []description.Unit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Units")
	ret0, _ := ret[0].([]description.Unit)
	return ret0
}

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

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

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

// MockMachine is a mock of Machine interface.
type MockMachine struct {
	ctrl     *gomock.Controller
	recorder *MockMachineMockRecorder
}

// MockMachineMockRecorder is the mock recorder for MockMachine.
type MockMachineMockRecorder struct {
	mock *MockMachine
}

// NewMockMachine creates a new mock instance.
func NewMockMachine(ctrl *gomock.Controller) *MockMachine {
	mock := &MockMachine{ctrl: ctrl}
	mock.recorder = &MockMachineMockRecorder{mock}
	return mock
}

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

// AddBlockDevice mocks base method.
func (m *MockMachine) AddBlockDevice(arg0 description.BlockDeviceArgs) description.BlockDevice {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddBlockDevice", arg0)
	ret0, _ := ret[0].(description.BlockDevice)
	return ret0
}

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

// AddContainer mocks base method.
func (m *MockMachine) AddContainer(arg0 description.MachineArgs) description.Machine {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddContainer", arg0)
	ret0, _ := ret[0].(description.Machine)
	return ret0
}

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

// AddOpenedPortRange mocks base method.
func (m *MockMachine) AddOpenedPortRange(arg0 description.OpenedPortRangeArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddOpenedPortRange", arg0)
}

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

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

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

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

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

// BlockDevices mocks base method.
func (m *MockMachine) BlockDevices() []description.BlockDevice {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockDevices")
	ret0, _ := ret[0].([]description.BlockDevice)
	return ret0
}

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

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

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

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

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

// Containers mocks base method.
func (m *MockMachine) Containers() []description.Machine {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Containers")
	ret0, _ := ret[0].([]description.Machine)
	return ret0
}

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

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

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

// Instance mocks base method.
func (m *MockMachine) Instance() description.CloudInstance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Instance")
	ret0, _ := ret[0].(description.CloudInstance)
	return ret0
}

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

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

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

// MachineAddresses mocks base method.
func (m *MockMachine) MachineAddresses() []description.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MachineAddresses")
	ret0, _ := ret[0].([]description.Address)
	return ret0
}

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

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

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

// OpenedPortRanges mocks base method.
func (m *MockMachine) OpenedPortRanges() description.PortRanges {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenedPortRanges")
	ret0, _ := ret[0].(description.PortRanges)
	return ret0
}

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

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

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

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

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

// PreferredPrivateAddress mocks base method.
func (m *MockMachine) PreferredPrivateAddress() description.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreferredPrivateAddress")
	ret0, _ := ret[0].(description.Address)
	return ret0
}

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

// PreferredPublicAddress mocks base method.
func (m *MockMachine) PreferredPublicAddress() description.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreferredPublicAddress")
	ret0, _ := ret[0].(description.Address)
	return ret0
}

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

// ProviderAddresses mocks base method.
func (m *MockMachine) ProviderAddresses() []description.Address {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProviderAddresses")
	ret0, _ := ret[0].([]description.Address)
	return ret0
}

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

// SetAddresses mocks base method.
func (m *MockMachine) SetAddresses(arg0, arg1 []description.AddressArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddresses", arg0, arg1)
}

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

// SetAnnotations mocks base method.
func (m *MockMachine) SetAnnotations(arg0 map[string]string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAnnotations", arg0)
}

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

// SetConstraints mocks base method.
func (m *MockMachine) SetConstraints(arg0 description.ConstraintsArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConstraints", arg0)
}

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

// SetInstance mocks base method.
func (m *MockMachine) SetInstance(arg0 description.CloudInstanceArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInstance", arg0)
}

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

// SetPreferredAddresses mocks base method.
func (m *MockMachine) SetPreferredAddresses(arg0, arg1 description.AddressArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPreferredAddresses", arg0, arg1)
}

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

// SetStatus mocks base method.
func (m *MockMachine) SetStatus(arg0 description.StatusArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStatus", arg0)
}

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

// SetStatusHistory mocks base method.
func (m *MockMachine) SetStatusHistory(arg0 []description.StatusArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStatusHistory", arg0)
}

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

// SetTools mocks base method.
func (m *MockMachine) SetTools(arg0 description.AgentToolsArgs) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTools", arg0)
}

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

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

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

// StatusHistory mocks base method.
func (m *MockMachine) StatusHistory() []description.Status {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StatusHistory")
	ret0, _ := ret[0].([]description.Status)
	return ret0
}

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

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

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

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

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

// Tools mocks base method.
func (m *MockMachine) Tools() description.AgentTools {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tools")
	ret0, _ := ret[0].(description.AgentTools)
	return ret0
}

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

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

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

// MockPortRanges is a mock of PortRanges interface.
type MockPortRanges struct {
	ctrl     *gomock.Controller
	recorder *MockPortRangesMockRecorder
}

// MockPortRangesMockRecorder is the mock recorder for MockPortRanges.
type MockPortRangesMockRecorder struct {
	mock *MockPortRanges
}

// NewMockPortRanges creates a new mock instance.
func NewMockPortRanges(ctrl *gomock.Controller) *MockPortRanges {
	mock := &MockPortRanges{ctrl: ctrl}
	mock.recorder = &MockPortRangesMockRecorder{mock}
	return mock
}

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

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

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

// MockUnitPortRanges is a mock of UnitPortRanges interface.
type MockUnitPortRanges struct {
	ctrl     *gomock.Controller
	recorder *MockUnitPortRangesMockRecorder
}

// MockUnitPortRangesMockRecorder is the mock recorder for MockUnitPortRanges.
type MockUnitPortRangesMockRecorder struct {
	mock *MockUnitPortRanges
}

// NewMockUnitPortRanges creates a new mock instance.
func NewMockUnitPortRanges(ctrl *gomock.Controller) *MockUnitPortRanges {
	mock := &MockUnitPortRanges{ctrl: ctrl}
	mock.recorder = &MockUnitPortRangesMockRecorder{mock}
	return mock
}

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

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

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