confluentcloud.RoleBinding

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
import * as std from "@pulumi/std";

const org_example_rb = new confluentcloud.RoleBinding("org-example-rb", {
    principal: `User:${test.id}`,
    roleName: "MetricsViewer",
    crnPattern: demo.resourceName,
});
const environment_example_rb = new confluentcloud.RoleBinding("environment-example-rb", {
    principal: `User:${test.id}`,
    roleName: "EnvironmentAdmin",
    crnPattern: stag.resourceName,
});
const environment_example_rb_skip_sync = new confluentcloud.RoleBinding("environment-example-rb-skip-sync", {
    principal: `User:${test.id}`,
    roleName: "EnvironmentAdmin",
    crnPattern: stag.resourceName,
    disableWaitForReady: true,
});
const environment_example_rb_2 = new confluentcloud.RoleBinding("environment-example-rb-2", {
    principal: `User:${testConfluentIdentityPool.id}`,
    roleName: "EnvironmentAdmin",
    crnPattern: stag.resourceName,
});
const data_discovery_example_rb = new confluentcloud.RoleBinding("data-discovery-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DataDiscovery",
    crnPattern: stag.resourceName,
});
const network_example_rb = new confluentcloud.RoleBinding("network-example-rb", {
    principal: `User:${test.id}`,
    roleName: "NetworkAdmin",
    crnPattern: demo.resourceName,
});
const cluster_example_rb = new confluentcloud.RoleBinding("cluster-example-rb", {
    principal: `User:${test.id}`,
    roleName: "CloudClusterAdmin",
    crnPattern: basic.rbacCrn,
});
const topic_example_rb = new confluentcloud.RoleBinding("topic-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperWrite",
    crnPattern: `${standard.rbacCrn}/kafka=${standard.id}/topic=${orders.topicName}`,
});
const topic_example_rb_2 = new confluentcloud.RoleBinding("topic-example-rb-2", {
    principal: `User:${testConfluentIdentityPool.id}`,
    roleName: "DeveloperWrite",
    crnPattern: `${standard.rbacCrn}/kafka=${standard.id}/topic=${orders.topicName}`,
});
const group_example_rb = new confluentcloud.RoleBinding("group-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${basic.rbacCrn}/kafka=${standard.id}/group=confluent_cli_consumer_*`,
});
const group_mapping_example_rb = new confluentcloud.RoleBinding("group-mapping-example-rb", {
    principal: `User:${application_developers.id}`,
    roleName: "EnvironmentAdmin",
    crnPattern: stag.resourceName,
});
const transaction_example_rb = new confluentcloud.RoleBinding("transaction-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${basic.rbacCrn}/kafka=${standard.id}/transactional-id=my_transaction`,
});
const connectorName = std.index.lookup({
    map: testConfluentConnector.configNonsensitive,
    key: "name",
    "default": "\"name\" attribute is missing",
}).result;
const connector_example_rb = new confluentcloud.RoleBinding("connector-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${standard.rbacCrn}/connector=${connectorName}`,
});
const all_subjects_example_rb = new confluentcloud.RoleBinding("all-subjects-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${example.resourceName}/subject=*`,
});
const subject_foo_example_rb = new confluentcloud.RoleBinding("subject-foo-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${example.resourceName}/subject=foo`,
});
const subject_with_abc_prefix_example_rb = new confluentcloud.RoleBinding("subject-with-abc-prefix-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${example.resourceName}/subject=abc*`,
});
const kek_example_rb = new confluentcloud.RoleBinding("kek-example-rb", {
    principal: `User:${test.id}`,
    roleName: "DeveloperRead",
    crnPattern: `${example.resourceName}/kek=kek-name`,
});

import pulumi
import pulumi_confluentcloud as confluentcloud
import pulumi_std as std

org_example_rb = confluentcloud.RoleBinding("org-example-rb",
    principal=f"User:{test['id']}",
    role_name="MetricsViewer",
    crn_pattern=demo["resourceName"])
environment_example_rb = confluentcloud.RoleBinding("environment-example-rb",
    principal=f"User:{test['id']}",
    role_name="EnvironmentAdmin",
    crn_pattern=stag["resourceName"])
environment_example_rb_skip_sync = confluentcloud.RoleBinding("environment-example-rb-skip-sync",
    principal=f"User:{test['id']}",
    role_name="EnvironmentAdmin",
    crn_pattern=stag["resourceName"],
    disable_wait_for_ready=True)
