confluentcloud.getConnectArtifact

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

const example = confluentcloud.getConnectArtifact({
    id: "ca-123456",
    environment: {
        id: "env-123456",
    },
    cloud: "AWS",
});
export const artifactName = example.then(example => example.displayName);
export const artifactCloud = example.then(example => example.cloud);
export const artifactContentFormat = example.then(example => example.contentFormat);
export const artifactDescription = example.then(example => example.description);

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.get_connect_artifact(id="ca-123456",
    environment={
        "id": "env-123456",
    },
    cloud="AWS")
pulumi.export("artifactName", example.display_name)
pulumi.export("artifactCloud", example.cloud)
pulumi.export("artifactContentFormat", example.content_format)
pulumi.export("artifactDescription", example.description)

package main

import (
	"github.com/pulumi/pulumi-confluentcloud/sdk/v2/go/confluentcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := confluentcloud.LookupConnectArtifact(ctx, &confluentcloud.LookupConnectArtifactArgs{
			Id: "ca-123456",
			Environment: confluentcloud.GetConnectArtifactEnvironment{
				Id: "env-123456",
			},
			Cloud: "AWS",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("artifactName", example.DisplayName)
		ctx.Export("artifactCloud", example.Cloud)
		ctx.Export("artifactContentFormat", example.ContentFormat)
		ctx.Export("artifactDescription", example.Description)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ConfluentCloud.GetConnectArtifact.Invoke(new()
    {
        Id = "ca-123456",
        Environment = new ConfluentCloud.Inputs.GetConnectArtifactEnvironmentInputArgs
        {
            Id = "env-123456",
        },
        Cloud = "AWS",
    });

    return new Dictionary<string, object?>
    {
        ["artifactName"] = example.Apply(getConnectArtifactResult => getConnectArtifactResult.DisplayName),
        ["artifactCloud"] = example.Apply(getConnectArtifactResult => getConnectArtifactResult.Cloud),
        ["artifactContentFormat"] = example.Apply(getConnectArtifactResult => getConnectArtifactResult.ContentFormat),
        ["artifactDescription"] = example.Apply(getConnectArtifactResult => getConnectArtifactResult.Description),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.confluentcloud.ConfluentcloudFunctions;
import com.pulumi.confluentcloud.inputs.GetConnectArtifactArgs;
import com.pulumi.confluentcloud.inputs.GetConnectArtifactEnvironmentArgs;
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) {
        final var example = ConfluentcloudFunctions.getConnectArtifact(GetConnectArtifactArgs.builder()
            .id("ca-123456")
            .environment(GetConnectArtifactEnvironmentArgs.builder()
                .id("env-123456")
                .build())
            .cloud("AWS")
            .build());

        ctx.export("artifactName", example.displayName());
        ctx.export("artifactCloud", example.cloud());
        ctx.export("artifactContentFormat", example.contentFormat());
        ctx.export("artifactDescription", example.description());
    }
}

variables:
  example:
    fn::invoke:
      function: confluentcloud:getConnectArtifact
      arguments:
        id: ca-123456
        environment:
          id: env-123456
        cloud: AWS
outputs:
  artifactName: ${example.displayName}
  artifactCloud: ${example.cloud}
  artifactContentFormat: ${example.contentFormat}
  artifactDescription: ${example.description}

function getConnectArtifact(args: GetConnectArtifactArgs, opts?: InvokeOptions): Promise<GetConnectArtifactResult>
function getConnectArtifactOutput(args: GetConnectArtifactOutputArgs, opts?: InvokeOptions): Output<GetConnectArtifactResult>

def get_connect_artifact(cloud: Optional[str] = None,
                         environment: Optional[GetConnectArtifactEnvironment] = None,
                         id: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetConnectArtifactResult
def get_connect_artifact_output(cloud: Optional[pulumi.Input[str]] = None,
                         environment: Optional[pulumi.Input[GetConnectArtifactEnvironmentArgs]] = None,
                         id: Optional[pulumi.Input[str]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetConnectArtifactResult]

func LookupConnectArtifact(ctx *Context, args *LookupConnectArtifactArgs, opts ...InvokeOption) (*LookupConnectArtifactResult, error)
func LookupConnectArtifactOutput(ctx *Context, args *LookupConnectArtifactOutputArgs, opts ...InvokeOption) LookupConnectArtifactResultOutput

public static class GetConnectArtifact 
{
    public static Task<GetConnectArtifactResult> InvokeAsync(GetConnectArtifactArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectArtifactResult> Invoke(GetConnectArtifactInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetConnectArtifactResult> getConnectArtifact(GetConnectArtifactArgs args, InvokeOptions options)
public static Output<GetConnectArtifactResult> getConnectArtifact(GetConnectArtifactArgs args, InvokeOptions options)

fn::invoke:
  function: confluentcloud:index/getConnectArtifact:getConnectArtifact
  arguments:
    # arguments dictionary