grafana.assert.Stack

import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const config = new pulumi.Config();
// The Grafana Cloud stack ID
const stackId = config.require("stackId");
// Example: Asserts Stack with Cloud Access Policy Token
//
// This example shows how to configure the Asserts stack using existing
// Terraform resources to create the required tokens.
//
// The resource performs the full onboarding flow:
// 1. Provisions API tokens
// 2. Auto-configures datasets based on available metrics
// 3. Enables the stack with the configured datasets
// Step 1: Create a Cloud Access Policy with required scopes
const asserts = new grafana.cloud.AccessPolicy("asserts", {
    name: "asserts-stack-policy",
    displayName: "Asserts Stack Policy",
    scopes: [
        "stacks:read",
        "metrics:read",
        "metrics:write",
    ],
    realms: [{
        type: "stack",
        identifier: stackId,
    }],
});
// Step 2: Create a token from the Cloud Access Policy
const assertsAccessPolicyToken = new grafana.cloud.AccessPolicyToken("asserts", {
    name: "asserts-stack-token",
    accessPolicyId: asserts.policyId,
});
// The Grafana Cloud stack slug
const stackSlug = config.require("stackSlug");
// Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
// Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
// datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
// alert.notifications:write, alert.rules:read/create/delete
const assertsStackServiceAccount = new grafana.cloud.StackServiceAccount("asserts", {
    stackSlug: stackSlug,
    name: "asserts-managed-alerts-sa",
    role: "Admin",
    isDisabled: false,
});
const assertsStackServiceAccountToken = new grafana.cloud.StackServiceAccountToken("asserts", {
    stackSlug: stackSlug,
    serviceAccountId: assertsStackServiceAccount.id,
    name: "asserts-managed-alerts-token",
});
// Step 4: Configure the Asserts Stack (auto-detect datasets)
const main = new grafana.assert.Stack("main", {
    cloudAccessPolicyToken: assertsAccessPolicyToken.token,
    grafanaToken: assertsStackServiceAccountToken.key,
});
// Alternative: Configure the Asserts Stack with manual dataset configuration.
// Use this when your metrics use non-standard labels (e.g., a custom environment label).
const custom = new grafana.assert.Stack("custom", {
    cloudAccessPolicyToken: assertsAccessPolicyToken.token,
    grafanaToken: assertsStackServiceAccountToken.key,
    datasets: [
        {
            type: "kubernetes",
            filterGroups: [{
                envLabel: "deployment_environment",
                siteLabel: "cluster",
                envLabelValues: [
                    "production",
                    "staging",
                ],
                siteLabelValues: [
                    "us-east-1",
                    "eu-west-1",
                ],
            }],
        },
        {
            type: "prometheus",
            filterGroups: [{
                envLabel: "environment",
                envName: "prod",
                filters: [{
                    name: "region",
                    operator: "=~",
                    values: [
                        "us-.*",
                        "eu-.*",
                    ],
                }],
            }],
        },
    ],
});
export const stackEnabled = main.enabled;
export const stackStatus = main.status;
export const stackVersion = main.version;

import pulumi
import pulumiverse_grafana as grafana

config = pulumi.Config()
# The Grafana Cloud stack ID
stack_id = config.require("stackId")
# Example: Asserts Stack with Cloud Access Policy Token
#
# This example shows how to configure the Asserts stack using existing
# Terraform resources to create the required tokens.
#
# The resource performs the full onboarding flow:
# 1. Provisions API tokens
# 2. Auto-configures datasets based on available metrics
# 3. Enables the stack with the configured datasets
# Step 1: Create a Cloud Access Policy with required scopes
asserts = grafana.cloud.AccessPolicy("asserts",
    name="asserts-stack-policy",
    display_name="Asserts Stack Policy",
    scopes=[
        "stacks:read",
        "metrics:read",
        "metrics:write",
    ],
    realms=[{
        "type": "stack",
        "identifier": stack_id,
    }])
# Step 2: Create a token from the Cloud Access Policy
asserts_access_policy_token = grafana.cloud.AccessPolicyToken("asserts",
    name="asserts-stack-token",
    access_policy_id=asserts.policy_id)
# The Grafana Cloud stack slug
stack_slug = config.require("stackSlug")
# Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
# Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
# datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
# alert.notifications:write, alert.rules:read/create/delete
asserts_stack_service_account = grafana.cloud.StackServiceAccount("asserts",
    stack_slug=stack_slug,
    name="asserts-managed-alerts-sa",
    role="Admin",
    is_disabled=False)
