grafana.cloud.getProviderAzureCredential

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

const testProviderAzureCredential = new grafana.cloud.ProviderAzureCredential("test", {
    stackId: "1",
    name: "test-name",
    clientId: "my-client-id",
    clientSecret: "my-client-secret",
    tenantId: "my-tenant-id",
    resourceDiscoveryTagFilters: [
        {
            key: "key-1",
            value: "value-1",
        },
        {
            key: "key-2",
            value: "value-2",
        },
    ],
});
const test = grafana.cloud.getProviderAzureCredentialOutput({
    stackId: testProviderAzureCredential.stackId,
    resourceId: testProviderAzureCredential.resourceId,
});

import pulumi
import pulumi_grafana as grafana
import pulumiverse_grafana as grafana

test_provider_azure_credential = grafana.cloud.ProviderAzureCredential("test",
    stack_id="1",
    name="test-name",
    client_id="my-client-id",
    client_secret="my-client-secret",
    tenant_id="my-tenant-id",
    resource_discovery_tag_filters=[
        {
            "key": "key-1",
            "value": "value-1",
        },
        {
            "key": "key-2",
            "value": "value-2",
        },
    ])
test = grafana.cloud.get_provider_azure_credential_output(stack_id=test_provider_azure_credential.stack_id,
    resource_id=test_provider_azure_credential.resource_id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testProviderAzureCredential, err := cloud.NewProviderAzureCredential(ctx, "test", &cloud.ProviderAzureCredentialArgs{
			StackId:      pulumi.String("1"),
			Name:         pulumi.String("test-name"),
			ClientId:     pulumi.String("my-client-id"),
			ClientSecret: pulumi.String("my-client-secret"),
			TenantId:     pulumi.String("my-tenant-id"),
			ResourceDiscoveryTagFilters: cloud.ProviderAzureCredentialResourceDiscoveryTagFilterArray{
				&cloud.ProviderAzureCredentialResourceDiscoveryTagFilterArgs{
					Key:   pulumi.String("key-1"),
					Value: pulumi.String("value-1"),
				},
				&cloud.ProviderAzureCredentialResourceDiscoveryTagFilterArgs{
					Key:   pulumi.String("key-2"),
					Value: pulumi.String("value-2"),
				},
			},
		})
		if err != nil {
			return err
		}
		_ = cloud.LookupProviderAzureCredentialOutput(ctx, cloud.GetProviderAzureCredentialOutputArgs{
			StackId:    testProviderAzureCredential.StackId,
			ResourceId: testProviderAzureCredential.ResourceId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testProviderAzureCredential = new Grafana.Cloud.ProviderAzureCredential("test", new()
    {
        StackId = "1",
        Name = "test-name",
        ClientId = "my-client-id",
        ClientSecret = "my-client-secret",
        TenantId = "my-tenant-id",
        ResourceDiscoveryTagFilters = new[]
        {
            new Grafana.Cloud.Inputs.ProviderAzureCredentialResourceDiscoveryTagFilterArgs
            {
                Key = "key-1",
                Value = "value-1",
            },
            new Grafana.Cloud.Inputs.ProviderAzureCredentialResourceDiscoveryTagFilterArgs
            {
                Key = "key-2",
                Value = "value-2",
            },
        },
    });

    var test = Grafana.Cloud.GetProviderAzureCredential.Invoke(new()
    {
        StackId = testProviderAzureCredential.StackId,
        ResourceId = testProviderAzureCredential.ResourceId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.cloud.ProviderAzureCredential;
import com.pulumi.grafana.cloud.ProviderAzureCredentialArgs;
import com.pulumi.grafana.cloud.inputs.ProviderAzureCredentialResourceDiscoveryTagFilterArgs;
import com.pulumi.grafana.cloud.CloudFunctions;
import com.pulumi.grafana.cloud.inputs.GetProviderAzureCredentialArgs;
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 testProviderAzureCredential = new ProviderAzureCredential("testProviderAzureCredential", ProviderAzureCredentialArgs.builder()
            .stackId("1")
            .name("test-name")
            .clientId("my-client-id")
            .clientSecret("my-client-secret")
            .tenantId("my-tenant-id")
            .resourceDiscoveryTagFilters(            
                ProviderAzureCredentialResourceDiscoveryTagFilterArgs.builder()
                    .key("key-1")
                    .value("value-1")
                    .build(),
                ProviderAzureCredentialResourceDiscoveryTagFilterArgs.builder()
                    .key("key-2")
                    .value("value-2")
                    .build())
            .build());

        final var test = CloudFunctions.getProviderAzureCredential(GetProviderAzureCredentialArgs.builder()
            .stackId(testProviderAzureCredential.stackId())
            .resourceId(testProviderAzureCredential.resourceId())
            .build());

    }
}

resources:
  testProviderAzureCredential:
    type: grafana:cloud:ProviderAzureCredential
    name: test
    properties:
      stackId: '1'
      name: test-name
      clientId: my-client-id
      clientSecret: my-client-secret
      tenantId: my-tenant-id
      resourceDiscoveryTagFilters:
        - key: key-1
          value: value-1
        - key: key-2
          value: value-2
variables:
  test:
    fn::invoke:
      function: grafana:cloud:getProviderAzureCredential
      arguments:
        stackId: ${testProviderAzureCredential.stackId}
        resourceId: ${testProviderAzureCredential.resourceId}

function getProviderAzureCredential(args: GetProviderAzureCredentialArgs, opts?: InvokeOptions): Promise<GetProviderAzureCredentialResult>
function getProviderAzureCredentialOutput(args: GetProviderAzureCredentialOutputArgs, opts?: InvokeOptions): Output<GetProviderAzureCredentialResult>

def get_provider_azure_credential(resource_discovery_tag_filters: Optional[Sequence[GetProviderAzureCredentialResourceDiscoveryTagFilter]] = None,
                                  resource_id: Optional[str] = None,
                                  stack_id: Optional[str] = None,
                                  opts: Optional[InvokeOptions] = None) -> GetProviderAzureCredentialResult
def get_provider_azure_credential_output(resource_discovery_tag_filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetProviderAzureCredentialResourceDiscoveryTagFilterArgs]]]] = None,
                                  resource_id: Optional[pulumi.Input[str]] = None,
                                  stack_id: Optional[pulumi.Input[str]] = None,
                                  opts: Optional[InvokeOptions] = None) -> Output[GetProviderAzureCredentialResult]

func LookupProviderAzureCredential(ctx *Context, args *LookupProviderAzureCredentialArgs, opts ...InvokeOption) (*LookupProviderAzureCredentialResult, error)
func LookupProviderAzureCredentialOutput(ctx *Context, args *LookupProviderAzureCredentialOutputArgs, opts ...InvokeOption) LookupProviderAzureCredentialResultOutput

public static class GetProviderAzureCredential 
{
    public static Task<GetProviderAzureCredentialResult> InvokeAsync(GetProviderAzureCredentialArgs args, InvokeOptions? opts = null)
    public static Output<GetProviderAzureCredentialResult> Invoke(GetProviderAzureCredentialInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetProviderAzureCredentialResult> getProviderAzureCredential(GetProviderAzureCredentialArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: grafana:cloud/getProviderAzureCredential:getProviderAzureCredential
  arguments:
    # arguments dictionary