azure.blueprint.Assignment

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const current = azure.core.getClientConfig({});
const example = azure.core.getSubscription({});
const exampleGetDefinition = example.then(example => azure.blueprint.getDefinition({
    name: "exampleBlueprint",
    scopeId: example.id,
}));
const exampleGetPublishedVersion = Promise.all([exampleGetDefinition, exampleGetDefinition]).then(([exampleGetDefinition, exampleGetDefinition1]) => azure.blueprint.getPublishedVersion({
    scopeId: exampleGetDefinition.scopeId,
    blueprintName: exampleGetDefinition1.name,
    version: "v1.0.0",
}));
const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "exampleRG-bp",
    location: "West Europe",
    tags: {
        Environment: "example",
    },
});
const exampleUserAssignedIdentity = new azure.authorization.UserAssignedIdentity("example", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    name: "bp-user-example",
});
const operator = new azure.authorization.Assignment("operator", {
    scope: example.then(example => example.id),
    roleDefinitionName: "Blueprint Operator",
    principalId: exampleUserAssignedIdentity.principalId,
});
const owner = new azure.authorization.Assignment("owner", {
    scope: example.then(example => example.id),
    roleDefinitionName: "Owner",
    principalId: exampleUserAssignedIdentity.principalId,
});
const exampleAssignment = new azure.blueprint.Assignment("example", {
    name: "testAccBPAssignment",
    targetSubscriptionId: example.then(example => example.id),
    versionId: exampleGetPublishedVersion.then(exampleGetPublishedVersion => exampleGetPublishedVersion.id),
    location: exampleResourceGroup.location,
    lockMode: "AllResourcesDoNotDelete",
    lockExcludePrincipals: [current.then(current => current.objectId)],
    identity: {
        type: "UserAssigned",
        identityIds: [exampleUserAssignedIdentity.id],
    },
    resourceGroups: `    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
`,
    parameterValues: `    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
`,
}, {
    dependsOn: [
        operator,
        owner,
    ],
});

import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example = azure.core.get_subscription()
example_get_definition = azure.blueprint.get_definition(name="exampleBlueprint",
    scope_id=example.id)
example_get_published_version = azure.blueprint.get_published_version(scope_id=example_get_definition.scope_id,
    blueprint_name=example_get_definition.name,
    version="v1.0.0")
example_resource_group = azure.core.ResourceGroup("example",
    name="exampleRG-bp",
    location="West Europe",
    tags={
        "Environment": "example",
    })
example_user_assigned_identity = azure.authorization.UserAssignedIdentity("example",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    name="bp-user-example")
operator = azure.authorization.Assignment("operator",
    scope=example.id,
    role_definition_name="Blueprint Operator",
    principal_id=example_user_assigned_identity.principal_id)
owner = azure.authorization.Assignment("owner",
    scope=example.id,
    role_definition_name="Owner",
    principal_id=example_user_assigned_identity.principal_id)
