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

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/apiserver/common/networkingcommon (interfaces: BackingSpace,BackingSubnet,LinkLayerDevice,LinkLayerAddress,LinkLayerMachine,LinkLayerState,AddSubnetsState,LinkLayerAndSubnetsState)
//
// Generated by this command:
//
//	mockgen -package mocks -destination mocks/package_mock.go github.com/juju/juju/apiserver/common/networkingcommon BackingSpace,BackingSubnet,LinkLayerDevice,LinkLayerAddress,LinkLayerMachine,LinkLayerState,AddSubnetsState,LinkLayerAndSubnetsState
//

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

import (
	reflect "reflect"

	networkingcommon "github.com/juju/juju/apiserver/common/networkingcommon"
	network "github.com/juju/juju/core/network"
	state "github.com/juju/juju/state"
	txn "github.com/juju/mgo/v3/txn"
	gomock "go.uber.org/mock/gomock"
)

// MockBackingSpace is a mock of BackingSpace interface.
type MockBackingSpace struct {
	ctrl     *gomock.Controller
	recorder *MockBackingSpaceMockRecorder
}

// MockBackingSpaceMockRecorder is the mock recorder for MockBackingSpace.
type MockBackingSpaceMockRecorder struct {
	mock *MockBackingSpace
}

// NewMockBackingSpace creates a new mock instance.
func NewMockBackingSpace(ctrl *gomock.Controller) *MockBackingSpace {
	mock := &MockBackingSpace{ctrl: ctrl}
	mock.recorder = &MockBackingSpaceMockRecorder{mock}
	return mock
}

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

// Id mocks base method.
func (m *MockBackingSpace) 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 *MockBackingSpaceMockRecorder) Id() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockBackingSpace)(nil).Id))
}

// Name mocks base method.
func (m *MockBackingSpace) 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 *MockBackingSpaceMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockBackingSpace)(nil).Name))
}

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

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

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

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

// MockBackingSubnet is a mock of BackingSubnet interface.
type MockBackingSubnet struct {
	ctrl     *gomock.Controller
	recorder *MockBackingSubnetMockRecorder
}

// MockBackingSubnetMockRecorder is the mock recorder for MockBackingSubnet.
type MockBackingSubnetMockRecorder struct {
	mock *MockBackingSubnet
}

// NewMockBackingSubnet creates a new mock instance.
func NewMockBackingSubnet(ctrl *gomock.Controller) *MockBackingSubnet {
	mock := &MockBackingSubnet{ctrl: ctrl}
	mock.recorder = &MockBackingSubnetMockRecorder{mock}
	return mock
}

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

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

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

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

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

// ID mocks base method.
func (m *MockBackingSubnet) 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 *MockBackingSubnetMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockBackingSubnet)(nil).ID))
}

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

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

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

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

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

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

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

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

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

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

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

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

// MockLinkLayerDevice is a mock of LinkLayerDevice interface.
type MockLinkLayerDevice struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerDeviceMockRecorder
}

// MockLinkLayerDeviceMockRecorder is the mock recorder for MockLinkLayerDevice.
type MockLinkLayerDeviceMockRecorder struct {
	mock *MockLinkLayerDevice
}

// NewMockLinkLayerDevice creates a new mock instance.
func NewMockLinkLayerDevice(ctrl *gomock.Controller) *MockLinkLayerDevice {
	mock := &MockLinkLayerDevice{ctrl: ctrl}
	mock.recorder = &MockLinkLayerDeviceMockRecorder{mock}
	return mock
}

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

// AddAddressOps mocks base method.
func (m *MockLinkLayerDevice) AddAddressOps(arg0 state.LinkLayerDeviceAddress) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddAddressOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Name mocks base method.
func (m *MockLinkLayerDevice) 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 *MockLinkLayerDeviceMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockLinkLayerDevice)(nil).Name))
}

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

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

// RemoveOps mocks base method.
func (m *MockLinkLayerDevice) RemoveOps() []txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveOps")
	ret0, _ := ret[0].([]txn.Op)
	return ret0
}

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

// SetProviderIDOps mocks base method.
func (m *MockLinkLayerDevice) SetProviderIDOps(arg0 network.Id) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProviderIDOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateOps mocks base method.
func (m *MockLinkLayerDevice) UpdateOps(arg0 state.LinkLayerDeviceArgs) []txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	return ret0
}

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

// MockLinkLayerAddress is a mock of LinkLayerAddress interface.
type MockLinkLayerAddress struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerAddressMockRecorder
}

// MockLinkLayerAddressMockRecorder is the mock recorder for MockLinkLayerAddress.
type MockLinkLayerAddressMockRecorder struct {
	mock *MockLinkLayerAddress
}

// NewMockLinkLayerAddress creates a new mock instance.
func NewMockLinkLayerAddress(ctrl *gomock.Controller) *MockLinkLayerAddress {
	mock := &MockLinkLayerAddress{ctrl: ctrl}
	mock.recorder = &MockLinkLayerAddressMockRecorder{mock}
	return mock
}

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

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

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

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

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

// RemoveOps mocks base method.
func (m *MockLinkLayerAddress) RemoveOps() []txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveOps")
	ret0, _ := ret[0].([]txn.Op)
	return ret0
}

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

