internal/resources/providers/azurelib/mock_provider_api.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

// Code generated by mockery v2.53.3. DO NOT EDIT.

package azurelib

import (
	context "context"

	cycle "github.com/elastic/cloudbeat/internal/resources/fetching/cycle"
	governance "github.com/elastic/cloudbeat/internal/resources/providers/azurelib/governance"

	inventory "github.com/elastic/cloudbeat/internal/resources/providers/azurelib/inventory"

	mock "github.com/stretchr/testify/mock"
)

// MockProviderAPI is an autogenerated mock type for the ProviderAPI type
type MockProviderAPI struct {
	mock.Mock
}

type MockProviderAPI_Expecter struct {
	mock *mock.Mock
}

func (_m *MockProviderAPI) EXPECT() *MockProviderAPI_Expecter {
	return &MockProviderAPI_Expecter{mock: &_m.Mock}
}

// GetAppServiceAuthSettings provides a mock function with given fields: ctx, webApp
func (_m *MockProviderAPI) GetAppServiceAuthSettings(ctx context.Context, webApp inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, webApp)

	if len(ret) == 0 {
		panic("no return value specified for GetAppServiceAuthSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, webApp)
	}
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, webApp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, inventory.AzureAsset) error); ok {
		r1 = rf(ctx, webApp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_GetAppServiceAuthSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppServiceAuthSettings'
type MockProviderAPI_GetAppServiceAuthSettings_Call struct {
	*mock.Call
}

// GetAppServiceAuthSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - webApp inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) GetAppServiceAuthSettings(ctx interface{}, webApp interface{}) *MockProviderAPI_GetAppServiceAuthSettings_Call {
	return &MockProviderAPI_GetAppServiceAuthSettings_Call{Call: _e.mock.On("GetAppServiceAuthSettings", ctx, webApp)}
}

func (_c *MockProviderAPI_GetAppServiceAuthSettings_Call) Run(run func(ctx context.Context, webApp inventory.AzureAsset)) *MockProviderAPI_GetAppServiceAuthSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_GetAppServiceAuthSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_GetAppServiceAuthSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_GetAppServiceAuthSettings_Call) RunAndReturn(run func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_GetAppServiceAuthSettings_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppServiceSiteConfig provides a mock function with given fields: ctx, webApp
func (_m *MockProviderAPI) GetAppServiceSiteConfig(ctx context.Context, webApp inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, webApp)

	if len(ret) == 0 {
		panic("no return value specified for GetAppServiceSiteConfig")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, webApp)
	}
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, webApp)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, inventory.AzureAsset) error); ok {
		r1 = rf(ctx, webApp)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_GetAppServiceSiteConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppServiceSiteConfig'
type MockProviderAPI_GetAppServiceSiteConfig_Call struct {
	*mock.Call
}

// GetAppServiceSiteConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - webApp inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) GetAppServiceSiteConfig(ctx interface{}, webApp interface{}) *MockProviderAPI_GetAppServiceSiteConfig_Call {
	return &MockProviderAPI_GetAppServiceSiteConfig_Call{Call: _e.mock.On("GetAppServiceSiteConfig", ctx, webApp)}
}

