redpanda.ServerlessCluster

resources:
  example:
    type: redpanda:ResourceGroup
    properties:
      name: example-resource-group
  exampleServerlessCluster:
    type: redpanda:ServerlessCluster
    name: example
    properties:
      name: example-serverless-cluster
      resourceGroupId: ${example.id}
      region: us-west-2

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

const test = new redpanda.ResourceGroup("test", {name: resourceGroupName});
const testServerlessPrivateLink: redpanda.ServerlessPrivateLink[] = [];
for (const range = {value: 0}; range.value < (privateNetworking == "STATE_ENABLED" ? 1 : 0); range.value++) {
    testServerlessPrivateLink.push(new redpanda.ServerlessPrivateLink(`test-${range.value}`, {
        name: `${clusterName}-private-link`,
        resourceGroupId: test.id,
        cloudProvider: "aws",
        serverlessRegion: region,
        allowDeletion: allowPrivateLinkDeletion,
        awsConfig: {
            allowedPrincipals: allowedPrincipals,
        },
    }));
}
const testServerlessCluster = new redpanda.ServerlessCluster("test", {
    name: clusterName,
    resourceGroupId: test.id,
    serverlessRegion: region,
    allowDeletion: clusterAllowDeletion,
    privateLinkId: privateNetworking == "STATE_ENABLED" ? testServerlessPrivateLink[0].id : null,
    networkingConfig: {
        "public": publicNetworking,
        "private": privateNetworking,
    },
});
const testTopic = new redpanda.Topic("test", {
    name: topicName,
    partitionCount: partitionCount,
    replicationFactor: replicationFactor,
    clusterApiUrl: testServerlessCluster.clusterApiUrl,
    allowDeletion: true,
});
const testUser = new redpanda.User("test", {
    name: userName,
    password: userPw,
    mechanism: mechanism,
    clusterApiUrl: testServerlessCluster.clusterApiUrl,
    allowDeletion: userAllowDeletion,
});
// Schema Registry against a serverless cluster keys off cluster_id (control
// plane), not cluster_api_url; cluster_id resolves the SR endpoint via the
// ServerlessClusterService fallback in GetSchemaRegistryClientForCluster.
// Both redpanda_schema_registry_acl and redpanda_schema route through it.
const providerBootstrapSubject = new redpanda.SchemaRegistryAcl("provider_bootstrap_subject", {
    clusterId: testServerlessCluster.id,
    principal: "User:*",
    resourceType: "SUBJECT",
    resourceName: resourceGroupName,
    patternType: "PREFIXED",
    host: "*",
    operation: "ALL",
    permission: "ALLOW",
    allowDeletion: true,
});
const providerBootstrapRegistry = new redpanda.SchemaRegistryAcl("provider_bootstrap_registry", {
    clusterId: testServerlessCluster.id,
    principal: "User:*",
    resourceType: "REGISTRY",
    resourceName: "*",
    patternType: "LITERAL",
    host: "*",
    operation: "ALL",
    permission: "ALLOW",
    allowDeletion: true,
});
const userSchema = new redpanda.Schema("user_schema", {
    clusterId: testServerlessCluster.id,
    subject: `${resourceGroupName}-value`,
    schemaType: "AVRO",
    compatibility: "BACKWARD",
    allowDeletion: true,
    schema: JSON.stringify({
        type: "record",
        name: "User",
        fields: [
            {
                name: "id",
                type: "long",
            },
            {
                name: "name",
                type: "string",
            },
        ],
    }),
}, {
    dependsOn: [
        providerBootstrapSubject,
        providerBootstrapRegistry,
    ],
});

import pulumi
import json
import pulumi_redpanda as redpanda

test = redpanda.ResourceGroup("test", name=resource_group_name)
test_serverless_private_link = []
for range in [{"value": i} for i in range(0, 1 if private_networking == STATE_ENABLED else 0)]:
    test_serverless_private_link.append(redpanda.ServerlessPrivateLink(f"test-{range['value']}",
        name=f"{cluster_name}-private-link",
        resource_group_id=test.id,
        cloud_provider="aws",
        serverless_region=region,
        allow_deletion=allow_private_link_deletion,
        aws_config={
            "allowed_principals": allowed_principals,
        }))