asserts_stack_service_account_token = grafana.cloud.StackServiceAccountToken("asserts",
    stack_slug=stack_slug,
    service_account_id=asserts_stack_service_account.id,
    name="asserts-managed-alerts-token")
# Step 4: Configure the Asserts Stack (auto-detect datasets)
main = grafana.assert_.Stack("main",
    cloud_access_policy_token=asserts_access_policy_token.token,
    grafana_token=asserts_stack_service_account_token.key)
# Alternative: Configure the Asserts Stack with manual dataset configuration.
# Use this when your metrics use non-standard labels (e.g., a custom environment label).
custom = grafana.assert_.Stack("custom",
    cloud_access_policy_token=asserts_access_policy_token.token,
    grafana_token=asserts_stack_service_account_token.key,
    datasets=[
        {
            "type": "kubernetes",
            "filter_groups": [{
                "env_label": "deployment_environment",
                "site_label": "cluster",
                "env_label_values": [
                    "production",
                    "staging",
                ],
                "site_label_values": [
                    "us-east-1",
                    "eu-west-1",
                ],
            }],
        },
        {
            "type": "prometheus",
            "filter_groups": [{
                "env_label": "environment",
                "env_name": "prod",
                "filters": [{
                    "name": "region",
                    "operator": "=~",
                    "values": [
                        "us-.*",
                        "eu-.*",
                    ],
                }],
            }],
        },
    ])
