snowflake.getApiIntegrations

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

// Simple usage
const simple = snowflake.getApiIntegrations({});
export const simpleOutput = simple.then(simple => simple.apiIntegrations);
// Filtering (like)
const like = snowflake.getApiIntegrations({
    like: "api-integration-name",
});
export const likeOutput = like.then(like => like.apiIntegrations);
// Filtering by prefix (like)
const likePrefix = snowflake.getApiIntegrations({
    like: "prefix%",
});
export const likePrefixOutput = likePrefix.then(likePrefix => likePrefix.apiIntegrations);
// Without additional data (to limit the number of calls made for every found API integration)
const onlyShow = snowflake.getApiIntegrations({
    withDescribe: false,
});
export const onlyShowOutput = onlyShow.then(onlyShow => onlyShow.apiIntegrations);

import pulumi
import pulumi_snowflake as snowflake

# Simple usage
simple = snowflake.get_api_integrations()
pulumi.export("simpleOutput", simple.api_integrations)
# Filtering (like)
like = snowflake.get_api_integrations(like="api-integration-name")
pulumi.export("likeOutput", like.api_integrations)
# Filtering by prefix (like)
like_prefix = snowflake.get_api_integrations(like="prefix%")
pulumi.export("likePrefixOutput", like_prefix.api_integrations)
# Without additional data (to limit the number of calls made for every found API integration)
only_show = snowflake.get_api_integrations(with_describe=False)
pulumi.export("onlyShowOutput", only_show.api_integrations)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Simple usage
		simple, err := snowflake.GetApiIntegrations(ctx, &snowflake.GetApiIntegrationsArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleOutput", simple.ApiIntegrations)
		// Filtering (like)
		like, err := snowflake.GetApiIntegrations(ctx, &snowflake.GetApiIntegrationsArgs{
			Like: pulumi.StringRef("api-integration-name"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("likeOutput", like.ApiIntegrations)
		// Filtering by prefix (like)
		likePrefix, err := snowflake.GetApiIntegrations(ctx, &snowflake.GetApiIntegrationsArgs{
			Like: pulumi.StringRef("prefix%"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("likePrefixOutput", likePrefix.ApiIntegrations)
		// Without additional data (to limit the number of calls made for every found API integration)
		onlyShow, err := snowflake.GetApiIntegrations(ctx, &snowflake.GetApiIntegrationsArgs{
			WithDescribe: pulumi.BoolRef(false),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("onlyShowOutput", onlyShow.ApiIntegrations)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Simple usage
    var simple = Snowflake.GetApiIntegrations.Invoke();

    // Filtering (like)
    var like = Snowflake.GetApiIntegrations.Invoke(new()
    {
        Like = "api-integration-name",
    });

    // Filtering by prefix (like)
    var likePrefix = Snowflake.GetApiIntegrations.Invoke(new()
    {
        Like = "prefix%",
    });

    // Without additional data (to limit the number of calls made for every found API integration)
    var onlyShow = Snowflake.GetApiIntegrations.Invoke(new()
    {
        WithDescribe = false,
    });

    return new Dictionary<string, object?>
    {
        ["simpleOutput"] = simple.Apply(getApiIntegrationsResult => getApiIntegrationsResult.ApiIntegrations),
        ["likeOutput"] = like.Apply(getApiIntegrationsResult => getApiIntegrationsResult.ApiIntegrations),
        ["likePrefixOutput"] = likePrefix.Apply(getApiIntegrationsResult => getApiIntegrationsResult.ApiIntegrations),
        ["onlyShowOutput"] = onlyShow.Apply(getApiIntegrationsResult => getApiIntegrationsResult.ApiIntegrations),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.SnowflakeFunctions;
import com.pulumi.snowflake.inputs.GetApiIntegrationsArgs;
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) {
        // Simple usage
        final var simple = SnowflakeFunctions.getApiIntegrations(GetApiIntegrationsArgs.builder()
            .build());

        ctx.export("simpleOutput", simple.apiIntegrations());
        // Filtering (like)
        final var like = SnowflakeFunctions.getApiIntegrations(GetApiIntegrationsArgs.builder()
            .like("api-integration-name")
            .build());

        ctx.export("likeOutput", like.apiIntegrations());
        // Filtering by prefix (like)
        final var likePrefix = SnowflakeFunctions.getApiIntegrations(GetApiIntegrationsArgs.builder()
            .like("prefix%")
            .build());

        ctx.export("likePrefixOutput", likePrefix.apiIntegrations());
        // Without additional data (to limit the number of calls made for every found API integration)
        final var onlyShow = SnowflakeFunctions.getApiIntegrations(GetApiIntegrationsArgs.builder()
            .withDescribe(false)
            .build());

        ctx.export("onlyShowOutput", onlyShow.apiIntegrations());
    }
}

variables:
  # Simple usage
  simple:
    fn::invoke:
      function: snowflake:getApiIntegrations
      arguments: {}
  # Filtering (like)
  like:
    fn::invoke:
      function: snowflake:getApiIntegrations
      arguments:
        like: api-integration-name
  # Filtering by prefix (like)
  likePrefix:
    fn::invoke:
      function: snowflake:getApiIntegrations
      arguments:
        like: prefix%
  # Without additional data (to limit the number of calls made for every found API integration)
  onlyShow:
    fn::invoke:
      function: snowflake:getApiIntegrations
      arguments:
        withDescribe: false
outputs:
  simpleOutput: ${simple.apiIntegrations}
  likeOutput: ${like.apiIntegrations}
  likePrefixOutput: ${likePrefix.apiIntegrations}
  onlyShowOutput: ${onlyShow.apiIntegrations}

pulumi {
  required_providers {
    snowflake = {
      source = "pulumi/snowflake"
    }
  }
}

data "snowflake_getapiintegrations" "simple" {
}
data "snowflake_getapiintegrations" "like" {
  like = "api-integration-name"
}
data "snowflake_getapiintegrations" "likePrefix" {
  like = "prefix%"
}
data "snowflake_getapiintegrations" "onlyShow" {
  with_describe = false
}

# Simple usage
output "simpleOutput" {
  value = data.snowflake_getapiintegrations.simple.api_integrations
}
# Filtering (like)
output "likeOutput" {
  value = data.snowflake_getapiintegrations.like.api_integrations
}
# Filtering by prefix (like)
output "likePrefixOutput" {
  value = data.snowflake_getapiintegrations.likePrefix.api_integrations
}
# Without additional data (to limit the number of calls made for every found API integration)
# with_describe is turned on by default and it calls DESCRIBE API INTEGRATION for every integration found and attaches its output to api_integrations.*.describe_output field
output "onlyShowOutput" {
  value = data.snowflake_getapiintegrations.onlyShow.api_integrations
}

function getApiIntegrations(args: GetApiIntegrationsArgs, opts?: InvokeOptions): Promise<GetApiIntegrationsResult>
function getApiIntegrationsOutput(args: GetApiIntegrationsOutputArgs, opts?: InvokeOptions): Output<GetApiIntegrationsResult>

def get_api_integrations(like: Optional[str] = None,
                         with_describe: Optional[bool] = None,
                         opts: Optional[InvokeOptions] = None) -> GetApiIntegrationsResult
def get_api_integrations_output(like: pulumi.Input[Optional[str]] = None,
                         with_describe: pulumi.Input[Optional[bool]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetApiIntegrationsResult]

func GetApiIntegrations(ctx *Context, args *GetApiIntegrationsArgs, opts ...InvokeOption) (*GetApiIntegrationsResult, error)
func GetApiIntegrationsOutput(ctx *Context, args *GetApiIntegrationsOutputArgs, opts ...InvokeOption) GetApiIntegrationsResultOutput

public static class GetApiIntegrations 
{
    public static Task<GetApiIntegrationsResult> InvokeAsync(GetApiIntegrationsArgs args, InvokeOptions? opts = null)
    public static Output<GetApiIntegrationsResult> Invoke(GetApiIntegrationsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetApiIntegrationsResult> getApiIntegrations(GetApiIntegrationsArgs args, InvokeOptions options)
public static Output<GetApiIntegrationsResult> getApiIntegrations(GetApiIntegrationsArgs args, InvokeOptions options)

fn::invoke:
  function: snowflake:index/getApiIntegrations:getApiIntegrations
  arguments:
    # arguments dictionary

data "snowflake_get_api_integrations" "name" {
    # arguments
}