example_assignment = azure.blueprint.Assignment("example",
    name="testAccBPAssignment",
    target_subscription_id=example.id,
    version_id=example_get_published_version.id,
    location=example_resource_group.location,
    lock_mode="AllResourcesDoNotDelete",
    lock_exclude_principals=[current.object_id],
    identity={
        "type": "UserAssigned",
        "identity_ids": [example_user_assigned_identity.id],
    },
    resource_groups="""    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
""",
    parameter_values="""    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
""",
    opts = pulumi.ResourceOptions(depends_on=[
            operator,
            owner,
        ]))

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/blueprint"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := core.GetClientConfig(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		example, err := core.LookupSubscription(ctx, &core.LookupSubscriptionArgs{}, nil)
		if err != nil {
			return err
		}
		exampleGetDefinition, err := blueprint.GetDefinition(ctx, &blueprint.GetDefinitionArgs{
			Name:    "exampleBlueprint",
			ScopeId: example.Id,
		}, nil)
		if err != nil {
			return err
		}
		exampleGetPublishedVersion, err := blueprint.GetPublishedVersion(ctx, &blueprint.GetPublishedVersionArgs{
			ScopeId:       exampleGetDefinition.ScopeId,
			BlueprintName: exampleGetDefinition.Name,
			Version:       "v1.0.0",
		}, nil)
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("exampleRG-bp"),
			Location: pulumi.String("West Europe"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		exampleUserAssignedIdentity, err := authorization.NewUserAssignedIdentity(ctx, "example", &authorization.UserAssignedIdentityArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			Name:              pulumi.String("bp-user-example"),
		})
		if err != nil {
			return err
		}
		operator, err := authorization.NewAssignment(ctx, "operator", &authorization.AssignmentArgs{
			Scope:              pulumi.String(example.Id),
			RoleDefinitionName: pulumi.String("Blueprint Operator"),
			PrincipalId:        exampleUserAssignedIdentity.PrincipalId,
		})
		if err != nil {
			return err
		}
		owner, err := authorization.NewAssignment(ctx, "owner", &authorization.AssignmentArgs{
			Scope:              pulumi.String(example.Id),
			RoleDefinitionName: pulumi.String("Owner"),
			PrincipalId:        exampleUserAssignedIdentity.PrincipalId,
		})
		if err != nil {
			return err
		}
		_, err = blueprint.NewAssignment(ctx, "example", &blueprint.AssignmentArgs{
			Name:                 pulumi.String("testAccBPAssignment"),
			TargetSubscriptionId: pulumi.String(example.Id),
			VersionId:            pulumi.String(exampleGetPublishedVersion.Id),
			Location:             exampleResourceGroup.Location,
			LockMode:             pulumi.String("AllResourcesDoNotDelete"),
			LockExcludePrincipals: pulumi.StringArray{
				pulumi.String(current.ObjectId),
			},
			Identity: &blueprint.AssignmentIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					exampleUserAssignedIdentity.ID(),
				},
			},
			ResourceGroups: pulumi.String(`    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
`),
			ParameterValues: pulumi.String(`    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
`),
		}, pulumi.DependsOn([]pulumi.Resource{
			operator,
			owner,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var current = Azure.Core.GetClientConfig.Invoke();

    var example = Azure.Core.GetSubscription.Invoke();

    var exampleGetDefinition = Azure.Blueprint.GetDefinition.Invoke(new()
    {
        Name = "exampleBlueprint",
        ScopeId = example.Apply(getSubscriptionResult => getSubscriptionResult.Id),
    });

    var exampleGetPublishedVersion = Azure.Blueprint.GetPublishedVersion.Invoke(new()
    {
        ScopeId = exampleGetDefinition.Apply(getDefinitionResult => getDefinitionResult.ScopeId),
        BlueprintName = exampleGetDefinition.Apply(getDefinitionResult => getDefinitionResult.Name),
        Version = "v1.0.0",
    });

    var exampleResourceGroup = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "exampleRG-bp",
        Location = "West Europe",
        Tags = 
        {
            { "Environment", "example" },
        },
    });

    var exampleUserAssignedIdentity = new Azure.Authorization.UserAssignedIdentity("example", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        Name = "bp-user-example",
    });

    var @operator = new Azure.Authorization.Assignment("operator", new()
    {
        Scope = example.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        RoleDefinitionName = "Blueprint Operator",
        PrincipalId = exampleUserAssignedIdentity.PrincipalId,
    });

    var owner = new Azure.Authorization.Assignment("owner", new()
    {
        Scope = example.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        RoleDefinitionName = "Owner",
        PrincipalId = exampleUserAssignedIdentity.PrincipalId,
    });

    var exampleAssignment = new Azure.Blueprint.Assignment("example", new()
    {
        Name = "testAccBPAssignment",
        TargetSubscriptionId = example.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        VersionId = exampleGetPublishedVersion.Apply(getPublishedVersionResult => getPublishedVersionResult.Id),
        Location = exampleResourceGroup.Location,
        LockMode = "AllResourcesDoNotDelete",
        LockExcludePrincipals = new[]
        {
            current.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
        },
        Identity = new Azure.Blueprint.Inputs.AssignmentIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                exampleUserAssignedIdentity.Id,
            },
        },
        ResourceGroups = @"    {
      ""ResourceGroup"": {
        ""name"": ""exampleRG-bp""
      }
    }
