mongodbatlas.getOrgLogIntegration

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

const example = mongodbatlas.getOrgLogIntegration({
    orgId: exampleMongodbatlasOrgLogIntegration.orgId,
    integrationId: exampleMongodbatlasOrgLogIntegration.integrationId,
});
export const orgLogIntegrationType = example.then(example => example.type);

import pulumi
import pulumi_mongodbatlas as mongodbatlas

example = mongodbatlas.get_org_log_integration(org_id=example_mongodbatlas_org_log_integration["orgId"],
    integration_id=example_mongodbatlas_org_log_integration["integrationId"])
pulumi.export("orgLogIntegrationType", example.type)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := mongodbatlas.GetOrgLogIntegration(ctx, &mongodbatlas.LookupOrgLogIntegrationArgs{
			OrgId:         exampleMongodbatlasOrgLogIntegration.OrgId,
			IntegrationId: exampleMongodbatlasOrgLogIntegration.IntegrationId,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("orgLogIntegrationType", example.Type)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Mongodbatlas.GetOrgLogIntegration.Invoke(new()
    {
        OrgId = exampleMongodbatlasOrgLogIntegration.OrgId,
        IntegrationId = exampleMongodbatlasOrgLogIntegration.IntegrationId,
    });

    return new Dictionary<string, object?>
    {
        ["orgLogIntegrationType"] = example.Apply(getOrgLogIntegrationResult => getOrgLogIntegrationResult.Type),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.mongodbatlas.MongodbatlasFunctions;
import com.pulumi.mongodbatlas.inputs.GetOrgLogIntegrationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 example = MongodbatlasFunctions.getOrgLogIntegration(GetOrgLogIntegrationArgs.builder()
            .orgId(exampleMongodbatlasOrgLogIntegration.get("orgId"))
            .integrationId(exampleMongodbatlasOrgLogIntegration.get("integrationId"))
            .build());

        ctx.export("orgLogIntegrationType", example.type());
    }
}

variables:
  example:
    fn::invoke:
      function: mongodbatlas:getOrgLogIntegration
      arguments:
        orgId: ${exampleMongodbatlasOrgLogIntegration.orgId}
        integrationId: ${exampleMongodbatlasOrgLogIntegration.integrationId}
outputs:
  orgLogIntegrationType: ${example.type}

terraform {
  required_providers {
    mongodbatlas = {
      source = "pulumi/mongodbatlas"
    }
  }
}

data "mongodbatlas_org_log_integration" "example" {
  org_id         = exampleMongodbatlasOrgLogIntegration.orgId
  integration_id = exampleMongodbatlasOrgLogIntegration.integrationId
}

output "orgLogIntegrationType" {
  value = data.mongodbatlas_org_log_integration.example.type
}

function getOrgLogIntegration(args: GetOrgLogIntegrationArgs, opts?: InvokeOptions): Promise<GetOrgLogIntegrationResult>
function getOrgLogIntegrationOutput(args: GetOrgLogIntegrationOutputArgs, opts?: InvokeOutputOptions): Output<GetOrgLogIntegrationResult>

def get_org_log_integration(integration_id: Optional[str] = None,
                            org_id: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetOrgLogIntegrationResult
def get_org_log_integration_output(integration_id: pulumi.Input[Optional[str]] = None,
                            org_id: pulumi.Input[Optional[str]] = None,
                            opts: Optional[InvokeOutputOptions] = None) -> Output[GetOrgLogIntegrationResult]

func LookupOrgLogIntegration(ctx *Context, args *LookupOrgLogIntegrationArgs, opts ...InvokeOption) (*LookupOrgLogIntegrationResult, error)
func LookupOrgLogIntegrationOutput(ctx *Context, args *LookupOrgLogIntegrationOutputArgs, opts ...InvokeOption) LookupOrgLogIntegrationResultOutput

public static class GetOrgLogIntegration 
{
    public static Task<GetOrgLogIntegrationResult> InvokeAsync(GetOrgLogIntegrationArgs args, InvokeOptions? opts = null)
    public static Output<GetOrgLogIntegrationResult> Invoke(GetOrgLogIntegrationInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetOrgLogIntegrationResult> Invoke(GetOrgLogIntegrationInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetOrgLogIntegrationResult> getOrgLogIntegration(GetOrgLogIntegrationArgs args, InvokeOptions options)
public static Output<GetOrgLogIntegrationResult> getOrgLogIntegration(GetOrgLogIntegrationArgs args, InvokeOptions options)
public static Output<GetOrgLogIntegrationResult> getOrgLogIntegration(GetOrgLogIntegrationArgs args, InvokeOutputOptions options)

fn::invoke:
  function: mongodbatlas:index/getOrgLogIntegration:getOrgLogIntegration
  arguments:
    # arguments dictionary

data "mongodbatlas_get_org_log_integration" "name" {
    # arguments
}