confluentcloud.getCatalogIntegration

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

export = async () => {
    const example = await confluentcloud.getCatalogIntegration({
        environment: {
            id: staging.id,
        },
        kafkaCluster: {
            id: stagingConfluentKafkaCluster.id,
        },
        id: "tci-abc123",
        credentials: {
            key: env_admin_tableflow_api_key.id,
            secret: env_admin_tableflow_api_key.secret,
        },
    });
    return {
        "retention-ms": example.retentionMs,
    };
}

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.get_catalog_integration(environment={
        "id": staging["id"],
    },
    kafka_cluster={
        "id": staging_confluent_kafka_cluster["id"],
    },
    id="tci-abc123",
    credentials={
        "key": env_admin_tableflow_api_key["id"],
        "secret": env_admin_tableflow_api_key["secret"],
    })
pulumi.export("retention-ms", example.retention_ms)

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.LookupCatalogIntegration(ctx, &confluentcloud.LookupCatalogIntegrationArgs{
			Environment: confluentcloud.GetCatalogIntegrationEnvironment{
				Id: staging.Id,
			},
			KafkaCluster: confluentcloud.GetCatalogIntegrationKafkaCluster{
				Id: stagingConfluentKafkaCluster.Id,
			},
			Id: "tci-abc123",
			Credentials: confluentcloud.GetCatalogIntegrationCredentials{
				Key:    env_admin_tableflow_api_key.Id,
				Secret: env_admin_tableflow_api_key.Secret,
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("retention-ms", example.RetentionMs)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ConfluentCloud.GetCatalogIntegration.Invoke(new()
    {
        Environment = new ConfluentCloud.Inputs.GetCatalogIntegrationEnvironmentInputArgs
        {
            Id = staging.Id,
        },
        KafkaCluster = new ConfluentCloud.Inputs.GetCatalogIntegrationKafkaClusterInputArgs
        {
            Id = stagingConfluentKafkaCluster.Id,
        },
        Id = "tci-abc123",
        Credentials = new ConfluentCloud.Inputs.GetCatalogIntegrationCredentialsInputArgs
        {
            Key = env_admin_tableflow_api_key.Id,
            Secret = env_admin_tableflow_api_key.Secret,
        },
    });

    return new Dictionary<string, object?>
    {
        ["retention-ms"] = example.Apply(getCatalogIntegrationResult => getCatalogIntegrationResult.RetentionMs),
    };
});

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.GetCatalogIntegrationArgs;
import com.pulumi.confluentcloud.inputs.GetCatalogIntegrationEnvironmentArgs;
import com.pulumi.confluentcloud.inputs.GetCatalogIntegrationKafkaClusterArgs;
import com.pulumi.confluentcloud.inputs.GetCatalogIntegrationCredentialsArgs;
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.getCatalogIntegration(GetCatalogIntegrationArgs.builder()
            .environment(GetCatalogIntegrationEnvironmentArgs.builder()
                .id(staging.id())
                .build())
            .kafkaCluster(GetCatalogIntegrationKafkaClusterArgs.builder()
                .id(stagingConfluentKafkaCluster.id())
                .build())
            .id("tci-abc123")
            .credentials(GetCatalogIntegrationCredentialsArgs.builder()
                .key(env_admin_tableflow_api_key.id())
                .secret(env_admin_tableflow_api_key.secret())
                .build())
            .build());

        ctx.export("retention-ms", example.retentionMs());
    }
}

variables:
  example:
    fn::invoke:
      function: confluentcloud:getCatalogIntegration
      arguments:
        environment:
          id: ${staging.id}
        kafkaCluster:
          id: ${stagingConfluentKafkaCluster.id}
        id: tci-abc123
        credentials:
          key: ${["env-admin-tableflow-api-key"].id}
          secret: ${["env-admin-tableflow-api-key"].secret}
outputs:
  retention-ms: ${example.retentionMs}

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

export = async () => {
    const example = await confluentcloud.getCatalogIntegration({
        id: "tci-abc123",
    });
    return {
        "retention-ms": example.retentionMs,
    };
}

import pulumi
import pulumi_confluentcloud as confluentcloud

example = confluentcloud.get_catalog_integration(id="tci-abc123")
pulumi.export("retention-ms", example.retention_ms)

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.LookupCatalogIntegration(ctx, &confluentcloud.LookupCatalogIntegrationArgs{
			Id: "tci-abc123",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("retention-ms", example.RetentionMs)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ConfluentCloud.GetCatalogIntegration.Invoke(new()
    {
        Id = "tci-abc123",
    });

    return new Dictionary<string, object?>
    {
        ["retention-ms"] = example.Apply(getCatalogIntegrationResult => getCatalogIntegrationResult.RetentionMs),
    };
});

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.GetCatalogIntegrationArgs;
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.getCatalogIntegration(GetCatalogIntegrationArgs.builder()
            .id("tci-abc123")
            .build());

        ctx.export("retention-ms", example.retentionMs());
    }
}

variables:
  example:
    fn::invoke:
      function: confluentcloud:getCatalogIntegration
      arguments:
        id: tci-abc123
outputs:
  retention-ms: ${example.retentionMs}

function getCatalogIntegration(args: GetCatalogIntegrationArgs, opts?: InvokeOptions): Promise<GetCatalogIntegrationResult>
function getCatalogIntegrationOutput(args: GetCatalogIntegrationOutputArgs, opts?: InvokeOptions): Output<GetCatalogIntegrationResult>

def get_catalog_integration(credentials: Optional[GetCatalogIntegrationCredentials] = None,
                            environment: Optional[GetCatalogIntegrationEnvironment] = None,
                            id: Optional[str] = None,
                            kafka_cluster: Optional[GetCatalogIntegrationKafkaCluster] = None,
                            opts: Optional[InvokeOptions] = None) -> GetCatalogIntegrationResult
def get_catalog_integration_output(credentials: Optional[pulumi.Input[GetCatalogIntegrationCredentialsArgs]] = None,
                            environment: Optional[pulumi.Input[GetCatalogIntegrationEnvironmentArgs]] = None,
                            id: Optional[pulumi.Input[str]] = None,
                            kafka_cluster: Optional[pulumi.Input[GetCatalogIntegrationKafkaClusterArgs]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetCatalogIntegrationResult]

func LookupCatalogIntegration(ctx *Context, args *LookupCatalogIntegrationArgs, opts ...InvokeOption) (*LookupCatalogIntegrationResult, error)
func LookupCatalogIntegrationOutput(ctx *Context, args *LookupCatalogIntegrationOutputArgs, opts ...InvokeOption) LookupCatalogIntegrationResultOutput

public static class GetCatalogIntegration 
{
    public static Task<GetCatalogIntegrationResult> InvokeAsync(GetCatalogIntegrationArgs args, InvokeOptions? opts = null)
    public static Output<GetCatalogIntegrationResult> Invoke(GetCatalogIntegrationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCatalogIntegrationResult> getCatalogIntegration(GetCatalogIntegrationArgs args, InvokeOptions options)
public static Output<GetCatalogIntegrationResult> getCatalogIntegration(GetCatalogIntegrationArgs args, InvokeOptions options)

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