",
        ParameterValues = @"    {
      ""allowedlocationsforresourcegroups_listOfAllowedLocations"": {
        ""value"": [""westus"", ""westus2"", ""eastus"", ""centralus"", ""centraluseuap"", ""southcentralus"", ""northcentralus"", ""westcentralus"", ""eastus2"", ""eastus2euap"", ""brazilsouth"", ""brazilus"", ""northeurope"", ""westeurope"", ""eastasia"", ""southeastasia"", ""japanwest"", ""japaneast"", ""koreacentral"", ""koreasouth"", ""indiasouth"", ""indiawest"", ""indiacentral"", ""australiaeast"", ""australiasoutheast"", ""canadacentral"", ""canadaeast"", ""uknorth"", ""uksouth2"", ""uksouth"", ""ukwest"", ""francecentral"", ""francesouth"", ""australiacentral"", ""australiacentral2"", ""uaecentral"", ""uaenorth"", ""southafricanorth"", ""southafricawest"", ""switzerlandnorth"", ""switzerlandwest"", ""germanynorth"", ""germanywestcentral"", ""norwayeast"", ""norwaywest""]
      }
    }
",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            @operator,
            owner,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.inputs.GetSubscriptionArgs;
import com.pulumi.azure.blueprint.BlueprintFunctions;
import com.pulumi.azure.blueprint.inputs.GetDefinitionArgs;
import com.pulumi.azure.blueprint.inputs.GetPublishedVersionArgs;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.blueprint.inputs.AssignmentIdentityArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var current = CoreFunctions.getClientConfig(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        final var example = CoreFunctions.getSubscription(GetSubscriptionArgs.builder()
            .build());

        final var exampleGetDefinition = BlueprintFunctions.getDefinition(GetDefinitionArgs.builder()
            .name("exampleBlueprint")
            .scopeId(example.id())
            .build());

        final var exampleGetPublishedVersion = BlueprintFunctions.getPublishedVersion(GetPublishedVersionArgs.builder()
            .scopeId(exampleGetDefinition.scopeId())
            .blueprintName(exampleGetDefinition.name())
            .version("v1.0.0")
            .build());

        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()
            .name("exampleRG-bp")
            .location("West Europe")
            .tags(Map.of("Environment", "example"))
            .build());

        var exampleUserAssignedIdentity = new UserAssignedIdentity("exampleUserAssignedIdentity", UserAssignedIdentityArgs.builder()
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .name("bp-user-example")
            .build());

        var operator = new com.pulumi.azure.authorization.Assignment("operator", com.pulumi.azure.authorization.AssignmentArgs.builder()
            .scope(example.id())
            .roleDefinitionName("Blueprint Operator")
            .principalId(exampleUserAssignedIdentity.principalId())
            .build());

        var owner = new com.pulumi.azure.authorization.Assignment("owner", com.pulumi.azure.authorization.AssignmentArgs.builder()
            .scope(example.id())
            .roleDefinitionName("Owner")
            .principalId(exampleUserAssignedIdentity.principalId())
            .build());

        var exampleAssignment = new com.pulumi.azure.blueprint.Assignment("exampleAssignment", com.pulumi.azure.blueprint.AssignmentArgs.builder()
            .name("testAccBPAssignment")
            .targetSubscriptionId(example.id())
            .versionId(exampleGetPublishedVersion.id())
            .location(exampleResourceGroup.location())
            .lockMode("AllResourcesDoNotDelete")
            .lockExcludePrincipals(current.objectId())
            .identity(AssignmentIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(exampleUserAssignedIdentity.id())
                .build())
            .resourceGroups("""
    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
            """)
            .parameterValues("""
    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
            """)
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    operator,
                    owner)
                .build());

    }
}

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    name: example
    properties:
      name: exampleRG-bp
      location: West Europe
      tags:
        Environment: example
  exampleUserAssignedIdentity:
    type: azure:authorization:UserAssignedIdentity
    name: example
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      name: bp-user-example
  operator:
    type: azure:authorization:Assignment
    properties:
      scope: ${example.id}
      roleDefinitionName: Blueprint Operator
      principalId: ${exampleUserAssignedIdentity.principalId}
  owner:
    type: azure:authorization:Assignment
    properties:
      scope: ${example.id}
      roleDefinitionName: Owner
      principalId: ${exampleUserAssignedIdentity.principalId}
  exampleAssignment:
    type: azure:blueprint:Assignment
    name: example
    properties:
      name: testAccBPAssignment
      targetSubscriptionId: ${example.id}
      versionId: ${exampleGetPublishedVersion.id}
      location: ${exampleResourceGroup.location}
      lockMode: AllResourcesDoNotDelete
      lockExcludePrincipals:
        - ${current.objectId}
      identity:
        type: UserAssigned
        identityIds:
          - ${exampleUserAssignedIdentity.id}
      resourceGroups: |2
            {
              "ResourceGroup": {
                "name": "exampleRG-bp"
              }
            }
      parameterValues: |2
            {
              "allowedlocationsforresourcegroups_listOfAllowedLocations": {
                "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
              }
            }
    options:
      dependsOn:
        - ${operator}
        - ${owner}