test_serverless_cluster = redpanda.ServerlessCluster("test",
    name=cluster_name,
    resource_group_id=test.id,
    serverless_region=region,
    allow_deletion=cluster_allow_deletion,
    private_link_id=test_serverless_private_link[0].id if private_networking == "STATE_ENABLED" else None,
    networking_config={
        "public": public_networking,
        "private": private_networking,
    })
test_topic = redpanda.Topic("test",
    name=topic_name,
    partition_count=partition_count,
    replication_factor=replication_factor,
    cluster_api_url=test_serverless_cluster.cluster_api_url,
    allow_deletion=True)
test_user = redpanda.User("test",
    name=user_name,
    password=user_pw,
    mechanism=mechanism,
    cluster_api_url=test_serverless_cluster.cluster_api_url,
    allow_deletion=user_allow_deletion)
# Schema Registry against a serverless cluster keys off cluster_id (control
# plane), not cluster_api_url; cluster_id resolves the SR endpoint via the
# ServerlessClusterService fallback in GetSchemaRegistryClientForCluster.
# Both redpanda_schema_registry_acl and redpanda_schema route through it.
provider_bootstrap_subject = redpanda.SchemaRegistryAcl("provider_bootstrap_subject",
    cluster_id=test_serverless_cluster.id,
    principal="User:*",
    resource_type="SUBJECT",
    resource_name_=resource_group_name,
    pattern_type="PREFIXED",
    host="*",
    operation="ALL",
    permission="ALLOW",
    allow_deletion=True)
provider_bootstrap_registry = redpanda.SchemaRegistryAcl("provider_bootstrap_registry",
    cluster_id=test_serverless_cluster.id,
    principal="User:*",
    resource_type="REGISTRY",
    resource_name_="*",
    pattern_type="LITERAL",
    host="*",
    operation="ALL",
    permission="ALLOW",
    allow_deletion=True)
user_schema = redpanda.Schema("user_schema",
    cluster_id=test_serverless_cluster.id,
    subject=f"{resource_group_name}-value",
    schema_type="AVRO",
    compatibility="BACKWARD",
    allow_deletion=True,
    schema=json.dumps({
        "type": "record",
        "name": "User",
        "fields": [
            {
                "name": "id",
                "type": "long",
            },
            {
                "name": "name",
                "type": "string",
            },
        ],
    }),
    opts = pulumi.ResourceOptions(depends_on=[
            provider_bootstrap_subject,
            provider_bootstrap_registry,
        ]))

package main

