sentry.getSentryIssueAlert

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

// Retrieve an Issue Alert
// URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
const original = sentry.getSentryIssueAlert({
    organization: "my-organization",
    project: "my-project",
    internalId: "42",
});
// Create a copy of an Issue Alert
const copy = new sentry.SentryIssueAlert("copy", {
    organization: original.then(original => original.organization),
    project: original.then(original => original.project),
    name: original.then(original => `${original.name}-copy`),
    actionMatch: original.then(original => original.actionMatch),
    filterMatch: original.then(original => original.filterMatch),
    frequency: original.then(original => original.frequency),
    conditions: original.then(original => original.conditions),
    filters: original.then(original => original.filters),
    actions: original.then(original => original.actions),
});

import pulumi
import pulumi_sentry as sentry
import pulumiverse_sentry as sentry

# Retrieve an Issue Alert
# URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
original = sentry.get_sentry_issue_alert(organization="my-organization",
    project="my-project",
    internal_id="42")
# Create a copy of an Issue Alert
copy = sentry.SentryIssueAlert("copy",
    organization=original.organization,
    project=original.project,
    name=f"{original.name}-copy",
    action_match=original.action_match,
    filter_match=original.filter_match,
    frequency=original.frequency,
    conditions=original.conditions,
    filters=original.filters,
    actions=original.actions)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-sentry/sdk/go/sentry"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Retrieve an Issue Alert
		// URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
		original, err := sentry.LookupSentryIssueAlert(ctx, &sentry.LookupSentryIssueAlertArgs{
			Organization: "my-organization",
			Project:      "my-project",
			InternalId:   "42",
		}, nil)
		if err != nil {
			return err
		}
		// Create a copy of an Issue Alert
		_, err = sentry.NewSentryIssueAlert(ctx, "copy", &sentry.SentryIssueAlertArgs{
			Organization: pulumi.String(original.Organization),
			Project:      pulumi.String(original.Project),
			Name:         pulumi.Sprintf("%v-copy", original.Name),
			ActionMatch:  pulumi.String(original.ActionMatch),
			FilterMatch:  pulumi.String(original.FilterMatch),
			Frequency:    pulumi.Int(original.Frequency),
			Conditions:   interface{}(original.Conditions),
			Filters:      interface{}(original.Filters),
			Actions:      interface{}(original.Actions),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Retrieve an Issue Alert
    // URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
    var original = Sentry.GetSentryIssueAlert.Invoke(new()
    {
        Organization = "my-organization",
        Project = "my-project",
        InternalId = "42",
    });

    // Create a copy of an Issue Alert
    var copy = new Sentry.SentryIssueAlert("copy", new()
    {
        Organization = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Organization),
        Project = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Project),
        Name = $"{original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Name)}-copy",
        ActionMatch = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.ActionMatch),
        FilterMatch = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.FilterMatch),
        Frequency = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Frequency),
        Conditions = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Conditions),
        Filters = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Filters),
        Actions = original.Apply(getSentryIssueAlertResult => getSentryIssueAlertResult.Actions),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.sentry.SentryFunctions;
import com.pulumi.sentry.inputs.GetSentryIssueAlertArgs;
import com.pulumi.sentry.SentryIssueAlert;
import com.pulumi.sentry.SentryIssueAlertArgs;
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) {
        // Retrieve an Issue Alert
        // URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
        final var original = SentryFunctions.getSentryIssueAlert(GetSentryIssueAlertArgs.builder()
            .organization("my-organization")
            .project("my-project")
            .internalId("42")
            .build());

        // Create a copy of an Issue Alert
        var copy = new SentryIssueAlert("copy", SentryIssueAlertArgs.builder()
            .organization(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.organization()))
            .project(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.project()))
            .name(String.format("%s-copy", original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.name())))
            .actionMatch(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.actionMatch()))
            .filterMatch(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.filterMatch()))
            .frequency(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.frequency()))
            .conditions(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.conditions()))
            .filters(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.filters()))
            .actions(original.applyValue(getSentryIssueAlertResult -> getSentryIssueAlertResult.actions()))
            .build());

    }
}

resources:
  # Create a copy of an Issue Alert
  copy:
    type: sentry:SentryIssueAlert
    properties:
      organization: ${original.organization}
      project: ${original.project}
      name: ${original.name}-copy
      actionMatch: ${original.actionMatch}
      filterMatch: ${original.filterMatch}
      frequency: ${original.frequency}
      conditions: ${original.conditions}
      filters: ${original.filters}
      actions: ${original.actions}
variables:
  # Retrieve an Issue Alert
  # URL format: https://sentry.io/organizations/[organization]/alerts/rules/[project]/[internal_id]/details/
  original:
    fn::invoke:
      Function: sentry:getSentryIssueAlert
      Arguments:
        organization: my-organization
        project: my-project
        internalId: '42'

function getSentryIssueAlert(args: GetSentryIssueAlertArgs, opts?: InvokeOptions): Promise<GetSentryIssueAlertResult>
function getSentryIssueAlertOutput(args: GetSentryIssueAlertOutputArgs, opts?: InvokeOptions): Output<GetSentryIssueAlertResult>

def get_sentry_issue_alert(internal_id: Optional[str] = None,
                           organization: Optional[str] = None,
                           project: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetSentryIssueAlertResult
def get_sentry_issue_alert_output(internal_id: Optional[pulumi.Input[str]] = None,
                           organization: Optional[pulumi.Input[str]] = None,
                           project: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetSentryIssueAlertResult]

func LookupSentryIssueAlert(ctx *Context, args *LookupSentryIssueAlertArgs, opts ...InvokeOption) (*LookupSentryIssueAlertResult, error)
func LookupSentryIssueAlertOutput(ctx *Context, args *LookupSentryIssueAlertOutputArgs, opts ...InvokeOption) LookupSentryIssueAlertResultOutput

public static class GetSentryIssueAlert 
{
    public static Task<GetSentryIssueAlertResult> InvokeAsync(GetSentryIssueAlertArgs args, InvokeOptions? opts = null)
    public static Output<GetSentryIssueAlertResult> Invoke(GetSentryIssueAlertInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSentryIssueAlertResult> getSentryIssueAlert(GetSentryIssueAlertArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: sentry:index/getSentryIssueAlert:getSentryIssueAlert
  arguments:
    # arguments dictionary