func (ar *AzureReader) ListVirtualNetworkPeerings(ctx context.Context, virtualNetworkName string) ([]network.VirtualNetworkPeering, error) {
	client := network.NewVirtualNetworkPeeringsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName(), virtualNetworkName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.VirtualNetworkPeering from Azure APIs")
	}
	resources := make([]network.VirtualNetworkPeering, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
ListVirtualNetworkPeerings returns a list of VirtualNetworkPeerings within a subscription and a resource group
package azurerm
import (
	"context"
	"github.com/pkg/errors"
	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2019-07-01/compute"
	"github.com/Azure/azure-sdk-for-go/services/containerregistry/mgmt/2019-05-01/containerregistry"
	"github.com/Azure/azure-sdk-for-go/services/logic/mgmt/2019-05-01/logic"
	"github.com/Azure/azure-sdk-for-go/services/mariadb/mgmt/2020-01-01/mariadb"
	"github.com/Azure/azure-sdk-for-go/services/mysql/mgmt/2020-01-01/mysql"
	"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2019-06-01/network"
	"github.com/Azure/azure-sdk-for-go/services/postgresql/mgmt/2020-01-01/postgresql"
	"github.com/Azure/azure-sdk-for-go/services/preview/desktopvirtualization/mgmt/2019-12-10-preview/desktopvirtualization"
	"github.com/Azure/azure-sdk-for-go/services/sql/mgmt/2014-04-01/sql"
	"github.com/Azure/azure-sdk-for-go/services/storage/mgmt/2021-02-01/storage"
)
func (ar *AzureReader) ListVirtualMachines(ctx context.Context) ([]compute.VirtualMachine, error) {
	client := compute.NewVirtualMachinesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list compute.VirtualMachine from Azure APIs")
	}
	resources := make([]compute.VirtualMachine, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListVirtualMachineScaleSets(ctx context.Context) ([]compute.VirtualMachineScaleSet, error) {
	client := compute.NewVirtualMachineScaleSetsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list compute.VirtualMachineScaleSet from Azure APIs")
	}
	resources := make([]compute.VirtualMachineScaleSet, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListVirtualMachineExtensions(ctx context.Context, VMName string, expand string) ([]compute.VirtualMachineExtension, error) {
	client := compute.NewVirtualMachineExtensionsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName(), VMName, expand)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list compute.VirtualMachineExtension from Azure APIs")
	}
	return *output.Value, nil
}
func (ar *AzureReader) ListAvailabilitySets(ctx context.Context) ([]compute.AvailabilitySet, error) {
	client := compute.NewAvailabilitySetsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list compute.AvailabilitySet from Azure APIs")
	}
	resources := make([]compute.AvailabilitySet, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListImages(ctx context.Context) ([]compute.Image, error) {
	client := compute.NewImagesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list compute.Image from Azure APIs")
	}
	resources := make([]compute.Image, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListVirtualNetworks(ctx context.Context) ([]network.VirtualNetwork, error) {
	client := network.NewVirtualNetworksClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.VirtualNetwork from Azure APIs")
	}
	resources := make([]network.VirtualNetwork, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListSubnets(ctx context.Context, virtualNetworkName string) ([]network.Subnet, error) {
	client := network.NewSubnetsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName(), virtualNetworkName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.Subnet from Azure APIs")
	}
	resources := make([]network.Subnet, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListInterfaces(ctx context.Context) ([]network.Interface, error) {
	client := network.NewInterfacesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.Interface from Azure APIs")
	}
	resources := make([]network.Interface, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListSecurityGroups(ctx context.Context) ([]network.SecurityGroup, error) {
	client := network.NewSecurityGroupsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.SecurityGroup from Azure APIs")
	}
	resources := make([]network.SecurityGroup, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListApplicationGateways(ctx context.Context) ([]network.ApplicationGateway, error) {
	client := network.NewApplicationGatewaysClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.ApplicationGateway from Azure APIs")
	}
	resources := make([]network.ApplicationGateway, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListApplicationSecurityGroups(ctx context.Context) ([]network.ApplicationSecurityGroup, error) {
	client := network.NewApplicationSecurityGroupsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.ApplicationSecurityGroup from Azure APIs")
	}
	resources := make([]network.ApplicationSecurityGroup, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListDdosProtectionPlans(ctx context.Context) ([]network.DdosProtectionPlan, error) {
	client := network.NewDdosProtectionPlansClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.DdosProtectionPlan from Azure APIs")
	}
	resources := make([]network.DdosProtectionPlan, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListAzureFirewalls(ctx context.Context) ([]network.AzureFirewall, error) {
	client := network.NewAzureFirewallsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.AzureFirewall from Azure APIs")
	}
	resources := make([]network.AzureFirewall, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListLocalNetworkGateways(ctx context.Context) ([]network.LocalNetworkGateway, error) {
	client := network.NewLocalNetworkGatewaysClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.LocalNetworkGateway from Azure APIs")
	}
	resources := make([]network.LocalNetworkGateway, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListNatGateways(ctx context.Context) ([]network.NatGateway, error) {
	client := network.NewNatGatewaysClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.NatGateway from Azure APIs")
	}
	resources := make([]network.NatGateway, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListProfiles(ctx context.Context) ([]network.Profile, error) {
	client := network.NewProfilesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.Profile from Azure APIs")
	}
	resources := make([]network.Profile, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListSecurityRules(ctx context.Context, networkSecurityGroupName string) ([]network.SecurityRule, error) {
	client := network.NewSecurityRulesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName(), networkSecurityGroupName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.SecurityRule from Azure APIs")
	}
	resources := make([]network.SecurityRule, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListPublicIPAddresses(ctx context.Context) ([]network.PublicIPAddress, error) {
	client := network.NewPublicIPAddressesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.PublicIPAddress from Azure APIs")
	}
	resources := make([]network.PublicIPAddress, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListPublicIPPrefixes(ctx context.Context) ([]network.PublicIPPrefix, error) {
	client := network.NewPublicIPPrefixesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.PublicIPPrefix from Azure APIs")
	}
	resources := make([]network.PublicIPPrefix, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListRoutes(ctx context.Context, routeTableName string) ([]network.Route, error) {
	client := network.NewRoutesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName(), routeTableName)
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.Route from Azure APIs")
	}
	resources := make([]network.Route, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListRouteTables(ctx context.Context) ([]network.RouteTable, error) {
	client := network.NewRouteTablesClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.RouteTable from Azure APIs")
	}
	resources := make([]network.RouteTable, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListVirtualNetworkGateways(ctx context.Context) ([]network.VirtualNetworkGateway, error) {
	client := network.NewVirtualNetworkGatewaysClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.VirtualNetworkGateway from Azure APIs")
	}
	resources := make([]network.VirtualNetworkGateway, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}
func (ar *AzureReader) ListVirtualNetworkGatewayConnections(ctx context.Context) ([]network.VirtualNetworkGatewayConnection, error) {
	client := network.NewVirtualNetworkGatewayConnectionsClient(ar.config.SubscriptionID)
	client.Authorizer = ar.authorizer
	output, err := client.List(ctx, ar.GetResourceGroupName())
	if err != nil {
		return nil, errors.Wrap(err, "unable to list network.VirtualNetworkGatewayConnection from Azure APIs")
	}
	resources := make([]network.VirtualNetworkGatewayConnection, 0)
	for output.NotDone() {
		for _, res := range output.Values() {
			resources = append(resources, res)
		}
		if err := output.NextWithContext(ctx); err != nil {
			break
		}
	}
	return resources, nil
}