environment_example_rb_2 = confluentcloud.RoleBinding("environment-example-rb-2",
    principal=f"User:{test_confluent_identity_pool['id']}",
    role_name="EnvironmentAdmin",
    crn_pattern=stag["resourceName"])
data_discovery_example_rb = confluentcloud.RoleBinding("data-discovery-example-rb",
    principal=f"User:{test['id']}",
    role_name="DataDiscovery",
    crn_pattern=stag["resourceName"])
network_example_rb = confluentcloud.RoleBinding("network-example-rb",
    principal=f"User:{test['id']}",
    role_name="NetworkAdmin",
    crn_pattern=demo["resourceName"])
cluster_example_rb = confluentcloud.RoleBinding("cluster-example-rb",
    principal=f"User:{test['id']}",
    role_name="CloudClusterAdmin",
    crn_pattern=basic["rbacCrn"])
topic_example_rb = confluentcloud.RoleBinding("topic-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperWrite",
    crn_pattern=f"{standard['rbacCrn']}/kafka={standard['id']}/topic={orders['topicName']}")
topic_example_rb_2 = confluentcloud.RoleBinding("topic-example-rb-2",
    principal=f"User:{test_confluent_identity_pool['id']}",
    role_name="DeveloperWrite",
    crn_pattern=f"{standard['rbacCrn']}/kafka={standard['id']}/topic={orders['topicName']}")
group_example_rb = confluentcloud.RoleBinding("group-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{basic['rbacCrn']}/kafka={standard['id']}/group=confluent_cli_consumer_*")
group_mapping_example_rb = confluentcloud.RoleBinding("group-mapping-example-rb",
    principal=f"User:{application_developers['id']}",
    role_name="EnvironmentAdmin",
    crn_pattern=stag["resourceName"])
transaction_example_rb = confluentcloud.RoleBinding("transaction-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{basic['rbacCrn']}/kafka={standard['id']}/transactional-id=my_transaction")
connector_name = std.index.lookup(map=test_confluent_connector["configNonsensitive"],
    key="name",
    default="\"name\" attribute is missing")["result"]