func (_c *MockProviderAPI_GetAppServiceSiteConfig_Call) Run(run func(ctx context.Context, webApp inventory.AzureAsset)) *MockProviderAPI_GetAppServiceSiteConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_GetAppServiceSiteConfig_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_GetAppServiceSiteConfig_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_GetAppServiceSiteConfig_Call) RunAndReturn(run func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_GetAppServiceSiteConfig_Call {
	_c.Call.Return(run)
	return _c
}

// GetFlexibleTLSVersionConfiguration provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) GetFlexibleTLSVersionConfiguration(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for GetFlexibleTLSVersionConfiguration")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFlexibleTLSVersionConfiguration'
type MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call struct {
	*mock.Call
}

// GetFlexibleTLSVersionConfiguration is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) GetFlexibleTLSVersionConfiguration(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call {
	return &MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call{Call: _e.mock.On("GetFlexibleTLSVersionConfiguration", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_GetFlexibleTLSVersionConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// GetSQLBlobAuditingPolicies provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) GetSQLBlobAuditingPolicies(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for GetSQLBlobAuditingPolicies")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_GetSQLBlobAuditingPolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSQLBlobAuditingPolicies'
type MockProviderAPI_GetSQLBlobAuditingPolicies_Call struct {
	*mock.Call
}

// GetSQLBlobAuditingPolicies is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) GetSQLBlobAuditingPolicies(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_GetSQLBlobAuditingPolicies_Call {
	return &MockProviderAPI_GetSQLBlobAuditingPolicies_Call{Call: _e.mock.On("GetSQLBlobAuditingPolicies", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_GetSQLBlobAuditingPolicies_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_GetSQLBlobAuditingPolicies_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_GetSQLBlobAuditingPolicies_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_GetSQLBlobAuditingPolicies_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_GetSQLBlobAuditingPolicies_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_GetSQLBlobAuditingPolicies_Call {
	_c.Call.Return(run)
	return _c
}

// GetSubscriptions provides a mock function with given fields: ctx, cycleMetadata
func (_m *MockProviderAPI) GetSubscriptions(ctx context.Context, cycleMetadata cycle.Metadata) (map[string]governance.Subscription, error) {
	ret := _m.Called(ctx, cycleMetadata)

	if len(ret) == 0 {
		panic("no return value specified for GetSubscriptions")
	}

	var r0 map[string]governance.Subscription
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, cycle.Metadata) (map[string]governance.Subscription, error)); ok {
		return rf(ctx, cycleMetadata)
	}
	if rf, ok := ret.Get(0).(func(context.Context, cycle.Metadata) map[string]governance.Subscription); ok {
		r0 = rf(ctx, cycleMetadata)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]governance.Subscription)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, cycle.Metadata) error); ok {
		r1 = rf(ctx, cycleMetadata)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_GetSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSubscriptions'
type MockProviderAPI_GetSubscriptions_Call struct {
	*mock.Call
}

// GetSubscriptions is a helper method to define mock.On call
//   - ctx context.Context
//   - cycleMetadata cycle.Metadata
func (_e *MockProviderAPI_Expecter) GetSubscriptions(ctx interface{}, cycleMetadata interface{}) *MockProviderAPI_GetSubscriptions_Call {
	return &MockProviderAPI_GetSubscriptions_Call{Call: _e.mock.On("GetSubscriptions", ctx, cycleMetadata)}
}

func (_c *MockProviderAPI_GetSubscriptions_Call) Run(run func(ctx context.Context, cycleMetadata cycle.Metadata)) *MockProviderAPI_GetSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(cycle.Metadata))
	})
	return _c
}

func (_c *MockProviderAPI_GetSubscriptions_Call) Return(_a0 map[string]governance.Subscription, _a1 error) *MockProviderAPI_GetSubscriptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_GetSubscriptions_Call) RunAndReturn(run func(context.Context, cycle.Metadata) (map[string]governance.Subscription, error)) *MockProviderAPI_GetSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// ListAllAssetTypesByName provides a mock function with given fields: ctx, assetsGroup, assets
func (_m *MockProviderAPI) ListAllAssetTypesByName(ctx context.Context, assetsGroup string, assets []string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, assetsGroup, assets)

	if len(ret) == 0 {
		panic("no return value specified for ListAllAssetTypesByName")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, assetsGroup, assets)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, assetsGroup, assets)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = rf(ctx, assetsGroup, assets)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListAllAssetTypesByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllAssetTypesByName'
type MockProviderAPI_ListAllAssetTypesByName_Call struct {
	*mock.Call
}

// ListAllAssetTypesByName is a helper method to define mock.On call
//   - ctx context.Context
//   - assetsGroup string
//   - assets []string
func (_e *MockProviderAPI_Expecter) ListAllAssetTypesByName(ctx interface{}, assetsGroup interface{}, assets interface{}) *MockProviderAPI_ListAllAssetTypesByName_Call {
	return &MockProviderAPI_ListAllAssetTypesByName_Call{Call: _e.mock.On("ListAllAssetTypesByName", ctx, assetsGroup, assets)}
}

func (_c *MockProviderAPI_ListAllAssetTypesByName_Call) Run(run func(ctx context.Context, assetsGroup string, assets []string)) *MockProviderAPI_ListAllAssetTypesByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]string))
	})
	return _c
}