pulumi.export("stackEnabled", main.enabled)
pulumi.export("stackStatus", main.status)
pulumi.export("stackVersion", main.version)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/assert"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/cloud"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		// The Grafana Cloud stack ID
		stackId := cfg.Require("stackId")
		// Example: Asserts Stack with Cloud Access Policy Token
		//
		// This example shows how to configure the Asserts stack using existing
		// Terraform resources to create the required tokens.
		//
		// The resource performs the full onboarding flow:
		// 1. Provisions API tokens
		// 2. Auto-configures datasets based on available metrics
		// 3. Enables the stack with the configured datasets
		// Step 1: Create a Cloud Access Policy with required scopes
		asserts, err := cloud.NewAccessPolicy(ctx, "asserts", &cloud.AccessPolicyArgs{
			Name:        pulumi.String("asserts-stack-policy"),
			DisplayName: pulumi.String("Asserts Stack Policy"),
			Scopes: pulumi.StringArray{
				pulumi.String("stacks:read"),
				pulumi.String("metrics:read"),
				pulumi.String("metrics:write"),
			},
			Realms: cloud.AccessPolicyRealmArray{
				&cloud.AccessPolicyRealmArgs{
					Type:       pulumi.String("stack"),
					Identifier: pulumi.String(pulumi.String(stackId)),
				},
			},
		})
		if err != nil {
			return err
		}
		// Step 2: Create a token from the Cloud Access Policy
		assertsAccessPolicyToken, err := cloud.NewAccessPolicyToken(ctx, "asserts", &cloud.AccessPolicyTokenArgs{
			Name:           pulumi.String("asserts-stack-token"),
			AccessPolicyId: asserts.PolicyId,
		})
		if err != nil {
			return err
		}
		// The Grafana Cloud stack slug
		stackSlug := cfg.Require("stackSlug")
		// Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
		// Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
		// datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
		// alert.notifications:write, alert.rules:read/create/delete
		assertsStackServiceAccount, err := cloud.NewStackServiceAccount(ctx, "asserts", &cloud.StackServiceAccountArgs{
			StackSlug:  pulumi.String(pulumi.String(stackSlug)),
			Name:       pulumi.String("asserts-managed-alerts-sa"),
			Role:       pulumi.String("Admin"),
			IsDisabled: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		assertsStackServiceAccountToken, err := cloud.NewStackServiceAccountToken(ctx, "asserts", &cloud.StackServiceAccountTokenArgs{
			StackSlug:        pulumi.String(pulumi.String(stackSlug)),
			ServiceAccountId: assertsStackServiceAccount.ID(),
			Name:             pulumi.String("asserts-managed-alerts-token"),
		})
		if err != nil {
			return err
		}
		// Step 4: Configure the Asserts Stack (auto-detect datasets)
		main, err := assert.NewStack(ctx, "main", &assert.StackArgs{
			CloudAccessPolicyToken: assertsAccessPolicyToken.Token,
			GrafanaToken:           assertsStackServiceAccountToken.Key,
		})
		if err != nil {
			return err
		}
		// Alternative: Configure the Asserts Stack with manual dataset configuration.
		// Use this when your metrics use non-standard labels (e.g., a custom environment label).
		_, err = assert.NewStack(ctx, "custom", &assert.StackArgs{
			CloudAccessPolicyToken: assertsAccessPolicyToken.Token,
			GrafanaToken:           assertsStackServiceAccountToken.Key,
			Datasets: assert.StackDatasetArray{
				&assert.StackDatasetArgs{
					Type: pulumi.String("kubernetes"),
					FilterGroups: assert.StackDatasetFilterGroupArray{
						&assert.StackDatasetFilterGroupArgs{
							EnvLabel:  pulumi.String("deployment_environment"),
							SiteLabel: pulumi.String("cluster"),
							EnvLabelValues: pulumi.StringArray{
								pulumi.String("production"),
								pulumi.String("staging"),
							},
							SiteLabelValues: pulumi.StringArray{
								pulumi.String("us-east-1"),
								pulumi.String("eu-west-1"),
							},
						},
					},
				},
				&assert.StackDatasetArgs{
					Type: pulumi.String("prometheus"),
					FilterGroups: assert.StackDatasetFilterGroupArray{
						&assert.StackDatasetFilterGroupArgs{
							EnvLabel: pulumi.String("environment"),
							EnvName:  pulumi.String("prod"),
							Filters: assert.StackDatasetFilterGroupFilterArray{
								&assert.StackDatasetFilterGroupFilterArgs{
									Name:     pulumi.String("region"),
									Operator: pulumi.String("=~"),
									Values: pulumi.StringArray{
										pulumi.String("us-.*"),
										pulumi.String("eu-.*"),
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("stackEnabled", main.Enabled)
		ctx.Export("stackStatus", main.Status)
		ctx.Export("stackVersion", main.Version)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    // The Grafana Cloud stack ID
    var stackId = config.Require("stackId");
    // Example: Asserts Stack with Cloud Access Policy Token
    //
    // This example shows how to configure the Asserts stack using existing
    // Terraform resources to create the required tokens.
    //
    // The resource performs the full onboarding flow:
    // 1. Provisions API tokens
    // 2. Auto-configures datasets based on available metrics
    // 3. Enables the stack with the configured datasets
    // Step 1: Create a Cloud Access Policy with required scopes
    var asserts = new Grafana.Cloud.AccessPolicy("asserts", new()
    {
        Name = "asserts-stack-policy",
        DisplayName = "Asserts Stack Policy",
        Scopes = new[]
        {
            "stacks:read",
            "metrics:read",
            "metrics:write",
        },
        Realms = new[]
        {
            new Grafana.Cloud.Inputs.AccessPolicyRealmArgs
            {
                Type = "stack",
                Identifier = stackId,
            },
        },
    });

    // Step 2: Create a token from the Cloud Access Policy
    var assertsAccessPolicyToken = new Grafana.Cloud.AccessPolicyToken("asserts", new()
    {
        Name = "asserts-stack-token",
        AccessPolicyId = asserts.PolicyId,
    });

    // The Grafana Cloud stack slug
    var stackSlug = config.Require("stackSlug");
    // Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
    // Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
    // datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
    // alert.notifications:write, alert.rules:read/create/delete
    var assertsStackServiceAccount = new Grafana.Cloud.StackServiceAccount("asserts", new()
    {
        StackSlug = stackSlug,
        Name = "asserts-managed-alerts-sa",
        Role = "Admin",
        IsDisabled = false,
    });

    var assertsStackServiceAccountToken = new Grafana.Cloud.StackServiceAccountToken("asserts", new()
    {
        StackSlug = stackSlug,
        ServiceAccountId = assertsStackServiceAccount.Id,
        Name = "asserts-managed-alerts-token",
    });

    // Step 4: Configure the Asserts Stack (auto-detect datasets)
    var main = new Grafana.Assert.Stack("main", new()
    {
        CloudAccessPolicyToken = assertsAccessPolicyToken.Token,
        GrafanaToken = assertsStackServiceAccountToken.Key,
    });

    // Alternative: Configure the Asserts Stack with manual dataset configuration.
    // Use this when your metrics use non-standard labels (e.g., a custom environment label).
    var custom = new Grafana.Assert.Stack("custom", new()
    {
        CloudAccessPolicyToken = assertsAccessPolicyToken.Token,
        GrafanaToken = assertsStackServiceAccountToken.Key,
        Datasets = new[]
        {
            new Grafana.Assert.Inputs.StackDatasetArgs
            {
                Type = "kubernetes",
                FilterGroups = new[]
                {
                    new Grafana.Assert.Inputs.StackDatasetFilterGroupArgs
                    {
                        EnvLabel = "deployment_environment",
                        SiteLabel = "cluster",
                        EnvLabelValues = new[]
                        {
                            "production",
                            "staging",
                        },
                        SiteLabelValues = new[]
                        {
                            "us-east-1",
                            "eu-west-1",
                        },
                    },
                },
            },
            new Grafana.Assert.Inputs.StackDatasetArgs
            {
                Type = "prometheus",
                FilterGroups = new[]
                {
                    new Grafana.Assert.Inputs.StackDatasetFilterGroupArgs
                    {
                        EnvLabel = "environment",
                        EnvName = "prod",
                        Filters = new[]
                        {
                            new Grafana.Assert.Inputs.StackDatasetFilterGroupFilterArgs
                            {
                                Name = "region",
                                Operator = "=~",
                                Values = new[]
                                {
                                    "us-.*",
                                    "eu-.*",
                                },
                            },
                        },
                    },
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["stackEnabled"] = main.Enabled,
        ["stackStatus"] = main.Status,
        ["stackVersion"] = main.Version,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.cloud.AccessPolicy;
import com.pulumi.grafana.cloud.AccessPolicyArgs;
import com.pulumi.grafana.cloud.inputs.AccessPolicyRealmArgs;
import com.pulumi.grafana.cloud.AccessPolicyToken;
import com.pulumi.grafana.cloud.AccessPolicyTokenArgs;
import com.pulumi.grafana.cloud.StackServiceAccount;
import com.pulumi.grafana.cloud.StackServiceAccountArgs;
import com.pulumi.grafana.cloud.StackServiceAccountToken;
import com.pulumi.grafana.cloud.StackServiceAccountTokenArgs;
import com.pulumi.grafana.assert.Stack;
import com.pulumi.grafana.assert.StackArgs;
import com.pulumi.grafana.assert.inputs.StackDatasetArgs;
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 config = ctx.config();
        final var stackId = config.require("stackId");
        // Example: Asserts Stack with Cloud Access Policy Token
        //
        // This example shows how to configure the Asserts stack using existing
        // Terraform resources to create the required tokens.
        //
        // The resource performs the full onboarding flow:
        // 1. Provisions API tokens
        // 2. Auto-configures datasets based on available metrics
        // 3. Enables the stack with the configured datasets
        // Step 1: Create a Cloud Access Policy with required scopes
        var asserts = new AccessPolicy("asserts", AccessPolicyArgs.builder()
            .name("asserts-stack-policy")
            .displayName("Asserts Stack Policy")
            .scopes(            
                "stacks:read",
                "metrics:read",
                "metrics:write")
            .realms(AccessPolicyRealmArgs.builder()
                .type("stack")
                .identifier(stackId)
                .build())
            .build());

        // Step 2: Create a token from the Cloud Access Policy
        var assertsAccessPolicyToken = new AccessPolicyToken("assertsAccessPolicyToken", AccessPolicyTokenArgs.builder()
            .name("asserts-stack-token")
            .accessPolicyId(asserts.policyId())
            .build());

        final var stackSlug = config.require("stackSlug");
        // Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
        // Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
        // datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
        // alert.notifications:write, alert.rules:read/create/delete
        var assertsStackServiceAccount = new StackServiceAccount("assertsStackServiceAccount", StackServiceAccountArgs.builder()
            .stackSlug(stackSlug)
            .name("asserts-managed-alerts-sa")
            .role("Admin")
            .isDisabled(false)
            .build());

        var assertsStackServiceAccountToken = new StackServiceAccountToken("assertsStackServiceAccountToken", StackServiceAccountTokenArgs.builder()
            .stackSlug(stackSlug)
            .serviceAccountId(assertsStackServiceAccount.id())
            .name("asserts-managed-alerts-token")
            .build());

        // Step 4: Configure the Asserts Stack (auto-detect datasets)
        var main = new Stack("main", StackArgs.builder()
            .cloudAccessPolicyToken(assertsAccessPolicyToken.token())
            .grafanaToken(assertsStackServiceAccountToken.key())
            .build());

        // Alternative: Configure the Asserts Stack with manual dataset configuration.
        // Use this when your metrics use non-standard labels (e.g., a custom environment label).
        var custom = new Stack("custom", StackArgs.builder()
            .cloudAccessPolicyToken(assertsAccessPolicyToken.token())
            .grafanaToken(assertsStackServiceAccountToken.key())
            .datasets(            
                StackDatasetArgs.builder()
                    .type("kubernetes")
                    .filterGroups(StackDatasetFilterGroupArgs.builder()
                        .envLabel("deployment_environment")
                        .siteLabel("cluster")
                        .envLabelValues(                        
                            "production",
                            "staging")
                        .siteLabelValues(                        
                            "us-east-1",
                            "eu-west-1")
                        .build())
                    .build(),
                StackDatasetArgs.builder()
                    .type("prometheus")
                    .filterGroups(StackDatasetFilterGroupArgs.builder()
                        .envLabel("environment")
                        .envName("prod")
                        .filters(StackDatasetFilterGroupFilterArgs.builder()
                            .name("region")
                            .operator("=~")
                            .values(                            
                                "us-.*",
                                "eu-.*")
                            .build())
                        .build())
                    .build())
            .build());

        ctx.export("stackEnabled", main.enabled());
        ctx.export("stackStatus", main.status());
        ctx.export("stackVersion", main.version());
    }
}

configuration:
  # Variables
  stackId:
    type: string
  stackSlug:
    type: string
resources:
  # Example: Asserts Stack with Cloud Access Policy Token
  #
  # This example shows how to configure the Asserts stack using existing
  # Terraform resources to create the required tokens.
  #
  # The resource performs the full onboarding flow:
  # 1. Provisions API tokens
  # 2. Auto-configures datasets based on available metrics
  # 3. Enables the stack with the configured datasets

  # Step 1: Create a Cloud Access Policy with required scopes
  asserts:
    type: grafana:cloud:AccessPolicy
    properties:
      name: asserts-stack-policy
      displayName: Asserts Stack Policy
      scopes:
        - stacks:read
        - metrics:read
        - metrics:write
      realms:
        - type: stack
          identifier: ${stackId}
  # Step 2: Create a token from the Cloud Access Policy
  assertsAccessPolicyToken:
    type: grafana:cloud:AccessPolicyToken
    name: asserts
    properties:
      name: asserts-stack-token
      accessPolicyId: ${asserts.policyId}
  # Step 3: Create a Grafana Service Account for dashboards and Grafana Managed Alerts
  # Required permissions: dashboards:create/write/read, folders:create/write/read/delete,
  # datasources:read/query, alert.provisioning:write, alert.notifications.provisioning:write,
  # alert.notifications:write, alert.rules:read/create/delete
  assertsStackServiceAccount:
    type: grafana:cloud:StackServiceAccount
    name: asserts
    properties:
      stackSlug: ${stackSlug}
      name: asserts-managed-alerts-sa
      role: Admin
      isDisabled: false
  assertsStackServiceAccountToken:
    type: grafana:cloud:StackServiceAccountToken
    name: asserts
    properties:
      stackSlug: ${stackSlug}
      serviceAccountId: ${assertsStackServiceAccount.id}
      name: asserts-managed-alerts-token
  # Step 4: Configure the Asserts Stack (auto-detect datasets)
  main:
    type: grafana:assert:Stack
    properties:
      cloudAccessPolicyToken: ${assertsAccessPolicyToken.token}
      grafanaToken: ${assertsStackServiceAccountToken.key}
  # Alternative: Configure the Asserts Stack with manual dataset configuration.
  # Use this when your metrics use non-standard labels (e.g., a custom environment label).
  custom:
    type: grafana:assert:Stack
    properties:
      cloudAccessPolicyToken: ${assertsAccessPolicyToken.token}
      grafanaToken: ${assertsStackServiceAccountToken.key}
      datasets:
        - type: kubernetes
          filterGroups:
            - envLabel: deployment_environment
              siteLabel: cluster
              envLabelValues:
                - production
                - staging
              siteLabelValues:
                - us-east-1
                - eu-west-1
        - type: prometheus
          filterGroups:
            - envLabel: environment
              envName: prod
              filters:
                - name: region
                  operator: =~
                  values:
                    - us-.*
                    - eu-.*
outputs:
  # Outputs
  stackEnabled: ${main.enabled}
  stackStatus: ${main.status}
  stackVersion: ${main.version}

var stackResource = new Grafana.Assert.Stack("stackResource", new()
{
    CloudAccessPolicyToken = "string",
    Datasets = new[]
    {
        new Grafana.Assert.Inputs.StackDatasetArgs
        {
            Type = "string",
            DisabledVendors = new[]
            {
                "string",
            },
            FilterGroups = new[]
            {
                new Grafana.Assert.Inputs.StackDatasetFilterGroupArgs
                {
                    EnvLabel = "string",
                    EnvLabelValues = new[]
                    {
                        "string",
                    },
                    EnvName = "string",
                    Filters = new[]
                    {
                        new Grafana.Assert.Inputs.StackDatasetFilterGroupFilterArgs
                        {
                            Name = "string",
                            Operator = "string",
                            Values = new[]
                            {
                                "string",
                            },
                        },
                    },
                    SiteLabel = "string",
                    SiteLabelValues = new[]
                    {
                        "string",
                    },
                },
            },
        },
    },
    GrafanaToken = "string",
});

example, err := assert.NewStack(ctx, "stackResource", &assert.StackArgs{
	CloudAccessPolicyToken: pulumi.String("string"),
	Datasets: assert.StackDatasetArray{
		&assert.StackDatasetArgs{
			Type: pulumi.String("string"),
			DisabledVendors: pulumi.StringArray{
				pulumi.String("string"),
			},
			FilterGroups: assert.StackDatasetFilterGroupArray{
				&assert.StackDatasetFilterGroupArgs{
					EnvLabel: pulumi.String("string"),
					EnvLabelValues: pulumi.StringArray{
						pulumi.String("string"),
					},
					EnvName: pulumi.String("string"),
					Filters: assert.StackDatasetFilterGroupFilterArray{
						&assert.StackDatasetFilterGroupFilterArgs{
							Name:     pulumi.String("string"),
							Operator: pulumi.String("string"),
							Values: pulumi.StringArray{
								pulumi.String("string"),
							},
						},
					},
					SiteLabel: pulumi.String("string"),
					SiteLabelValues: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
			},
		},
	},
	GrafanaToken: pulumi.String("string"),
})

var stackResource = new com.pulumi.grafana.assert.Stack("stackResource", com.pulumi.grafana.assert.StackArgs.builder()
    .cloudAccessPolicyToken("string")
    .datasets(StackDatasetArgs.builder()
        .type("string")
        .disabledVendors("string")
        .filterGroups(StackDatasetFilterGroupArgs.builder()
            .envLabel("string")
            .envLabelValues("string")
            .envName("string")
            .filters(StackDatasetFilterGroupFilterArgs.builder()
                .name("string")
                .operator("string")
                .values("string")
                .build())
            .siteLabel("string")
            .siteLabelValues("string")
            .build())
        .build())
    .grafanaToken("string")
    .build());

stack_resource = grafana.assert_.Stack("stackResource",
    cloud_access_policy_token="string",
    datasets=[{
        "type": "string",
        "disabled_vendors": ["string"],
        "filter_groups": [{
            "env_label": "string",
            "env_label_values": ["string"],
            "env_name": "string",
            "filters": [{
                "name": "string",
                "operator": "string",
                "values": ["string"],
            }],
            "site_label": "string",
            "site_label_values": ["string"],
        }],
    }],
    grafana_token="string")

const stackResource = new grafana.assert.Stack("stackResource", {
    cloudAccessPolicyToken: "string",
    datasets: [{
        type: "string",
        disabledVendors: ["string"],
        filterGroups: [{
            envLabel: "string",
            envLabelValues: ["string"],
            envName: "string",
            filters: [{
                name: "string",
                operator: "string",
                values: ["string"],
            }],
            siteLabel: "string",
            siteLabelValues: ["string"],
        }],
    }],
    grafanaToken: "string",
});

type: grafana:assert:Stack
properties:
    cloudAccessPolicyToken: string
    datasets:
        - disabledVendors:
            - string
          filterGroups:
            - envLabel: string
              envLabelValues:
                - string
              envName: string
              filters:
                - name: string
                  operator: string
                  values:
                    - string
              siteLabel: string
              siteLabelValues:
                - string
          type: string
    grafanaToken: string