variables:
  current:
    fn::invoke:
      function: azure:core:getClientConfig
      arguments: {}
  example:
    fn::invoke:
      function: azure:core:getSubscription
      arguments: {}
  exampleGetDefinition:
    fn::invoke:
      function: azure:blueprint:getDefinition
      arguments:
        name: exampleBlueprint
        scopeId: ${example.id}
  exampleGetPublishedVersion:
    fn::invoke:
      function: azure:blueprint:getPublishedVersion
      arguments:
        scopeId: ${exampleGetDefinition.scopeId}
        blueprintName: ${exampleGetDefinition.name}
        version: v1.0.0

var azureAssignmentResource = new Azure.Blueprint.Assignment("azureAssignmentResource", new()
{
    Identity = new Azure.Blueprint.Inputs.AssignmentIdentityArgs
    {
        Type = "string",
        IdentityIds = new[]
        {
            "string",
        },
        PrincipalId = "string",
        TenantId = "string",
    },
    TargetSubscriptionId = "string",
    VersionId = "string",
    Location = "string",
    LockExcludeActions = new[]
    {
        "string",
    },
    LockExcludePrincipals = new[]
    {
        "string",
    },
    LockMode = "string",
    Name = "string",
    ParameterValues = "string",
    ResourceGroups = "string",
});

example, err := blueprint.NewAssignment(ctx, "azureAssignmentResource", &blueprint.AssignmentArgs{
	Identity: &blueprint.AssignmentIdentityArgs{
		Type: pulumi.String("string"),
		IdentityIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		PrincipalId: pulumi.String("string"),
		TenantId:    pulumi.String("string"),
	},
	TargetSubscriptionId: pulumi.String("string"),
	VersionId:            pulumi.String("string"),
	Location:             pulumi.String("string"),
	LockExcludeActions: pulumi.StringArray{
		pulumi.String("string"),
	},
	LockExcludePrincipals: pulumi.StringArray{
		pulumi.String("string"),
	},
	LockMode:        pulumi.String("string"),
	Name:            pulumi.String("string"),
	ParameterValues: pulumi.String("string"),
	ResourceGroups:  pulumi.String("string"),
})

var azureAssignmentResource = new com.pulumi.azure.blueprint.Assignment("azureAssignmentResource", com.pulumi.azure.blueprint.AssignmentArgs.builder()
    .identity(AssignmentIdentityArgs.builder()
        .type("string")
        .identityIds("string")
        .principalId("string")
        .tenantId("string")
        .build())
    .targetSubscriptionId("string")
    .versionId("string")
    .location("string")
    .lockExcludeActions("string")
    .lockExcludePrincipals("string")
    .lockMode("string")
    .name("string")
    .parameterValues("string")
    .resourceGroups("string")
    .build());

azure_assignment_resource = azure.blueprint.Assignment("azureAssignmentResource",
    identity={
        "type": "string",
        "identity_ids": ["string"],
        "principal_id": "string",
        "tenant_id": "string",
    },
    target_subscription_id="string",
    version_id="string",
    location="string",
    lock_exclude_actions=["string"],
    lock_exclude_principals=["string"],
    lock_mode="string",
    name="string",
    parameter_values="string",
    resource_groups="string")

const azureAssignmentResource = new azure.blueprint.Assignment("azureAssignmentResource", {
    identity: {
        type: "string",
        identityIds: ["string"],
        principalId: "string",
        tenantId: "string",
    },
    targetSubscriptionId: "string",
    versionId: "string",
    location: "string",
    lockExcludeActions: ["string"],
    lockExcludePrincipals: ["string"],
    lockMode: "string",
    name: "string",
    parameterValues: "string",
    resourceGroups: "string",
});

type: azure:blueprint:Assignment
properties:
    identity:
        identityIds:
            - string
        principalId: string
        tenantId: string
        type: string
    location: string
    lockExcludeActions:
        - string
    lockExcludePrincipals:
        - string
    lockMode: string
    name: string
    parameterValues: string
    resourceGroups: string
    targetSubscriptionId: string
    versionId: string