snowflake.getConnections

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

// Simple usage
const simple = snowflake.getConnections({});
export const simpleOutput = simple.then(simple => simple.connections);
// Filtering (like)
const like = snowflake.getConnections({
    like: "connection-name",
});
export const likeOutput = like.then(like => like.connections);
// Filtering by prefix (like)
const likePrefix = snowflake.getConnections({
    like: "prefix%",
});
export const likePrefixOutput = likePrefix.then(likePrefix => likePrefix.connections);

import pulumi
import pulumi_snowflake as snowflake

# Simple usage
simple = snowflake.get_connections()
pulumi.export("simpleOutput", simple.connections)
# Filtering (like)
like = snowflake.get_connections(like="connection-name")
pulumi.export("likeOutput", like.connections)
# Filtering by prefix (like)
like_prefix = snowflake.get_connections(like="prefix%")
pulumi.export("likePrefixOutput", like_prefix.connections)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Simple usage
		simple, err := snowflake.GetConnections(ctx, &snowflake.GetConnectionsArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("simpleOutput", simple.Connections)
		// Filtering (like)
		like, err := snowflake.GetConnections(ctx, &snowflake.GetConnectionsArgs{
			Like: pulumi.StringRef("connection-name"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("likeOutput", like.Connections)
		// Filtering by prefix (like)
		likePrefix, err := snowflake.GetConnections(ctx, &snowflake.GetConnectionsArgs{
			Like: pulumi.StringRef("prefix%"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("likePrefixOutput", likePrefix.Connections)
		return nil
	})
}

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

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

    // Filtering (like)
    var like = Snowflake.GetConnections.Invoke(new()
    {
        Like = "connection-name",
    });

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

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

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.GetConnectionsArgs;
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) {
        // Simple usage
        final var simple = SnowflakeFunctions.getConnections();

        ctx.export("simpleOutput", simple.applyValue(getConnectionsResult -> getConnectionsResult.connections()));
        // Filtering (like)
        final var like = SnowflakeFunctions.getConnections(GetConnectionsArgs.builder()
            .like("connection-name")
            .build());

        ctx.export("likeOutput", like.applyValue(getConnectionsResult -> getConnectionsResult.connections()));
        // Filtering by prefix (like)
        final var likePrefix = SnowflakeFunctions.getConnections(GetConnectionsArgs.builder()
            .like("prefix%")
            .build());

        ctx.export("likePrefixOutput", likePrefix.applyValue(getConnectionsResult -> getConnectionsResult.connections()));
    }
}

variables:
  # Simple usage
  simple:
    fn::invoke:
      Function: snowflake:getConnections
      Arguments: {}
  # Filtering (like)
  like:
    fn::invoke:
      Function: snowflake:getConnections
      Arguments:
        like: connection-name
  # Filtering by prefix (like)
  likePrefix:
    fn::invoke:
      Function: snowflake:getConnections
      Arguments:
        like: prefix%
outputs:
  simpleOutput: ${simple.connections}
  likeOutput: ${like.connections}
  likePrefixOutput: ${likePrefix.connections}

function getConnections(args: GetConnectionsArgs, opts?: InvokeOptions): Promise<GetConnectionsResult>
function getConnectionsOutput(args: GetConnectionsOutputArgs, opts?: InvokeOptions): Output<GetConnectionsResult>

def get_connections(like: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetConnectionsResult
def get_connections_output(like: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetConnectionsResult]

func GetConnections(ctx *Context, args *GetConnectionsArgs, opts ...InvokeOption) (*GetConnectionsResult, error)
func GetConnectionsOutput(ctx *Context, args *GetConnectionsOutputArgs, opts ...InvokeOption) GetConnectionsResultOutput

public static class GetConnections 
{
    public static Task<GetConnectionsResult> InvokeAsync(GetConnectionsArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectionsResult> Invoke(GetConnectionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetConnectionsResult> getConnections(GetConnectionsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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