connector_example_rb = confluentcloud.RoleBinding("connector-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{standard['rbacCrn']}/connector={connector_name}")
all_subjects_example_rb = confluentcloud.RoleBinding("all-subjects-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{example['resourceName']}/subject=*")
subject_foo_example_rb = confluentcloud.RoleBinding("subject-foo-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{example['resourceName']}/subject=foo")
subject_with_abc_prefix_example_rb = confluentcloud.RoleBinding("subject-with-abc-prefix-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{example['resourceName']}/subject=abc*")
kek_example_rb = confluentcloud.RoleBinding("kek-example-rb",
    principal=f"User:{test['id']}",
    role_name="DeveloperRead",
    crn_pattern=f"{example['resourceName']}/kek=kek-name")

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := confluentcloud.NewRoleBinding(ctx, "org-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("MetricsViewer"),
			CrnPattern: pulumi.Any(demo.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "environment-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("EnvironmentAdmin"),
			CrnPattern: pulumi.Any(stag.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "environment-example-rb-skip-sync", &confluentcloud.RoleBindingArgs{
			Principal:           pulumi.Sprintf("User:%v", test.Id),
			RoleName:            pulumi.String("EnvironmentAdmin"),
			CrnPattern:          pulumi.Any(stag.ResourceName),
			DisableWaitForReady: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "environment-example-rb-2", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", testConfluentIdentityPool.Id),
			RoleName:   pulumi.String("EnvironmentAdmin"),
			CrnPattern: pulumi.Any(stag.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "data-discovery-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DataDiscovery"),
			CrnPattern: pulumi.Any(stag.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "network-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("NetworkAdmin"),
			CrnPattern: pulumi.Any(demo.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "cluster-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("CloudClusterAdmin"),
			CrnPattern: pulumi.Any(basic.RbacCrn),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "topic-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperWrite"),
			CrnPattern: pulumi.Sprintf("%v/kafka=%v/topic=%v", standard.RbacCrn, standard.Id, orders.TopicName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "topic-example-rb-2", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", testConfluentIdentityPool.Id),
			RoleName:   pulumi.String("DeveloperWrite"),
			CrnPattern: pulumi.Sprintf("%v/kafka=%v/topic=%v", standard.RbacCrn, standard.Id, orders.TopicName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "group-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/kafka=%v/group=confluent_cli_consumer_*", basic.RbacCrn, standard.Id),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "group-mapping-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", application_developers.Id),
			RoleName:   pulumi.String("EnvironmentAdmin"),
			CrnPattern: pulumi.Any(stag.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "transaction-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/kafka=%v/transactional-id=my_transaction", basic.RbacCrn, standard.Id),
		})
		if err != nil {
			return err
		}
		connectorName := std.Lookup(ctx, map[string]interface{}{
			"map":     testConfluentConnector.ConfigNonsensitive,
			"key":     "name",
			"default": "\"name\" attribute is missing",
		}, nil).Result
		_, err = confluentcloud.NewRoleBinding(ctx, "connector-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/connector=%v", standard.RbacCrn, connectorName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "all-subjects-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/subject=*", example.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "subject-foo-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/subject=foo", example.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "subject-with-abc-prefix-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/subject=abc*", example.ResourceName),
		})
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewRoleBinding(ctx, "kek-example-rb", &confluentcloud.RoleBindingArgs{
			Principal:  pulumi.Sprintf("User:%v", test.Id),
			RoleName:   pulumi.String("DeveloperRead"),
			CrnPattern: pulumi.Sprintf("%v/kek=kek-name", example.ResourceName),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var org_example_rb = new ConfluentCloud.RoleBinding("org-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "MetricsViewer",
        CrnPattern = demo.ResourceName,
    });

    var environment_example_rb = new ConfluentCloud.RoleBinding("environment-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "EnvironmentAdmin",
        CrnPattern = stag.ResourceName,
    });

    var environment_example_rb_skip_sync = new ConfluentCloud.RoleBinding("environment-example-rb-skip-sync", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "EnvironmentAdmin",
        CrnPattern = stag.ResourceName,
        DisableWaitForReady = true,
    });

    var environment_example_rb_2 = new ConfluentCloud.RoleBinding("environment-example-rb-2", new()
    {
        Principal = $"User:{testConfluentIdentityPool.Id}",
        RoleName = "EnvironmentAdmin",
        CrnPattern = stag.ResourceName,
    });

    var data_discovery_example_rb = new ConfluentCloud.RoleBinding("data-discovery-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DataDiscovery",
        CrnPattern = stag.ResourceName,
    });

    var network_example_rb = new ConfluentCloud.RoleBinding("network-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "NetworkAdmin",
        CrnPattern = demo.ResourceName,
    });

    var cluster_example_rb = new ConfluentCloud.RoleBinding("cluster-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "CloudClusterAdmin",
        CrnPattern = basic.RbacCrn,
    });

    var topic_example_rb = new ConfluentCloud.RoleBinding("topic-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperWrite",
        CrnPattern = $"{standard.RbacCrn}/kafka={standard.Id}/topic={orders.TopicName}",
    });

    var topic_example_rb_2 = new ConfluentCloud.RoleBinding("topic-example-rb-2", new()
    {
        Principal = $"User:{testConfluentIdentityPool.Id}",
        RoleName = "DeveloperWrite",
        CrnPattern = $"{standard.RbacCrn}/kafka={standard.Id}/topic={orders.TopicName}",
    });

    var group_example_rb = new ConfluentCloud.RoleBinding("group-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{basic.RbacCrn}/kafka={standard.Id}/group=confluent_cli_consumer_*",
    });

    var group_mapping_example_rb = new ConfluentCloud.RoleBinding("group-mapping-example-rb", new()
    {
        Principal = $"User:{application_developers.Id}",
        RoleName = "EnvironmentAdmin",
        CrnPattern = stag.ResourceName,
    });

    var transaction_example_rb = new ConfluentCloud.RoleBinding("transaction-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{basic.RbacCrn}/kafka={standard.Id}/transactional-id=my_transaction",
    });

    var connectorName = Std.Index.Lookup.Invoke(new()
    {
        Map = testConfluentConnector.ConfigNonsensitive,
        Key = "name",
        Default = "\"name\" attribute is missing",
    }).Result;

    var connector_example_rb = new ConfluentCloud.RoleBinding("connector-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{standard.RbacCrn}/connector={connectorName}",
    });

    var all_subjects_example_rb = new ConfluentCloud.RoleBinding("all-subjects-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{example.ResourceName}/subject=*",
    });

    var subject_foo_example_rb = new ConfluentCloud.RoleBinding("subject-foo-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{example.ResourceName}/subject=foo",
    });

    var subject_with_abc_prefix_example_rb = new ConfluentCloud.RoleBinding("subject-with-abc-prefix-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{example.ResourceName}/subject=abc*",
    });

    var kek_example_rb = new ConfluentCloud.RoleBinding("kek-example-rb", new()
    {
        Principal = $"User:{test.Id}",
        RoleName = "DeveloperRead",
        CrnPattern = $"{example.ResourceName}/kek=kek-name",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import com.pulumi.std.StdFunctions;
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) {
        var org_example_rb = new RoleBinding("org-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("MetricsViewer")
            .crnPattern(demo.resourceName())
            .build());

        var environment_example_rb = new RoleBinding("environment-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("EnvironmentAdmin")
            .crnPattern(stag.resourceName())
            .build());

        var environment_example_rb_skip_sync = new RoleBinding("environment-example-rb-skip-sync", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("EnvironmentAdmin")
            .crnPattern(stag.resourceName())
            .disableWaitForReady(true)
            .build());

        var environment_example_rb_2 = new RoleBinding("environment-example-rb-2", RoleBindingArgs.builder()
            .principal(String.format("User:%s", testConfluentIdentityPool.id()))
            .roleName("EnvironmentAdmin")
            .crnPattern(stag.resourceName())
            .build());

        var data_discovery_example_rb = new RoleBinding("data-discovery-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DataDiscovery")
            .crnPattern(stag.resourceName())
            .build());

        var network_example_rb = new RoleBinding("network-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("NetworkAdmin")
            .crnPattern(demo.resourceName())
            .build());

        var cluster_example_rb = new RoleBinding("cluster-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("CloudClusterAdmin")
            .crnPattern(basic.rbacCrn())
            .build());

        var topic_example_rb = new RoleBinding("topic-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperWrite")
            .crnPattern(String.format("%s/kafka=%s/topic=%s", standard.rbacCrn(),standard.id(),orders.topicName()))
            .build());

        var topic_example_rb_2 = new RoleBinding("topic-example-rb-2", RoleBindingArgs.builder()
            .principal(String.format("User:%s", testConfluentIdentityPool.id()))
            .roleName("DeveloperWrite")
            .crnPattern(String.format("%s/kafka=%s/topic=%s", standard.rbacCrn(),standard.id(),orders.topicName()))
            .build());

        var group_example_rb = new RoleBinding("group-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/kafka=%s/group=confluent_cli_consumer_*", basic.rbacCrn(),standard.id()))
            .build());

        var group_mapping_example_rb = new RoleBinding("group-mapping-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", application_developers.id()))
            .roleName("EnvironmentAdmin")
            .crnPattern(stag.resourceName())
            .build());

        var transaction_example_rb = new RoleBinding("transaction-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/kafka=%s/transactional-id=my_transaction", basic.rbacCrn(),standard.id()))
            .build());

        final var connectorName = StdFunctions.lookup(Map.ofEntries(
            Map.entry("map", testConfluentConnector.configNonsensitive()),
            Map.entry("key", "name"),
            Map.entry("default", "\"name\" attribute is missing")
        )).result();

        var connector_example_rb = new RoleBinding("connector-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/connector=%s", standard.rbacCrn(),connectorName))
            .build());

        var all_subjects_example_rb = new RoleBinding("all-subjects-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/subject=*", example.resourceName()))
            .build());

        var subject_foo_example_rb = new RoleBinding("subject-foo-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/subject=foo", example.resourceName()))
            .build());

        var subject_with_abc_prefix_example_rb = new RoleBinding("subject-with-abc-prefix-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/subject=abc*", example.resourceName()))
            .build());

        var kek_example_rb = new RoleBinding("kek-example-rb", RoleBindingArgs.builder()
            .principal(String.format("User:%s", test.id()))
            .roleName("DeveloperRead")
            .crnPattern(String.format("%s/kek=kek-name", example.resourceName()))
            .build());

    }
}