import (
	"encoding/json"
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/redpanda/v2/redpanda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := redpanda.NewResourceGroup(ctx, "test", &redpanda.ResourceGroupArgs{
			Name: pulumi.Any(resourceGroupName),
		})
		if err != nil {
			return err
		}
		var tmp0 float64
		if privateNetworking == "STATE_ENABLED" {
			tmp0 = 1
		} else {
			tmp0 = 0
		}
		var testServerlessPrivateLink []*redpanda.ServerlessPrivateLink
		for index := 0; index < tmp0; index++ {
			key0 := index
			_ := index
			__res, err := redpanda.NewServerlessPrivateLink(ctx, fmt.Sprintf("test-%v", key0), &redpanda.ServerlessPrivateLinkArgs{
				Name:             pulumi.Sprintf("%v-private-link", clusterName),
				ResourceGroupId:  test.ID(),
				CloudProvider:    pulumi.String("aws"),
				ServerlessRegion: pulumi.Any(region),
				AllowDeletion:    pulumi.Any(allowPrivateLinkDeletion),
				AwsConfig: &redpanda.ServerlessPrivateLinkAwsConfigArgs{
					AllowedPrincipals: pulumi.Any(allowedPrincipals),
				},
			})
			if err != nil {
				return err
			}
			testServerlessPrivateLink = append(testServerlessPrivateLink, __res)
		}
		var tmp1 pulumi.String
		if privateNetworking == "STATE_ENABLED" {
			tmp1 = testServerlessPrivateLink[0].ID()
		} else {
			tmp1 = nil
		}
		testServerlessCluster, err := redpanda.NewServerlessCluster(ctx, "test", &redpanda.ServerlessClusterArgs{
			Name:             pulumi.Any(clusterName),
			ResourceGroupId:  test.ID(),
			ServerlessRegion: pulumi.Any(region),
			AllowDeletion:    pulumi.Any(clusterAllowDeletion),
			PrivateLinkId:    pulumi.String(tmp1),
			NetworkingConfig: &redpanda.ServerlessClusterNetworkingConfigArgs{
				Public:  pulumi.Any(publicNetworking),
				Private: pulumi.Any(privateNetworking),
			},
		})
		if err != nil {
			return err
		}
		_, err = redpanda.NewTopic(ctx, "test", &redpanda.TopicArgs{
			Name:              pulumi.Any(topicName),
			PartitionCount:    pulumi.Any(partitionCount),
			ReplicationFactor: pulumi.Any(replicationFactor),
			ClusterApiUrl:     testServerlessCluster.ClusterApiUrl,
			AllowDeletion:     pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = redpanda.NewUser(ctx, "test", &redpanda.UserArgs{
			Name:          pulumi.Any(userName),
			Password:      pulumi.Any(userPw),
			Mechanism:     pulumi.Any(mechanism),
			ClusterApiUrl: testServerlessCluster.ClusterApiUrl,
			AllowDeletion: pulumi.Any(userAllowDeletion),
		})
		if err != nil {
			return err
		}
		// Schema Registry against a serverless cluster keys off cluster_id (control
		// plane), not cluster_api_url; cluster_id resolves the SR endpoint via the
		// ServerlessClusterService fallback in GetSchemaRegistryClientForCluster.
		// Both redpanda_schema_registry_acl and redpanda_schema route through it.
		providerBootstrapSubject, err := redpanda.NewSchemaRegistryAcl(ctx, "provider_bootstrap_subject", &redpanda.SchemaRegistryAclArgs{
			ClusterId:     testServerlessCluster.ID(),
			Principal:     pulumi.String("User:*"),
			ResourceType:  pulumi.String("SUBJECT"),
			ResourceName:  pulumi.Any(resourceGroupName),
			PatternType:   pulumi.String("PREFIXED"),
			Host:          pulumi.String("*"),
			Operation:     pulumi.String("ALL"),
			Permission:    pulumi.String("ALLOW"),
			AllowDeletion: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		providerBootstrapRegistry, err := redpanda.NewSchemaRegistryAcl(ctx, "provider_bootstrap_registry", &redpanda.SchemaRegistryAclArgs{
			ClusterId:     testServerlessCluster.ID(),
			Principal:     pulumi.String("User:*"),
			ResourceType:  pulumi.String("REGISTRY"),
			ResourceName:  pulumi.String("*"),
			PatternType:   pulumi.String("LITERAL"),
			Host:          pulumi.String("*"),
			Operation:     pulumi.String("ALL"),
			Permission:    pulumi.String("ALLOW"),
			AllowDeletion: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"type": "record",
			"name": "User",
			"fields": []map[string]interface{}{
				map[string]interface{}{
					"name": "id",
					"type": "long",
				},
				map[string]interface{}{
					"name": "name",
					"type": "string",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = redpanda.NewSchema(ctx, "user_schema", &redpanda.SchemaArgs{
			ClusterId:     testServerlessCluster.ID(),
			Subject:       pulumi.Sprintf("%v-value", resourceGroupName),
			SchemaType:    pulumi.String("AVRO"),
			Compatibility: pulumi.String("BACKWARD"),
			AllowDeletion: pulumi.Bool(true),
			Schema:        pulumi.String(json0),
		}, pulumi.DependsOn([]pulumi.Resource{
			providerBootstrapSubject,
			providerBootstrapRegistry,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Redpanda = Pulumi.Redpanda;

return await Deployment.RunAsync(() => 
{
    var test = new Redpanda.ResourceGroup("test", new()
    {
        Name = resourceGroupName,
    });

    var testServerlessPrivateLink = new List<Redpanda.ServerlessPrivateLink>();
    for (var rangeIndex = 0; rangeIndex < (privateNetworking == "STATE_ENABLED" ? 1 : 0); rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        testServerlessPrivateLink.Add(new Redpanda.ServerlessPrivateLink($"test-{range.Value}", new()
        {
            Name = $"{clusterName}-private-link",
            ResourceGroupId = test.Id,
            CloudProvider = "aws",
            ServerlessRegion = region,
            AllowDeletion = allowPrivateLinkDeletion,
            AwsConfig = new Redpanda.Inputs.ServerlessPrivateLinkAwsConfigArgs
            {
                AllowedPrincipals = allowedPrincipals,
            },
        }));
    }
    var testServerlessCluster = new Redpanda.ServerlessCluster("test", new()
    {
        Name = clusterName,
        ResourceGroupId = test.Id,
        ServerlessRegion = region,
        AllowDeletion = clusterAllowDeletion,
        PrivateLinkId = privateNetworking == "STATE_ENABLED" ? testServerlessPrivateLink[0].Id : null,
        NetworkingConfig = new Redpanda.Inputs.ServerlessClusterNetworkingConfigArgs
        {
            Public = publicNetworking,
            Private = privateNetworking,
        },
    });

    var testTopic = new Redpanda.Topic("test", new()
    {
        Name = topicName,
        PartitionCount = partitionCount,
        ReplicationFactor = replicationFactor,
        ClusterApiUrl = testServerlessCluster.ClusterApiUrl,
        AllowDeletion = true,
    });

    var testUser = new Redpanda.User("test", new()
    {
        Name = userName,
        Password = userPw,
        Mechanism = mechanism,
        ClusterApiUrl = testServerlessCluster.ClusterApiUrl,
        AllowDeletion = userAllowDeletion,
    });

    // Schema Registry against a serverless cluster keys off cluster_id (control
    // plane), not cluster_api_url; cluster_id resolves the SR endpoint via the
    // ServerlessClusterService fallback in GetSchemaRegistryClientForCluster.
    // Both redpanda_schema_registry_acl and redpanda_schema route through it.
    var providerBootstrapSubject = new Redpanda.SchemaRegistryAcl("provider_bootstrap_subject", new()
    {
        ClusterId = testServerlessCluster.Id,
        Principal = "User:*",
        ResourceType = "SUBJECT",
        ResourceName = resourceGroupName,
        PatternType = "PREFIXED",
        Host = "*",
        Operation = "ALL",
        Permission = "ALLOW",
        AllowDeletion = true,
    });

    var providerBootstrapRegistry = new Redpanda.SchemaRegistryAcl("provider_bootstrap_registry", new()
    {
        ClusterId = testServerlessCluster.Id,
        Principal = "User:*",
        ResourceType = "REGISTRY",
        ResourceName = "*",
        PatternType = "LITERAL",
        Host = "*",
        Operation = "ALL",
        Permission = "ALLOW",
        AllowDeletion = true,
    });

    var userSchema = new Redpanda.Schema("user_schema", new()
    {
        ClusterId = testServerlessCluster.Id,
        Subject = $"{resourceGroupName}-value",
        SchemaType = "AVRO",
        Compatibility = "BACKWARD",
        AllowDeletion = true,
        Schema = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["type"] = "record",
            ["name"] = "User",
            ["fields"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["name"] = "id",
                    ["type"] = "long",
                },
                new Dictionary<string, object?>
                {
                    ["name"] = "name",
                    ["type"] = "string",
                },
            },
        }),
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            providerBootstrapSubject,
            providerBootstrapRegistry,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.redpanda.ResourceGroup;
import com.pulumi.redpanda.ResourceGroupArgs;
import com.pulumi.redpanda.ServerlessPrivateLink;
import com.pulumi.redpanda.ServerlessPrivateLinkArgs;
import com.pulumi.redpanda.inputs.ServerlessPrivateLinkAwsConfigArgs;
import com.pulumi.redpanda.ServerlessCluster;
import com.pulumi.redpanda.ServerlessClusterArgs;
import com.pulumi.redpanda.inputs.ServerlessClusterNetworkingConfigArgs;
import com.pulumi.redpanda.Topic;
import com.pulumi.redpanda.TopicArgs;
import com.pulumi.redpanda.User;
import com.pulumi.redpanda.UserArgs;
import com.pulumi.redpanda.SchemaRegistryAcl;
import com.pulumi.redpanda.SchemaRegistryAclArgs;
import com.pulumi.redpanda.Schema;
import com.pulumi.redpanda.SchemaArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.codegen.internal.KeyedValue;
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 test = new ResourceGroup("test", ResourceGroupArgs.builder()
            .name(resourceGroupName)
            .build());

        for (var i = 0; i < (privateNetworking == "STATE_ENABLED" ? 1 : 0); i++) {
            new ServerlessPrivateLink("testServerlessPrivateLink-" + i, ServerlessPrivateLinkArgs.builder()
                .name(String.format("%s-private-link", clusterName))
                .resourceGroupId(test.id())
                .cloudProvider("aws")
                .serverlessRegion(region)
                .allowDeletion(allowPrivateLinkDeletion)
                .awsConfig(ServerlessPrivateLinkAwsConfigArgs.builder()
                    .allowedPrincipals(allowedPrincipals)
                    .build())
                .build());

        
}
        var testServerlessCluster = new ServerlessCluster("testServerlessCluster", ServerlessClusterArgs.builder()
            .name(clusterName)
            .resourceGroupId(test.id())
            .serverlessRegion(region)
            .allowDeletion(clusterAllowDeletion)
            .privateLinkId(privateNetworking == "STATE_ENABLED" ? testServerlessPrivateLink[0].id() : null)
            .networkingConfig(ServerlessClusterNetworkingConfigArgs.builder()
                .public_(publicNetworking)
                .private_(privateNetworking)
                .build())
            .build());

        var testTopic = new Topic("testTopic", TopicArgs.builder()
            .name(topicName)
            .partitionCount(partitionCount)
            .replicationFactor(replicationFactor)
            .clusterApiUrl(testServerlessCluster.clusterApiUrl())
            .allowDeletion(true)
            .build());

        var testUser = new User("testUser", UserArgs.builder()
            .name(userName)
            .password(userPw)
            .mechanism(mechanism)
            .clusterApiUrl(testServerlessCluster.clusterApiUrl())
            .allowDeletion(userAllowDeletion)
            .build());

        // Schema Registry against a serverless cluster keys off cluster_id (control
        // plane), not cluster_api_url; cluster_id resolves the SR endpoint via the
        // ServerlessClusterService fallback in GetSchemaRegistryClientForCluster.
        // Both redpanda_schema_registry_acl and redpanda_schema route through it.
        var providerBootstrapSubject = new SchemaRegistryAcl("providerBootstrapSubject", SchemaRegistryAclArgs.builder()
            .clusterId(testServerlessCluster.id())
            .principal("User:*")
            .resourceType("SUBJECT")
            .resourceName(resourceGroupName)
            .patternType("PREFIXED")
            .host("*")
            .operation("ALL")
            .permission("ALLOW")
            .allowDeletion(true)
            .build());

        var providerBootstrapRegistry = new SchemaRegistryAcl("providerBootstrapRegistry", SchemaRegistryAclArgs.builder()
            .clusterId(testServerlessCluster.id())
            .principal("User:*")
            .resourceType("REGISTRY")
            .resourceName("*")
            .patternType("LITERAL")
            .host("*")
            .operation("ALL")
            .permission("ALLOW")
            .allowDeletion(true)
            .build());

        var userSchema = new Schema("userSchema", SchemaArgs.builder()
            .clusterId(testServerlessCluster.id())
            .subject(String.format("%s-value", resourceGroupName))
            .schemaType("AVRO")
            .compatibility("BACKWARD")
            .allowDeletion(true)
            .schema(serializeJson(
                jsonObject(
                    jsonProperty("type", "record"),
                    jsonProperty("name", "User"),
                    jsonProperty("fields", jsonArray(
                        jsonObject(
                            jsonProperty("name", "id"),
                            jsonProperty("type", "long")
                        ), 
                        jsonObject(
                            jsonProperty("name", "name"),
                            jsonProperty("type", "string")
                        )
                    ))
                )))
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    providerBootstrapSubject,
                    providerBootstrapRegistry)
                .build());

    }
}

var serverlessClusterResource = new Redpanda.ServerlessCluster("serverlessClusterResource", new()
{
    ResourceGroupId = "string",
    ServerlessRegion = "string",
    AllowDeletion = false,
    Name = "string",
    NetworkingConfig = new Redpanda.Inputs.ServerlessClusterNetworkingConfigArgs
    {
        Private = "string",
        Public = "string",
    },
    PrivateLinkId = "string",
    Tags = 
    {
        { "string", "string" },
    },
    Timeouts = new Redpanda.Inputs.ServerlessClusterTimeoutsArgs
    {
        Create = "string",
        Delete = "string",
        Update = "string",
    },
});

example, err := redpanda.NewServerlessCluster(ctx, "serverlessClusterResource", &redpanda.ServerlessClusterArgs{
	ResourceGroupId:  pulumi.String("string"),
	ServerlessRegion: pulumi.String("string"),
	AllowDeletion:    pulumi.Bool(false),
	Name:             pulumi.String("string"),
	NetworkingConfig: &redpanda.ServerlessClusterNetworkingConfigArgs{
		Private: pulumi.String("string"),
		Public:  pulumi.String("string"),
	},
	PrivateLinkId: pulumi.String("string"),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Timeouts: &redpanda.ServerlessClusterTimeoutsArgs{
		Create: pulumi.String("string"),
		Delete: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

resource "redpanda_serverlesscluster" "serverlessClusterResource" {
  resource_group_id = "string"
  serverless_region = "string"
  allow_deletion    = false
  name              = "string"
  networking_config = {
    private = "string"
    public  = "string"
  }
  private_link_id = "string"
  tags = {
    "string" = "string"
  }
  timeouts = {
    create = "string"
    delete = "string"
    update = "string"
  }
}

var serverlessClusterResource = new ServerlessCluster("serverlessClusterResource", ServerlessClusterArgs.builder()
    .resourceGroupId("string")
    .serverlessRegion("string")
    .allowDeletion(false)
    .name("string")
    .networkingConfig(ServerlessClusterNetworkingConfigArgs.builder()
        .private_("string")
        .public_("string")
        .build())
    .privateLinkId("string")
    .tags(Map.of("string", "string"))
    .timeouts(ServerlessClusterTimeoutsArgs.builder()
        .create("string")
        .delete("string")
        .update("string")
        .build())
    .build());

serverless_cluster_resource = redpanda.ServerlessCluster("serverlessClusterResource",
    resource_group_id="string",
    serverless_region="string",
    allow_deletion=False,
    name="string",
    networking_config={
        "private": "string",
        "public": "string",
    },
    private_link_id="string",
    tags={
        "string": "string",
    },
    timeouts={
        "create": "string",
        "delete": "string",
        "update": "string",
    })

const serverlessClusterResource = new redpanda.ServerlessCluster("serverlessClusterResource", {
    resourceGroupId: "string",
    serverlessRegion: "string",
    allowDeletion: false,
    name: "string",
    networkingConfig: {
        "private": "string",
        "public": "string",
    },
    privateLinkId: "string",
    tags: {
        string: "string",
    },
    timeouts: {
        create: "string",
        "delete": "string",
        update: "string",
    },
});

type: redpanda:ServerlessCluster
properties:
    allowDeletion: false
    name: string
    networkingConfig:
        private: string
        public: string
    privateLinkId: string
    resourceGroupId: string
    serverlessRegion: string
    tags:
        string: string
    timeouts:
        create: string
        delete: string
        update: string