// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/cloud/azure/client.go
//
// Generated by this command:
//
//	mockgen -destination ./pkg/cloud/azure/client_mock.go -package azure -source ./pkg/cloud/azure/client.go
//

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

import (
	context "context"
	reflect "reflect"

	armcontainerservice "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v8"
	armnetwork "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v8"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

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

// BlobContainers indicates an expected call of BlobContainers.
func (mr *MockClientMockRecorder) BlobContainers(accountName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlobContainers", reflect.TypeOf((*MockClient)(nil).BlobContainers), accountName)
}

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

// LoadBalancers indicates an expected call of LoadBalancers.
func (mr *MockClientMockRecorder) LoadBalancers(subscriptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadBalancers", reflect.TypeOf((*MockClient)(nil).LoadBalancers), subscriptionID)
}

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

// ManagedClusters indicates an expected call of ManagedClusters.
func (mr *MockClientMockRecorder) ManagedClusters(subscriptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManagedClusters", reflect.TypeOf((*MockClient)(nil).ManagedClusters), subscriptionID)
}

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

// PrivateEndpoints indicates an expected call of PrivateEndpoints.
func (mr *MockClientMockRecorder) PrivateEndpoints(subscriptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrivateEndpoints", reflect.TypeOf((*MockClient)(nil).PrivateEndpoints), subscriptionID)
}

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

// PrivateLinkServices indicates an expected call of PrivateLinkServices.
func (mr *MockClientMockRecorder) PrivateLinkServices(subscriptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrivateLinkServices", reflect.TypeOf((*MockClient)(nil).PrivateLinkServices), subscriptionID)
}

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

// StorageAccounts indicates an expected call of StorageAccounts.
func (mr *MockClientMockRecorder) StorageAccounts(subscriptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAccounts", reflect.TypeOf((*MockClient)(nil).StorageAccounts), subscriptionID)
}

// MockManagedClustersAPI is a mock of ManagedClustersAPI interface.
type MockManagedClustersAPI struct {
	ctrl     *gomock.Controller
	recorder *MockManagedClustersAPIMockRecorder
}

// MockManagedClustersAPIMockRecorder is the mock recorder for MockManagedClustersAPI.
type MockManagedClustersAPIMockRecorder struct {
	mock *MockManagedClustersAPI
}

// NewMockManagedClustersAPI creates a new mock instance.
func NewMockManagedClustersAPI(ctrl *gomock.Controller) *MockManagedClustersAPI {
	mock := &MockManagedClustersAPI{ctrl: ctrl}
	mock.recorder = &MockManagedClustersAPIMockRecorder{mock}
	return mock
}

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

// ListClusterAdminCredentials mocks base method.
func (m *MockManagedClustersAPI) ListClusterAdminCredentials(ctx context.Context, resourceGroupName, clusterName string, options *armcontainerservice.ManagedClustersClientListClusterAdminCredentialsOptions) (armcontainerservice.ManagedClustersClientListClusterAdminCredentialsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterAdminCredentials", ctx, resourceGroupName, clusterName, options)
	ret0, _ := ret[0].(armcontainerservice.ManagedClustersClientListClusterAdminCredentialsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterAdminCredentials indicates an expected call of ListClusterAdminCredentials.
func (mr *MockManagedClustersAPIMockRecorder) ListClusterAdminCredentials(ctx, resourceGroupName, clusterName, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterAdminCredentials", reflect.TypeOf((*MockManagedClustersAPI)(nil).ListClusterAdminCredentials), ctx, resourceGroupName, clusterName, options)
}

// ListClusterUserCredentials mocks base method.
func (m *MockManagedClustersAPI) ListClusterUserCredentials(ctx context.Context, resourceGroupName, clusterName string, options *armcontainerservice.ManagedClustersClientListClusterUserCredentialsOptions) (armcontainerservice.ManagedClustersClientListClusterUserCredentialsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterUserCredentials", ctx, resourceGroupName, clusterName, options)
	ret0, _ := ret[0].(armcontainerservice.ManagedClustersClientListClusterUserCredentialsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterUserCredentials indicates an expected call of ListClusterUserCredentials.
func (mr *MockManagedClustersAPIMockRecorder) ListClusterUserCredentials(ctx, resourceGroupName, clusterName, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterUserCredentials", reflect.TypeOf((*MockManagedClustersAPI)(nil).ListClusterUserCredentials), ctx, resourceGroupName, clusterName, options)
}

// MockLoadBalancersAPI is a mock of LoadBalancersAPI interface.
type MockLoadBalancersAPI struct {
	ctrl     *gomock.Controller
	recorder *MockLoadBalancersAPIMockRecorder
}

// MockLoadBalancersAPIMockRecorder is the mock recorder for MockLoadBalancersAPI.
type MockLoadBalancersAPIMockRecorder struct {
	mock *MockLoadBalancersAPI
}

// NewMockLoadBalancersAPI creates a new mock instance.
func NewMockLoadBalancersAPI(ctrl *gomock.Controller) *MockLoadBalancersAPI {
	mock := &MockLoadBalancersAPI{ctrl: ctrl}
	mock.recorder = &MockLoadBalancersAPIMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockLoadBalancersAPI) Get(ctx context.Context, resourceGroupName, loadBalancerName string) (armnetwork.LoadBalancersClientGetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, loadBalancerName)
	ret0, _ := ret[0].(armnetwork.LoadBalancersClientGetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLoadBalancersAPIMockRecorder) Get(ctx, resourceGroupName, loadBalancerName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoadBalancersAPI)(nil).Get), ctx, resourceGroupName, loadBalancerName)
}

// MockPrivateLinkServicesAPI is a mock of PrivateLinkServicesAPI interface.
type MockPrivateLinkServicesAPI struct {
	ctrl     *gomock.Controller
	recorder *MockPrivateLinkServicesAPIMockRecorder
}

// MockPrivateLinkServicesAPIMockRecorder is the mock recorder for MockPrivateLinkServicesAPI.
type MockPrivateLinkServicesAPIMockRecorder struct {
	mock *MockPrivateLinkServicesAPI
}

// NewMockPrivateLinkServicesAPI creates a new mock instance.
func NewMockPrivateLinkServicesAPI(ctrl *gomock.Controller) *MockPrivateLinkServicesAPI {
	mock := &MockPrivateLinkServicesAPI{ctrl: ctrl}
	mock.recorder = &MockPrivateLinkServicesAPIMockRecorder{mock}
	return mock
}

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

// DeletePrivateEndpointConnection mocks base method.
func (m *MockPrivateLinkServicesAPI) DeletePrivateEndpointConnection(ctx context.Context, resourceGroupName, clusterName, connName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePrivateEndpointConnection", ctx, resourceGroupName, clusterName, connName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePrivateEndpointConnection indicates an expected call of DeletePrivateEndpointConnection.
func (mr *MockPrivateLinkServicesAPIMockRecorder) DeletePrivateEndpointConnection(ctx, resourceGroupName, clusterName, connName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePrivateEndpointConnection", reflect.TypeOf((*MockPrivateLinkServicesAPI)(nil).DeletePrivateEndpointConnection), ctx, resourceGroupName, clusterName, connName)
}

// ListPrivateEndpointConnections mocks base method.
func (m *MockPrivateLinkServicesAPI) ListPrivateEndpointConnections(ctx context.Context, resourceGroupName, clusterName string) ([]*armnetwork.PrivateEndpointConnection, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPrivateEndpointConnections", ctx, resourceGroupName, clusterName)
	ret0, _ := ret[0].([]*armnetwork.PrivateEndpointConnection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPrivateEndpointConnections indicates an expected call of ListPrivateEndpointConnections.
func (mr *MockPrivateLinkServicesAPIMockRecorder) ListPrivateEndpointConnections(ctx, resourceGroupName, clusterName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPrivateEndpointConnections", reflect.TypeOf((*MockPrivateLinkServicesAPI)(nil).ListPrivateEndpointConnections), ctx, resourceGroupName, clusterName)
}

// UpdatePrivateEndpointConnection mocks base method.
func (m *MockPrivateLinkServicesAPI) UpdatePrivateEndpointConnection(ctx context.Context, resourceGroupName, clusterName, connName string, params armnetwork.PrivateEndpointConnection) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePrivateEndpointConnection", ctx, resourceGroupName, clusterName, connName, params)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdatePrivateEndpointConnection indicates an expected call of UpdatePrivateEndpointConnection.
func (mr *MockPrivateLinkServicesAPIMockRecorder) UpdatePrivateEndpointConnection(ctx, resourceGroupName, clusterName, connName, params any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrivateEndpointConnection", reflect.TypeOf((*MockPrivateLinkServicesAPI)(nil).UpdatePrivateEndpointConnection), ctx, resourceGroupName, clusterName, connName, params)
}

// MockPrivateEndpointsAPI is a mock of PrivateEndpointsAPI interface.
type MockPrivateEndpointsAPI struct {
	ctrl     *gomock.Controller
	recorder *MockPrivateEndpointsAPIMockRecorder
}

// MockPrivateEndpointsAPIMockRecorder is the mock recorder for MockPrivateEndpointsAPI.
type MockPrivateEndpointsAPIMockRecorder struct {
	mock *MockPrivateEndpointsAPI
}

// NewMockPrivateEndpointsAPI creates a new mock instance.
func NewMockPrivateEndpointsAPI(ctrl *gomock.Controller) *MockPrivateEndpointsAPI {
	mock := &MockPrivateEndpointsAPI{ctrl: ctrl}
	mock.recorder = &MockPrivateEndpointsAPIMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockPrivateEndpointsAPI) Get(ctx context.Context, resourceGroupName, privateEndpointName string) (armnetwork.PrivateEndpointsClientGetResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, resourceGroupName, privateEndpointName)
	ret0, _ := ret[0].(armnetwork.PrivateEndpointsClientGetResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockPrivateEndpointsAPIMockRecorder) Get(ctx, resourceGroupName, privateEndpointName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPrivateEndpointsAPI)(nil).Get), ctx, resourceGroupName, privateEndpointName)
}

// MockStorageAccountsAPI is a mock of StorageAccountsAPI interface.
type MockStorageAccountsAPI struct {
	ctrl     *gomock.Controller
	recorder *MockStorageAccountsAPIMockRecorder
}

// MockStorageAccountsAPIMockRecorder is the mock recorder for MockStorageAccountsAPI.
type MockStorageAccountsAPIMockRecorder struct {
	mock *MockStorageAccountsAPI
}

// NewMockStorageAccountsAPI creates a new mock instance.
func NewMockStorageAccountsAPI(ctrl *gomock.Controller) *MockStorageAccountsAPI {
	mock := &MockStorageAccountsAPI{ctrl: ctrl}
	mock.recorder = &MockStorageAccountsAPIMockRecorder{mock}
	return mock
}

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

// StorageAccountContainerExists mocks base method.
func (m *MockStorageAccountsAPI) StorageAccountContainerExists(ctx context.Context, resourceGroupName, accountName, containerName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StorageAccountContainerExists", ctx, resourceGroupName, accountName, containerName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StorageAccountContainerExists indicates an expected call of StorageAccountContainerExists.
func (mr *MockStorageAccountsAPIMockRecorder) StorageAccountContainerExists(ctx, resourceGroupName, accountName, containerName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAccountContainerExists", reflect.TypeOf((*MockStorageAccountsAPI)(nil).StorageAccountContainerExists), ctx, resourceGroupName, accountName, containerName)
}

// StorageAccountHasContainers mocks base method.
func (m *MockStorageAccountsAPI) StorageAccountHasContainers(ctx context.Context, resourceGroupName, accountName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StorageAccountHasContainers", ctx, resourceGroupName, accountName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StorageAccountHasContainers indicates an expected call of StorageAccountHasContainers.
func (mr *MockStorageAccountsAPIMockRecorder) StorageAccountHasContainers(ctx, resourceGroupName, accountName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StorageAccountHasContainers", reflect.TypeOf((*MockStorageAccountsAPI)(nil).StorageAccountHasContainers), ctx, resourceGroupName, accountName)
}

// MockBlobContainersAPI is a mock of BlobContainersAPI interface.
type MockBlobContainersAPI struct {
	ctrl     *gomock.Controller
	recorder *MockBlobContainersAPIMockRecorder
}

// MockBlobContainersAPIMockRecorder is the mock recorder for MockBlobContainersAPI.
type MockBlobContainersAPIMockRecorder struct {
	mock *MockBlobContainersAPI
}

// NewMockBlobContainersAPI creates a new mock instance.
func NewMockBlobContainersAPI(ctrl *gomock.Controller) *MockBlobContainersAPI {
	mock := &MockBlobContainersAPI{ctrl: ctrl}
	mock.recorder = &MockBlobContainersAPIMockRecorder{mock}
	return mock
}

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

// ContainerHasBlobs mocks base method.
func (m *MockBlobContainersAPI) ContainerHasBlobs(ctx context.Context, accountName, containerName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerHasBlobs", ctx, accountName, containerName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerHasBlobs indicates an expected call of ContainerHasBlobs.
func (mr *MockBlobContainersAPIMockRecorder) ContainerHasBlobs(ctx, accountName, containerName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainerHasBlobs", reflect.TypeOf((*MockBlobContainersAPI)(nil).ContainerHasBlobs), ctx, accountName, containerName)
}