sentry.getSentryOrganizationIntegration

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

// Retrieve a Github organization integration
const github = sentry.getSentryOrganizationIntegration({
    organization: "my-organization",
    providerKey: "github",
    name: "my-github-organization",
});
// Retrieve a Slack integration
const slack = sentry.getSentryOrganizationIntegration({
    organization: "my-organization",
    providerKey: "slack",
    name: "Slack Workspace",
});

import pulumi
import pulumi_sentry as sentry

# Retrieve a Github organization integration
github = sentry.get_sentry_organization_integration(organization="my-organization",
    provider_key="github",
    name="my-github-organization")
# Retrieve a Slack integration
slack = sentry.get_sentry_organization_integration(organization="my-organization",
    provider_key="slack",
    name="Slack Workspace")

package main

import (
	"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 a Github organization integration
		_, err := sentry.GetSentryOrganizationIntegration(ctx, &sentry.GetSentryOrganizationIntegrationArgs{
			Organization: "my-organization",
			ProviderKey:  "github",
			Name:         "my-github-organization",
		}, nil)
		if err != nil {
			return err
		}
		// Retrieve a Slack integration
		_, err = sentry.GetSentryOrganizationIntegration(ctx, &sentry.GetSentryOrganizationIntegrationArgs{
			Organization: "my-organization",
			ProviderKey:  "slack",
			Name:         "Slack Workspace",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Retrieve a Github organization integration
    var github = Sentry.GetSentryOrganizationIntegration.Invoke(new()
    {
        Organization = "my-organization",
        ProviderKey = "github",
        Name = "my-github-organization",
    });

    // Retrieve a Slack integration
    var slack = Sentry.GetSentryOrganizationIntegration.Invoke(new()
    {
        Organization = "my-organization",
        ProviderKey = "slack",
        Name = "Slack Workspace",
    });

});

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.GetSentryOrganizationIntegrationArgs;
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 a Github organization integration
        final var github = SentryFunctions.getSentryOrganizationIntegration(GetSentryOrganizationIntegrationArgs.builder()
            .organization("my-organization")
            .providerKey("github")
            .name("my-github-organization")
            .build());

        // Retrieve a Slack integration
        final var slack = SentryFunctions.getSentryOrganizationIntegration(GetSentryOrganizationIntegrationArgs.builder()
            .organization("my-organization")
            .providerKey("slack")
            .name("Slack Workspace")
            .build());

    }
}

variables:
  # Retrieve a Github organization integration
  github:
    fn::invoke:
      Function: sentry:getSentryOrganizationIntegration
      Arguments:
        organization: my-organization
        providerKey: github
        name: my-github-organization
  # Retrieve a Slack integration
  slack:
    fn::invoke:
      Function: sentry:getSentryOrganizationIntegration
      Arguments:
        organization: my-organization
        providerKey: slack
        name: Slack Workspace

function getSentryOrganizationIntegration(args: GetSentryOrganizationIntegrationArgs, opts?: InvokeOptions): Promise<GetSentryOrganizationIntegrationResult>
function getSentryOrganizationIntegrationOutput(args: GetSentryOrganizationIntegrationOutputArgs, opts?: InvokeOptions): Output<GetSentryOrganizationIntegrationResult>

def get_sentry_organization_integration(name: Optional[str] = None,
                                        organization: Optional[str] = None,
                                        provider_key: Optional[str] = None,
                                        opts: Optional[InvokeOptions] = None) -> GetSentryOrganizationIntegrationResult
def get_sentry_organization_integration_output(name: Optional[pulumi.Input[str]] = None,
                                        organization: Optional[pulumi.Input[str]] = None,
                                        provider_key: Optional[pulumi.Input[str]] = None,
                                        opts: Optional[InvokeOptions] = None) -> Output[GetSentryOrganizationIntegrationResult]

func GetSentryOrganizationIntegration(ctx *Context, args *GetSentryOrganizationIntegrationArgs, opts ...InvokeOption) (*GetSentryOrganizationIntegrationResult, error)
func GetSentryOrganizationIntegrationOutput(ctx *Context, args *GetSentryOrganizationIntegrationOutputArgs, opts ...InvokeOption) GetSentryOrganizationIntegrationResultOutput

public static class GetSentryOrganizationIntegration 
{
    public static Task<GetSentryOrganizationIntegrationResult> InvokeAsync(GetSentryOrganizationIntegrationArgs args, InvokeOptions? opts = null)
    public static Output<GetSentryOrganizationIntegrationResult> Invoke(GetSentryOrganizationIntegrationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSentryOrganizationIntegrationResult> getSentryOrganizationIntegration(GetSentryOrganizationIntegrationArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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