// SetOriginOps mocks base method.
func (m *MockLinkLayerAddress) SetOriginOps(arg0 network.Origin) []txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOriginOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	return ret0
}

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

// SetProviderIDOps mocks base method.
func (m *MockLinkLayerAddress) SetProviderIDOps(arg0 network.Id) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProviderIDOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetProviderNetIDsOps mocks base method.
func (m *MockLinkLayerAddress) SetProviderNetIDsOps(arg0, arg1 network.Id) []txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProviderNetIDsOps", arg0, arg1)
	ret0, _ := ret[0].([]txn.Op)
	return ret0
}

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

// UpdateOps mocks base method.
func (m *MockLinkLayerAddress) UpdateOps(arg0 state.LinkLayerDeviceAddress) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockLinkLayerMachine is a mock of LinkLayerMachine interface.
type MockLinkLayerMachine struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerMachineMockRecorder
}

// MockLinkLayerMachineMockRecorder is the mock recorder for MockLinkLayerMachine.
type MockLinkLayerMachineMockRecorder struct {
	mock *MockLinkLayerMachine
}

// NewMockLinkLayerMachine creates a new mock instance.
func NewMockLinkLayerMachine(ctrl *gomock.Controller) *MockLinkLayerMachine {
	mock := &MockLinkLayerMachine{ctrl: ctrl}
	mock.recorder = &MockLinkLayerMachineMockRecorder{mock}
	return mock
}

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

// AddLinkLayerDeviceOps mocks base method.
func (m *MockLinkLayerMachine) AddLinkLayerDeviceOps(arg0 state.LinkLayerDeviceArgs, arg1 ...state.LinkLayerDeviceAddress) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddLinkLayerDeviceOps", varargs...)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddLinkLayerDeviceOps indicates an expected call of AddLinkLayerDeviceOps.
func (mr *MockLinkLayerMachineMockRecorder) AddLinkLayerDeviceOps(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLinkLayerDeviceOps", reflect.TypeOf((*MockLinkLayerMachine)(nil).AddLinkLayerDeviceOps), varargs...)
}

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

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

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

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

// AssertAliveOp mocks base method.
func (m *MockLinkLayerMachine) AssertAliveOp() txn.Op {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssertAliveOp")
	ret0, _ := ret[0].(txn.Op)
	return ret0
}

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

// Id mocks base method.
func (m *MockLinkLayerMachine) 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 *MockLinkLayerMachineMockRecorder) Id() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockLinkLayerMachine)(nil).Id))
}

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

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

// MockLinkLayerState is a mock of LinkLayerState interface.
type MockLinkLayerState struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerStateMockRecorder
}

// MockLinkLayerStateMockRecorder is the mock recorder for MockLinkLayerState.
type MockLinkLayerStateMockRecorder struct {
	mock *MockLinkLayerState
}

// NewMockLinkLayerState creates a new mock instance.
func NewMockLinkLayerState(ctrl *gomock.Controller) *MockLinkLayerState {
	mock := &MockLinkLayerState{ctrl: ctrl}
	mock.recorder = &MockLinkLayerStateMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockAddSubnetsState is a mock of AddSubnetsState interface.
type MockAddSubnetsState struct {
	ctrl     *gomock.Controller
	recorder *MockAddSubnetsStateMockRecorder
}

// MockAddSubnetsStateMockRecorder is the mock recorder for MockAddSubnetsState.
type MockAddSubnetsStateMockRecorder struct {
	mock *MockAddSubnetsState
}

// NewMockAddSubnetsState creates a new mock instance.
func NewMockAddSubnetsState(ctrl *gomock.Controller) *MockAddSubnetsState {
	mock := &MockAddSubnetsState{ctrl: ctrl}
	mock.recorder = &MockAddSubnetsStateMockRecorder{mock}
	return mock
}

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

// AddSubnetOps mocks base method.
func (m *MockAddSubnetsState) AddSubnetOps(arg0 network.SubnetInfo) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSubnetOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockLinkLayerAndSubnetsState is a mock of LinkLayerAndSubnetsState interface.
type MockLinkLayerAndSubnetsState struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerAndSubnetsStateMockRecorder
}

// MockLinkLayerAndSubnetsStateMockRecorder is the mock recorder for MockLinkLayerAndSubnetsState.
type MockLinkLayerAndSubnetsStateMockRecorder struct {
	mock *MockLinkLayerAndSubnetsState
}

// NewMockLinkLayerAndSubnetsState creates a new mock instance.
func NewMockLinkLayerAndSubnetsState(ctrl *gomock.Controller) *MockLinkLayerAndSubnetsState {
	mock := &MockLinkLayerAndSubnetsState{ctrl: ctrl}
	mock.recorder = &MockLinkLayerAndSubnetsStateMockRecorder{mock}
	return mock
}

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

// AddSubnetOps mocks base method.
func (m *MockLinkLayerAndSubnetsState) AddSubnetOps(arg0 network.SubnetInfo) ([]txn.Op, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSubnetOps", arg0)
	ret0, _ := ret[0].([]txn.Op)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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