resources:
  org-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: MetricsViewer
      crnPattern: ${demo.resourceName}
  environment-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: EnvironmentAdmin
      crnPattern: ${stag.resourceName}
  environment-example-rb-skip-sync:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: EnvironmentAdmin
      crnPattern: ${stag.resourceName}
      disableWaitForReady: true
  environment-example-rb-2:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${testConfluentIdentityPool.id}
      roleName: EnvironmentAdmin
      crnPattern: ${stag.resourceName}
  data-discovery-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DataDiscovery
      crnPattern: ${stag.resourceName}
  network-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: NetworkAdmin
      crnPattern: ${demo.resourceName}
  cluster-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: CloudClusterAdmin
      crnPattern: ${basic.rbacCrn}
  topic-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperWrite
      crnPattern: ${standard.rbacCrn}/kafka=${standard.id}/topic=${orders.topicName}
  topic-example-rb-2:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${testConfluentIdentityPool.id}
      roleName: DeveloperWrite
      crnPattern: ${standard.rbacCrn}/kafka=${standard.id}/topic=${orders.topicName}
  group-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${basic.rbacCrn}/kafka=${standard.id}/group=confluent_cli_consumer_*
  group-mapping-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${["application-developers"].id}
      roleName: EnvironmentAdmin
      crnPattern: ${stag.resourceName}
  transaction-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${basic.rbacCrn}/kafka=${standard.id}/transactional-id=my_transaction
  connector-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${standard.rbacCrn}/connector=${connectorName}
  all-subjects-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${example.resourceName}/subject=*
  subject-foo-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${example.resourceName}/subject=foo
  subject-with-abc-prefix-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${example.resourceName}/subject=abc*
  kek-example-rb:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${test.id}
      roleName: DeveloperRead
      crnPattern: ${example.resourceName}/kek=kek-name
