datadog.getTeamNotificationRule

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

// Get a specific notification rule for a team
const example = datadog.getTeamNotificationRule({
    teamId: "00000000-0000-0000-0000-000000000000",
    ruleId: "11111111-1111-1111-1111-111111111111",
});

import pulumi
import pulumi_datadog as datadog

# Get a specific notification rule for a team
example = datadog.get_team_notification_rule(team_id="00000000-0000-0000-0000-000000000000",
    rule_id="11111111-1111-1111-1111-111111111111")

package main

import (
	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get a specific notification rule for a team
		_, err := datadog.LookupTeamNotificationRule(ctx, &datadog.LookupTeamNotificationRuleArgs{
			TeamId: "00000000-0000-0000-0000-000000000000",
			RuleId: "11111111-1111-1111-1111-111111111111",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Get a specific notification rule for a team
    var example = Datadog.GetTeamNotificationRule.Invoke(new()
    {
        TeamId = "00000000-0000-0000-0000-000000000000",
        RuleId = "11111111-1111-1111-1111-111111111111",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.datadog.DatadogFunctions;
import com.pulumi.datadog.inputs.GetTeamNotificationRuleArgs;
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) {
        // Get a specific notification rule for a team
        final var example = DatadogFunctions.getTeamNotificationRule(GetTeamNotificationRuleArgs.builder()
            .teamId("00000000-0000-0000-0000-000000000000")
            .ruleId("11111111-1111-1111-1111-111111111111")
            .build());

    }
}

variables:
  # Get a specific notification rule for a team
  example:
    fn::invoke:
      function: datadog:getTeamNotificationRule
      arguments:
        teamId: 00000000-0000-0000-0000-000000000000
        ruleId: 11111111-1111-1111-1111-111111111111

function getTeamNotificationRule(args: GetTeamNotificationRuleArgs, opts?: InvokeOptions): Promise<GetTeamNotificationRuleResult>
function getTeamNotificationRuleOutput(args: GetTeamNotificationRuleOutputArgs, opts?: InvokeOptions): Output<GetTeamNotificationRuleResult>

def get_team_notification_rule(email: Optional[GetTeamNotificationRuleEmail] = None,
                               ms_teams: Optional[GetTeamNotificationRuleMsTeams] = None,
                               pagerduty: Optional[GetTeamNotificationRulePagerduty] = None,
                               rule_id: Optional[str] = None,
                               slack: Optional[GetTeamNotificationRuleSlack] = None,
                               team_id: Optional[str] = None,
                               opts: Optional[InvokeOptions] = None) -> GetTeamNotificationRuleResult
def get_team_notification_rule_output(email: Optional[pulumi.Input[GetTeamNotificationRuleEmailArgs]] = None,
                               ms_teams: Optional[pulumi.Input[GetTeamNotificationRuleMsTeamsArgs]] = None,
                               pagerduty: Optional[pulumi.Input[GetTeamNotificationRulePagerdutyArgs]] = None,
                               rule_id: Optional[pulumi.Input[str]] = None,
                               slack: Optional[pulumi.Input[GetTeamNotificationRuleSlackArgs]] = None,
                               team_id: Optional[pulumi.Input[str]] = None,
                               opts: Optional[InvokeOptions] = None) -> Output[GetTeamNotificationRuleResult]

func LookupTeamNotificationRule(ctx *Context, args *LookupTeamNotificationRuleArgs, opts ...InvokeOption) (*LookupTeamNotificationRuleResult, error)
func LookupTeamNotificationRuleOutput(ctx *Context, args *LookupTeamNotificationRuleOutputArgs, opts ...InvokeOption) LookupTeamNotificationRuleResultOutput

public static class GetTeamNotificationRule 
{
    public static Task<GetTeamNotificationRuleResult> InvokeAsync(GetTeamNotificationRuleArgs args, InvokeOptions? opts = null)
    public static Output<GetTeamNotificationRuleResult> Invoke(GetTeamNotificationRuleInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTeamNotificationRuleResult> getTeamNotificationRule(GetTeamNotificationRuleArgs args, InvokeOptions options)
public static Output<GetTeamNotificationRuleResult> getTeamNotificationRule(GetTeamNotificationRuleArgs args, InvokeOptions options)

fn::invoke:
  function: datadog:index/getTeamNotificationRule:getTeamNotificationRule
  arguments:
    # arguments dictionary