func (_c *MockProviderAPI_ListAllAssetTypesByName_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListAllAssetTypesByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListAllAssetTypesByName_Call) RunAndReturn(run func(context.Context, string, []string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListAllAssetTypesByName_Call {
	_c.Call.Return(run)
	return _c
}

// ListAutoProvisioningSettings provides a mock function with given fields: ctx, subscriptionID
func (_m *MockProviderAPI) ListAutoProvisioningSettings(ctx context.Context, subscriptionID string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subscriptionID)

	if len(ret) == 0 {
		panic("no return value specified for ListAutoProvisioningSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subscriptionID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subscriptionID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, subscriptionID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListAutoProvisioningSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAutoProvisioningSettings'
type MockProviderAPI_ListAutoProvisioningSettings_Call struct {
	*mock.Call
}

// ListAutoProvisioningSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - subscriptionID string
func (_e *MockProviderAPI_Expecter) ListAutoProvisioningSettings(ctx interface{}, subscriptionID interface{}) *MockProviderAPI_ListAutoProvisioningSettings_Call {
	return &MockProviderAPI_ListAutoProvisioningSettings_Call{Call: _e.mock.On("ListAutoProvisioningSettings", ctx, subscriptionID)}
}

func (_c *MockProviderAPI_ListAutoProvisioningSettings_Call) Run(run func(ctx context.Context, subscriptionID string)) *MockProviderAPI_ListAutoProvisioningSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListAutoProvisioningSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListAutoProvisioningSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListAutoProvisioningSettings_Call) RunAndReturn(run func(context.Context, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListAutoProvisioningSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListDiagnosticSettingsAssetTypes provides a mock function with given fields: ctx, cycleMetadata, subscriptionIDs
func (_m *MockProviderAPI) ListDiagnosticSettingsAssetTypes(ctx context.Context, cycleMetadata cycle.Metadata, subscriptionIDs []string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, cycleMetadata, subscriptionIDs)

	if len(ret) == 0 {
		panic("no return value specified for ListDiagnosticSettingsAssetTypes")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, cycle.Metadata, []string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, cycleMetadata, subscriptionIDs)
	}
	if rf, ok := ret.Get(0).(func(context.Context, cycle.Metadata, []string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, cycleMetadata, subscriptionIDs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, cycle.Metadata, []string) error); ok {
		r1 = rf(ctx, cycleMetadata, subscriptionIDs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDiagnosticSettingsAssetTypes'
type MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call struct {
	*mock.Call
}

// ListDiagnosticSettingsAssetTypes is a helper method to define mock.On call
//   - ctx context.Context
//   - cycleMetadata cycle.Metadata
//   - subscriptionIDs []string
func (_e *MockProviderAPI_Expecter) ListDiagnosticSettingsAssetTypes(ctx interface{}, cycleMetadata interface{}, subscriptionIDs interface{}) *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call {
	return &MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call{Call: _e.mock.On("ListDiagnosticSettingsAssetTypes", ctx, cycleMetadata, subscriptionIDs)}
}

func (_c *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call) Run(run func(ctx context.Context, cycleMetadata cycle.Metadata, subscriptionIDs []string)) *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(cycle.Metadata), args[2].([]string))
	})
	return _c
}

func (_c *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call) RunAndReturn(run func(context.Context, cycle.Metadata, []string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListDiagnosticSettingsAssetTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListFlexiblePostgresConfigurations provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListFlexiblePostgresConfigurations(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListFlexiblePostgresConfigurations")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListFlexiblePostgresConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFlexiblePostgresConfigurations'
type MockProviderAPI_ListFlexiblePostgresConfigurations_Call struct {
	*mock.Call
}

// ListFlexiblePostgresConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListFlexiblePostgresConfigurations(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListFlexiblePostgresConfigurations_Call {
	return &MockProviderAPI_ListFlexiblePostgresConfigurations_Call{Call: _e.mock.On("ListFlexiblePostgresConfigurations", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListFlexiblePostgresConfigurations_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListFlexiblePostgresConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListFlexiblePostgresConfigurations_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListFlexiblePostgresConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListFlexiblePostgresConfigurations_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListFlexiblePostgresConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// ListFlexiblePostgresFirewallRules provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListFlexiblePostgresFirewallRules(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListFlexiblePostgresFirewallRules")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListFlexiblePostgresFirewallRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFlexiblePostgresFirewallRules'
type MockProviderAPI_ListFlexiblePostgresFirewallRules_Call struct {
	*mock.Call
}

// ListFlexiblePostgresFirewallRules is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListFlexiblePostgresFirewallRules(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call {
	return &MockProviderAPI_ListFlexiblePostgresFirewallRules_Call{Call: _e.mock.On("ListFlexiblePostgresFirewallRules", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListFlexiblePostgresFirewallRules_Call {
	_c.Call.Return(run)
	return _c
}

// ListKeyVaultDiagnosticSettings provides a mock function with given fields: ctx, vault
func (_m *MockProviderAPI) ListKeyVaultDiagnosticSettings(ctx context.Context, vault inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, vault)

	if len(ret) == 0 {
		panic("no return value specified for ListKeyVaultDiagnosticSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, vault)
	}
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, vault)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, inventory.AzureAsset) error); ok {
		r1 = rf(ctx, vault)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListKeyVaultDiagnosticSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListKeyVaultDiagnosticSettings'
type MockProviderAPI_ListKeyVaultDiagnosticSettings_Call struct {
	*mock.Call
}

// ListKeyVaultDiagnosticSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - vault inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListKeyVaultDiagnosticSettings(ctx interface{}, vault interface{}) *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call {
	return &MockProviderAPI_ListKeyVaultDiagnosticSettings_Call{Call: _e.mock.On("ListKeyVaultDiagnosticSettings", ctx, vault)}
}

func (_c *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call) Run(run func(ctx context.Context, vault inventory.AzureAsset)) *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call) RunAndReturn(run func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListKeyVaultDiagnosticSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListKeyVaultKeys provides a mock function with given fields: ctx, vault
func (_m *MockProviderAPI) ListKeyVaultKeys(ctx context.Context, vault inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, vault)

	if len(ret) == 0 {
		panic("no return value specified for ListKeyVaultKeys")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, vault)
	}
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, vault)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, inventory.AzureAsset) error); ok {
		r1 = rf(ctx, vault)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListKeyVaultKeys_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListKeyVaultKeys'
type MockProviderAPI_ListKeyVaultKeys_Call struct {
	*mock.Call
}

// ListKeyVaultKeys is a helper method to define mock.On call
//   - ctx context.Context
//   - vault inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListKeyVaultKeys(ctx interface{}, vault interface{}) *MockProviderAPI_ListKeyVaultKeys_Call {
	return &MockProviderAPI_ListKeyVaultKeys_Call{Call: _e.mock.On("ListKeyVaultKeys", ctx, vault)}
}

func (_c *MockProviderAPI_ListKeyVaultKeys_Call) Run(run func(ctx context.Context, vault inventory.AzureAsset)) *MockProviderAPI_ListKeyVaultKeys_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultKeys_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListKeyVaultKeys_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultKeys_Call) RunAndReturn(run func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListKeyVaultKeys_Call {
	_c.Call.Return(run)
	return _c
}

// ListKeyVaultSecrets provides a mock function with given fields: ctx, vault
func (_m *MockProviderAPI) ListKeyVaultSecrets(ctx context.Context, vault inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, vault)

	if len(ret) == 0 {
		panic("no return value specified for ListKeyVaultSecrets")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, vault)
	}
	if rf, ok := ret.Get(0).(func(context.Context, inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, vault)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, inventory.AzureAsset) error); ok {
		r1 = rf(ctx, vault)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListKeyVaultSecrets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListKeyVaultSecrets'
type MockProviderAPI_ListKeyVaultSecrets_Call struct {
	*mock.Call
}

// ListKeyVaultSecrets is a helper method to define mock.On call
//   - ctx context.Context
//   - vault inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListKeyVaultSecrets(ctx interface{}, vault interface{}) *MockProviderAPI_ListKeyVaultSecrets_Call {
	return &MockProviderAPI_ListKeyVaultSecrets_Call{Call: _e.mock.On("ListKeyVaultSecrets", ctx, vault)}
}

func (_c *MockProviderAPI_ListKeyVaultSecrets_Call) Run(run func(ctx context.Context, vault inventory.AzureAsset)) *MockProviderAPI_ListKeyVaultSecrets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultSecrets_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListKeyVaultSecrets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListKeyVaultSecrets_Call) RunAndReturn(run func(context.Context, inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListKeyVaultSecrets_Call {
	_c.Call.Return(run)
	return _c
}

// ListLocations provides a mock function with given fields: ctx, subID
func (_m *MockProviderAPI) ListLocations(ctx context.Context, subID string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID)

	if len(ret) == 0 {
		panic("no return value specified for ListLocations")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, subID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListLocations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListLocations'
type MockProviderAPI_ListLocations_Call struct {
	*mock.Call
}

// ListLocations is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
func (_e *MockProviderAPI_Expecter) ListLocations(ctx interface{}, subID interface{}) *MockProviderAPI_ListLocations_Call {
	return &MockProviderAPI_ListLocations_Call{Call: _e.mock.On("ListLocations", ctx, subID)}
}

func (_c *MockProviderAPI_ListLocations_Call) Run(run func(ctx context.Context, subID string)) *MockProviderAPI_ListLocations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListLocations_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListLocations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListLocations_Call) RunAndReturn(run func(context.Context, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListLocations_Call {
	_c.Call.Return(run)
	return _c
}

// ListSQLAdvancedThreatProtectionSettings provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSQLAdvancedThreatProtectionSettings(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSQLAdvancedThreatProtectionSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSQLAdvancedThreatProtectionSettings'
type MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call struct {
	*mock.Call
}

// ListSQLAdvancedThreatProtectionSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSQLAdvancedThreatProtectionSettings(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call {
	return &MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call{Call: _e.mock.On("ListSQLAdvancedThreatProtectionSettings", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSQLAdvancedThreatProtectionSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListSQLEncryptionProtector provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSQLEncryptionProtector(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSQLEncryptionProtector")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSQLEncryptionProtector_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSQLEncryptionProtector'
type MockProviderAPI_ListSQLEncryptionProtector_Call struct {
	*mock.Call
}

// ListSQLEncryptionProtector is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSQLEncryptionProtector(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSQLEncryptionProtector_Call {
	return &MockProviderAPI_ListSQLEncryptionProtector_Call{Call: _e.mock.On("ListSQLEncryptionProtector", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSQLEncryptionProtector_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSQLEncryptionProtector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSQLEncryptionProtector_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSQLEncryptionProtector_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSQLEncryptionProtector_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSQLEncryptionProtector_Call {
	_c.Call.Return(run)
	return _c
}

// ListSQLFirewallRules provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSQLFirewallRules(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSQLFirewallRules")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSQLFirewallRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSQLFirewallRules'
type MockProviderAPI_ListSQLFirewallRules_Call struct {
	*mock.Call
}

// ListSQLFirewallRules is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSQLFirewallRules(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSQLFirewallRules_Call {
	return &MockProviderAPI_ListSQLFirewallRules_Call{Call: _e.mock.On("ListSQLFirewallRules", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSQLFirewallRules_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSQLFirewallRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSQLFirewallRules_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSQLFirewallRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSQLFirewallRules_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSQLFirewallRules_Call {
	_c.Call.Return(run)
	return _c
}

// ListSQLTransparentDataEncryptions provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSQLTransparentDataEncryptions(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSQLTransparentDataEncryptions")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSQLTransparentDataEncryptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSQLTransparentDataEncryptions'
type MockProviderAPI_ListSQLTransparentDataEncryptions_Call struct {
	*mock.Call
}

// ListSQLTransparentDataEncryptions is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSQLTransparentDataEncryptions(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSQLTransparentDataEncryptions_Call {
	return &MockProviderAPI_ListSQLTransparentDataEncryptions_Call{Call: _e.mock.On("ListSQLTransparentDataEncryptions", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSQLTransparentDataEncryptions_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSQLTransparentDataEncryptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSQLTransparentDataEncryptions_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSQLTransparentDataEncryptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSQLTransparentDataEncryptions_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSQLTransparentDataEncryptions_Call {
	_c.Call.Return(run)
	return _c
}

// ListSecurityContacts provides a mock function with given fields: ctx, subscriptionID
func (_m *MockProviderAPI) ListSecurityContacts(ctx context.Context, subscriptionID string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subscriptionID)

	if len(ret) == 0 {
		panic("no return value specified for ListSecurityContacts")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subscriptionID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subscriptionID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, subscriptionID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSecurityContacts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSecurityContacts'
type MockProviderAPI_ListSecurityContacts_Call struct {
	*mock.Call
}

// ListSecurityContacts is a helper method to define mock.On call
//   - ctx context.Context
//   - subscriptionID string
func (_e *MockProviderAPI_Expecter) ListSecurityContacts(ctx interface{}, subscriptionID interface{}) *MockProviderAPI_ListSecurityContacts_Call {
	return &MockProviderAPI_ListSecurityContacts_Call{Call: _e.mock.On("ListSecurityContacts", ctx, subscriptionID)}
}

func (_c *MockProviderAPI_ListSecurityContacts_Call) Run(run func(ctx context.Context, subscriptionID string)) *MockProviderAPI_ListSecurityContacts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSecurityContacts_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSecurityContacts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSecurityContacts_Call) RunAndReturn(run func(context.Context, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSecurityContacts_Call {
	_c.Call.Return(run)
	return _c
}

// ListSinglePostgresConfigurations provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSinglePostgresConfigurations(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSinglePostgresConfigurations")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSinglePostgresConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSinglePostgresConfigurations'
type MockProviderAPI_ListSinglePostgresConfigurations_Call struct {
	*mock.Call
}

// ListSinglePostgresConfigurations is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSinglePostgresConfigurations(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSinglePostgresConfigurations_Call {
	return &MockProviderAPI_ListSinglePostgresConfigurations_Call{Call: _e.mock.On("ListSinglePostgresConfigurations", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSinglePostgresConfigurations_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSinglePostgresConfigurations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSinglePostgresConfigurations_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSinglePostgresConfigurations_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSinglePostgresConfigurations_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSinglePostgresConfigurations_Call {
	_c.Call.Return(run)
	return _c
}

// ListSinglePostgresFirewallRules provides a mock function with given fields: ctx, subID, resourceGroup, serverName
func (_m *MockProviderAPI) ListSinglePostgresFirewallRules(ctx context.Context, subID string, resourceGroup string, serverName string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, subID, resourceGroup, serverName)

	if len(ret) == 0 {
		panic("no return value specified for ListSinglePostgresFirewallRules")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, subID, resourceGroup, serverName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, subID, resourceGroup, serverName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSinglePostgresFirewallRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSinglePostgresFirewallRules'
type MockProviderAPI_ListSinglePostgresFirewallRules_Call struct {
	*mock.Call
}

// ListSinglePostgresFirewallRules is a helper method to define mock.On call
//   - ctx context.Context
//   - subID string
//   - resourceGroup string
//   - serverName string
func (_e *MockProviderAPI_Expecter) ListSinglePostgresFirewallRules(ctx interface{}, subID interface{}, resourceGroup interface{}, serverName interface{}) *MockProviderAPI_ListSinglePostgresFirewallRules_Call {
	return &MockProviderAPI_ListSinglePostgresFirewallRules_Call{Call: _e.mock.On("ListSinglePostgresFirewallRules", ctx, subID, resourceGroup, serverName)}
}

func (_c *MockProviderAPI_ListSinglePostgresFirewallRules_Call) Run(run func(ctx context.Context, subID string, resourceGroup string, serverName string)) *MockProviderAPI_ListSinglePostgresFirewallRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockProviderAPI_ListSinglePostgresFirewallRules_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSinglePostgresFirewallRules_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSinglePostgresFirewallRules_Call) RunAndReturn(run func(context.Context, string, string, string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSinglePostgresFirewallRules_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountBlobContainers provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountBlobContainers(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountBlobContainers")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountBlobContainers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountBlobContainers'
type MockProviderAPI_ListStorageAccountBlobContainers_Call struct {
	*mock.Call
}

// ListStorageAccountBlobContainers is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountBlobContainers(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountBlobContainers_Call {
	return &MockProviderAPI_ListStorageAccountBlobContainers_Call{Call: _e.mock.On("ListStorageAccountBlobContainers", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountBlobContainers_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountBlobContainers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountBlobContainers_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountBlobContainers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountBlobContainers_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountBlobContainers_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountBlobServices provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountBlobServices(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountBlobServices")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountBlobServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountBlobServices'
type MockProviderAPI_ListStorageAccountBlobServices_Call struct {
	*mock.Call
}

// ListStorageAccountBlobServices is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountBlobServices(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountBlobServices_Call {
	return &MockProviderAPI_ListStorageAccountBlobServices_Call{Call: _e.mock.On("ListStorageAccountBlobServices", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountBlobServices_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountBlobServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountBlobServices_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountBlobServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountBlobServices_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountBlobServices_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountFileServices provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountFileServices(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountFileServices")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountFileServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountFileServices'
type MockProviderAPI_ListStorageAccountFileServices_Call struct {
	*mock.Call
}

// ListStorageAccountFileServices is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountFileServices(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountFileServices_Call {
	return &MockProviderAPI_ListStorageAccountFileServices_Call{Call: _e.mock.On("ListStorageAccountFileServices", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountFileServices_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountFileServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountFileServices_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountFileServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountFileServices_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountFileServices_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountFileShares provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountFileShares(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountFileShares")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountFileShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountFileShares'
type MockProviderAPI_ListStorageAccountFileShares_Call struct {
	*mock.Call
}

// ListStorageAccountFileShares is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountFileShares(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountFileShares_Call {
	return &MockProviderAPI_ListStorageAccountFileShares_Call{Call: _e.mock.On("ListStorageAccountFileShares", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountFileShares_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountFileShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountFileShares_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountFileShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountFileShares_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountFileShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountQueueServices provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountQueueServices(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountQueueServices")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountQueueServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountQueueServices'
type MockProviderAPI_ListStorageAccountQueueServices_Call struct {
	*mock.Call
}

// ListStorageAccountQueueServices is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountQueueServices(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountQueueServices_Call {
	return &MockProviderAPI_ListStorageAccountQueueServices_Call{Call: _e.mock.On("ListStorageAccountQueueServices", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountQueueServices_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountQueueServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountQueueServices_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountQueueServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountQueueServices_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountQueueServices_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountQueues provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountQueues(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountQueues")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountQueues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountQueues'
type MockProviderAPI_ListStorageAccountQueues_Call struct {
	*mock.Call
}

// ListStorageAccountQueues is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountQueues(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountQueues_Call {
	return &MockProviderAPI_ListStorageAccountQueues_Call{Call: _e.mock.On("ListStorageAccountQueues", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountQueues_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountQueues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountQueues_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountQueues_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountQueues_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountQueues_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountTableServices provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountTableServices(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountTableServices")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountTableServices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountTableServices'
type MockProviderAPI_ListStorageAccountTableServices_Call struct {
	*mock.Call
}

// ListStorageAccountTableServices is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountTableServices(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountTableServices_Call {
	return &MockProviderAPI_ListStorageAccountTableServices_Call{Call: _e.mock.On("ListStorageAccountTableServices", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountTableServices_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountTableServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountTableServices_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountTableServices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountTableServices_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountTableServices_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountTables provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountTables(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountTables")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountTables_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountTables'
type MockProviderAPI_ListStorageAccountTables_Call struct {
	*mock.Call
}

// ListStorageAccountTables is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountTables(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountTables_Call {
	return &MockProviderAPI_ListStorageAccountTables_Call{Call: _e.mock.On("ListStorageAccountTables", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountTables_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountTables_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountTables_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountTables_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccounts provides a mock function with given fields: ctx, storageAccountsSubscriptionsIds
func (_m *MockProviderAPI) ListStorageAccounts(ctx context.Context, storageAccountsSubscriptionsIds []string) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccountsSubscriptionsIds)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccounts")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []string) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccountsSubscriptionsIds)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []string) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccountsSubscriptionsIds)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
		r1 = rf(ctx, storageAccountsSubscriptionsIds)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccounts'
type MockProviderAPI_ListStorageAccounts_Call struct {
	*mock.Call
}

// ListStorageAccounts is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccountsSubscriptionsIds []string
func (_e *MockProviderAPI_Expecter) ListStorageAccounts(ctx interface{}, storageAccountsSubscriptionsIds interface{}) *MockProviderAPI_ListStorageAccounts_Call {
	return &MockProviderAPI_ListStorageAccounts_Call{Call: _e.mock.On("ListStorageAccounts", ctx, storageAccountsSubscriptionsIds)}
}

func (_c *MockProviderAPI_ListStorageAccounts_Call) Run(run func(ctx context.Context, storageAccountsSubscriptionsIds []string)) *MockProviderAPI_ListStorageAccounts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]string))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccounts_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccounts_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccounts_Call) RunAndReturn(run func(context.Context, []string) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccounts_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountsBlobDiagnosticSettings provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountsBlobDiagnosticSettings(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountsBlobDiagnosticSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountsBlobDiagnosticSettings'
type MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call struct {
	*mock.Call
}

// ListStorageAccountsBlobDiagnosticSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountsBlobDiagnosticSettings(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call {
	return &MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call{Call: _e.mock.On("ListStorageAccountsBlobDiagnosticSettings", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountsBlobDiagnosticSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountsQueueDiagnosticSettings provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountsQueueDiagnosticSettings(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountsQueueDiagnosticSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountsQueueDiagnosticSettings'
type MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call struct {
	*mock.Call
}

// ListStorageAccountsQueueDiagnosticSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountsQueueDiagnosticSettings(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call {
	return &MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call{Call: _e.mock.On("ListStorageAccountsQueueDiagnosticSettings", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountsQueueDiagnosticSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageAccountsTableDiagnosticSettings provides a mock function with given fields: ctx, storageAccounts
func (_m *MockProviderAPI) ListStorageAccountsTableDiagnosticSettings(ctx context.Context, storageAccounts []inventory.AzureAsset) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx, storageAccounts)

	if len(ret) == 0 {
		panic("no return value specified for ListStorageAccountsTableDiagnosticSettings")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx, storageAccounts)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []inventory.AzureAsset) []inventory.AzureAsset); ok {
		r0 = rf(ctx, storageAccounts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []inventory.AzureAsset) error); ok {
		r1 = rf(ctx, storageAccounts)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageAccountsTableDiagnosticSettings'
type MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call struct {
	*mock.Call
}

// ListStorageAccountsTableDiagnosticSettings is a helper method to define mock.On call
//   - ctx context.Context
//   - storageAccounts []inventory.AzureAsset
func (_e *MockProviderAPI_Expecter) ListStorageAccountsTableDiagnosticSettings(ctx interface{}, storageAccounts interface{}) *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call {
	return &MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call{Call: _e.mock.On("ListStorageAccountsTableDiagnosticSettings", ctx, storageAccounts)}
}

func (_c *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call) Run(run func(ctx context.Context, storageAccounts []inventory.AzureAsset)) *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]inventory.AzureAsset))
	})
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call) RunAndReturn(run func(context.Context, []inventory.AzureAsset) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListStorageAccountsTableDiagnosticSettings_Call {
	_c.Call.Return(run)
	return _c
}

// ListSubscriptions provides a mock function with given fields: ctx
func (_m *MockProviderAPI) ListSubscriptions(ctx context.Context) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListSubscriptions")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []inventory.AzureAsset); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSubscriptions'
type MockProviderAPI_ListSubscriptions_Call struct {
	*mock.Call
}

// ListSubscriptions is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockProviderAPI_Expecter) ListSubscriptions(ctx interface{}) *MockProviderAPI_ListSubscriptions_Call {
	return &MockProviderAPI_ListSubscriptions_Call{Call: _e.mock.On("ListSubscriptions", ctx)}
}

func (_c *MockProviderAPI_ListSubscriptions_Call) Run(run func(ctx context.Context)) *MockProviderAPI_ListSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockProviderAPI_ListSubscriptions_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListSubscriptions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListSubscriptions_Call) RunAndReturn(run func(context.Context) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// ListTenants provides a mock function with given fields: ctx
func (_m *MockProviderAPI) ListTenants(ctx context.Context) ([]inventory.AzureAsset, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for ListTenants")
	}

	var r0 []inventory.AzureAsset
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]inventory.AzureAsset, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []inventory.AzureAsset); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]inventory.AzureAsset)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockProviderAPI_ListTenants_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTenants'
type MockProviderAPI_ListTenants_Call struct {
	*mock.Call
}

// ListTenants is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockProviderAPI_Expecter) ListTenants(ctx interface{}) *MockProviderAPI_ListTenants_Call {
	return &MockProviderAPI_ListTenants_Call{Call: _e.mock.On("ListTenants", ctx)}
}

func (_c *MockProviderAPI_ListTenants_Call) Run(run func(ctx context.Context)) *MockProviderAPI_ListTenants_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockProviderAPI_ListTenants_Call) Return(_a0 []inventory.AzureAsset, _a1 error) *MockProviderAPI_ListTenants_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockProviderAPI_ListTenants_Call) RunAndReturn(run func(context.Context) ([]inventory.AzureAsset, error)) *MockProviderAPI_ListTenants_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockProviderAPI creates a new instance of MockProviderAPI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockProviderAPI(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProviderAPI {
	mock := &MockProviderAPI{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}