variables:
  connectorName:
    fn::invoke:
      function: std:lookup
      arguments:
        map: ${testConfluentConnector.configNonsensitive}
        key: name
        default: '"name" attribute is missing'
      return: result

import * as pulumi from "@pulumi/pulumi";
import * as confluentcloud from "@pulumi/confluentcloud";
import * as time from "@pulumi/time";

const app_manager_kafka_cluster_admin_skip_sync = new confluentcloud.RoleBinding("app-manager-kafka-cluster-admin-skip-sync", {
    principal: `User:${app_manager.id}`,
    roleName: "CloudClusterAdmin",
    crnPattern: standard.rbacCrn,
    disableWaitForReady: true,
});
const wait360SecondsAfterRoleBinding = new time.index.Sleep("wait_360_seconds_after_role_binding", {createDuration: "360s"}, {
    dependsOn: [app_manager_kafka_cluster_admin_skip_sync],
});
const orders = new confluentcloud.KafkaTopic("orders", {
    kafkaCluster: {
        id: standard.id,
    },
    topicName: "orders",
    restEndpoint: standard.restEndpoint,
    credentials: {
        key: app_manager_kafka_api_key.id,
        secret: app_manager_kafka_api_key.secret,
    },
}, {
    dependsOn: [wait360SecondsAfterRoleBinding],
});

import pulumi
import pulumi_confluentcloud as confluentcloud
import pulumi_time as time

app_manager_kafka_cluster_admin_skip_sync = confluentcloud.RoleBinding("app-manager-kafka-cluster-admin-skip-sync",
    principal=f"User:{app_manager['id']}",
    role_name="CloudClusterAdmin",
    crn_pattern=standard["rbacCrn"],
    disable_wait_for_ready=True)
wait360_seconds_after_role_binding = time.index.Sleep("wait_360_seconds_after_role_binding", create_duration=360s,
opts = pulumi.ResourceOptions(depends_on=[app_manager_kafka_cluster_admin_skip_sync]))
orders = confluentcloud.KafkaTopic("orders",
    kafka_cluster={
        "id": standard["id"],
    },
    topic_name="orders",
    rest_endpoint=standard["restEndpoint"],
    credentials={
        "key": app_manager_kafka_api_key["id"],
        "secret": app_manager_kafka_api_key["secret"],
    },
    opts = pulumi.ResourceOptions(depends_on=[wait360_seconds_after_role_binding]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi-time/sdk/go/time"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		app_manager_kafka_cluster_admin_skip_sync, err := confluentcloud.NewRoleBinding(ctx, "app-manager-kafka-cluster-admin-skip-sync", &confluentcloud.RoleBindingArgs{
			Principal:           pulumi.Sprintf("User:%v", app_manager.Id),
			RoleName:            pulumi.String("CloudClusterAdmin"),
			CrnPattern:          pulumi.Any(standard.RbacCrn),
			DisableWaitForReady: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		wait360SecondsAfterRoleBinding, err := time.NewSleep(ctx, "wait_360_seconds_after_role_binding", &time.SleepArgs{
			CreateDuration: "360s",
		}, pulumi.DependsOn([]pulumi.Resource{
			app_manager_kafka_cluster_admin_skip_sync,
		}))
		if err != nil {
			return err
		}
		_, err = confluentcloud.NewKafkaTopic(ctx, "orders", &confluentcloud.KafkaTopicArgs{
			KafkaCluster: &confluentcloud.KafkaTopicKafkaClusterArgs{
				Id: pulumi.Any(standard.Id),
			},
			TopicName:    pulumi.String("orders"),
			RestEndpoint: pulumi.Any(standard.RestEndpoint),
			Credentials: &confluentcloud.KafkaTopicCredentialsArgs{
				Key:    pulumi.Any(app_manager_kafka_api_key.Id),
				Secret: pulumi.Any(app_manager_kafka_api_key.Secret),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			wait360SecondsAfterRoleBinding,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using ConfluentCloud = Pulumi.ConfluentCloud;
using Time = Pulumi.Time;

return await Deployment.RunAsync(() => 
{
    var app_manager_kafka_cluster_admin_skip_sync = new ConfluentCloud.RoleBinding("app-manager-kafka-cluster-admin-skip-sync", new()
    {
        Principal = $"User:{app_manager.Id}",
        RoleName = "CloudClusterAdmin",
        CrnPattern = standard.RbacCrn,
        DisableWaitForReady = true,
    });

    var wait360SecondsAfterRoleBinding = new Time.Index.Sleep("wait_360_seconds_after_role_binding", new()
    {
        CreateDuration = "360s",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            app_manager_kafka_cluster_admin_skip_sync,
        },
    });

    var orders = new ConfluentCloud.KafkaTopic("orders", new()
    {
        KafkaCluster = new ConfluentCloud.Inputs.KafkaTopicKafkaClusterArgs
        {
            Id = standard.Id,
        },
        TopicName = "orders",
        RestEndpoint = standard.RestEndpoint,
        Credentials = new ConfluentCloud.Inputs.KafkaTopicCredentialsArgs
        {
            Key = app_manager_kafka_api_key.Id,
            Secret = app_manager_kafka_api_key.Secret,
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            wait360SecondsAfterRoleBinding,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.RoleBinding;
import com.pulumi.confluentcloud.RoleBindingArgs;
import com.pulumi.time.Sleep;
import com.pulumi.time.SleepArgs;
import com.pulumi.confluentcloud.KafkaTopic;
import com.pulumi.confluentcloud.KafkaTopicArgs;
import com.pulumi.confluentcloud.inputs.KafkaTopicKafkaClusterArgs;
import com.pulumi.confluentcloud.inputs.KafkaTopicCredentialsArgs;
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) {
        var app_manager_kafka_cluster_admin_skip_sync = new RoleBinding("app-manager-kafka-cluster-admin-skip-sync", RoleBindingArgs.builder()
            .principal(String.format("User:%s", app_manager.id()))
            .roleName("CloudClusterAdmin")
            .crnPattern(standard.rbacCrn())
            .disableWaitForReady(true)
            .build());

        var wait360SecondsAfterRoleBinding = new Sleep("wait360SecondsAfterRoleBinding", SleepArgs.builder()
            .createDuration("360s")
            .build(), CustomResourceOptions.builder()
                .dependsOn(List.of(app_manager_kafka_cluster_admin_skip_sync))
                .build());

        var orders = new KafkaTopic("orders", KafkaTopicArgs.builder()
            .kafkaCluster(KafkaTopicKafkaClusterArgs.builder()
                .id(standard.id())
                .build())
            .topicName("orders")
            .restEndpoint(standard.restEndpoint())
            .credentials(KafkaTopicCredentialsArgs.builder()
                .key(app_manager_kafka_api_key.id())
                .secret(app_manager_kafka_api_key.secret())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(wait360SecondsAfterRoleBinding)
                .build());

    }
}

resources:
  app-manager-kafka-cluster-admin-skip-sync:
    type: confluentcloud:RoleBinding
    properties:
      principal: User:${["app-manager"].id}
      roleName: CloudClusterAdmin
      crnPattern: ${standard.rbacCrn}
      disableWaitForReady: true
  wait360SecondsAfterRoleBinding:
    type: time:Sleep
    name: wait_360_seconds_after_role_binding
    properties:
      createDuration: 360s
    options:
      dependsOn:
        - ${["app-manager-kafka-cluster-admin-skip-sync"]}
  orders:
    type: confluentcloud:KafkaTopic
    properties:
      kafkaCluster:
        id: ${standard.id}
      topicName: orders
      restEndpoint: ${standard.restEndpoint}
      credentials:
        key: ${["app-manager-kafka-api-key"].id}
        secret: ${["app-manager-kafka-api-key"].secret}
    options:
      dependsOn:
        - ${wait360SecondsAfterRoleBinding}