vercel.getSharedEnvironmentVariable

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

// Environment variables can be identified by their ID, or by their key and target.
// The ID can be taken from the network tab inside developer tools, while you are on the project page.
const example = vercel.getSharedEnvironmentVariable({
    id: "xxxxxxxxxxxxxxx",
});
// Alternatively, you can use the key and target to identify the environment variable.
// Note that all `target`s must be specified for a match to be found.
const exampleByKeyAndTarget = vercel.getSharedEnvironmentVariable({
    key: "MY_ENV_VAR",
    targets: [
        "production",
        "preview",
    ],
});

import pulumi
import pulumi_vercel as vercel

# Environment variables can be identified by their ID, or by their key and target.
# The ID can be taken from the network tab inside developer tools, while you are on the project page.
example = vercel.get_shared_environment_variable(id="xxxxxxxxxxxxxxx")
# Alternatively, you can use the key and target to identify the environment variable.
# Note that all `target`s must be specified for a match to be found.
example_by_key_and_target = vercel.get_shared_environment_variable(key="MY_ENV_VAR",
    targets=[
        "production",
        "preview",
    ])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Environment variables can be identified by their ID, or by their key and target.
		// The ID can be taken from the network tab inside developer tools, while you are on the project page.
		_, err := vercel.LookupSharedEnvironmentVariable(ctx, &vercel.LookupSharedEnvironmentVariableArgs{
			Id: pulumi.StringRef("xxxxxxxxxxxxxxx"),
		}, nil)
		if err != nil {
			return err
		}
		// Alternatively, you can use the key and target to identify the environment variable.
		// Note that all `target`s must be specified for a match to be found.
		_, err = vercel.LookupSharedEnvironmentVariable(ctx, &vercel.LookupSharedEnvironmentVariableArgs{
			Key: pulumi.StringRef("MY_ENV_VAR"),
			Targets: []string{
				"production",
				"preview",
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Environment variables can be identified by their ID, or by their key and target.
    // The ID can be taken from the network tab inside developer tools, while you are on the project page.
    var example = Vercel.GetSharedEnvironmentVariable.Invoke(new()
    {
        Id = "xxxxxxxxxxxxxxx",
    });

    // Alternatively, you can use the key and target to identify the environment variable.
    // Note that all `target`s must be specified for a match to be found.
    var exampleByKeyAndTarget = Vercel.GetSharedEnvironmentVariable.Invoke(new()
    {
        Key = "MY_ENV_VAR",
        Targets = new[]
        {
            "production",
            "preview",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vercel.VercelFunctions;
import com.pulumi.vercel.inputs.GetSharedEnvironmentVariableArgs;
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) {
        // Environment variables can be identified by their ID, or by their key and target.
        // The ID can be taken from the network tab inside developer tools, while you are on the project page.
        final var example = VercelFunctions.getSharedEnvironmentVariable(GetSharedEnvironmentVariableArgs.builder()
            .id("xxxxxxxxxxxxxxx")
            .build());

        // Alternatively, you can use the key and target to identify the environment variable.
        // Note that all `target`s must be specified for a match to be found.
        final var exampleByKeyAndTarget = VercelFunctions.getSharedEnvironmentVariable(GetSharedEnvironmentVariableArgs.builder()
            .key("MY_ENV_VAR")
            .targets(            
                "production",
                "preview")
            .build());

    }
}

variables:
  # Environment variables can be identified by their ID, or by their key and target.
  # The ID can be taken from the network tab inside developer tools, while you are on the project page.
  example:
    fn::invoke:
      Function: vercel:getSharedEnvironmentVariable
      Arguments:
        id: xxxxxxxxxxxxxxx
  # Alternatively, you can use the key and target to identify the environment variable.
  # Note that all `target`s must be specified for a match to be found.
  exampleByKeyAndTarget:
    fn::invoke:
      Function: vercel:getSharedEnvironmentVariable
      Arguments:
        key: MY_ENV_VAR
        targets:
          - production
          - preview

function getSharedEnvironmentVariable(args: GetSharedEnvironmentVariableArgs, opts?: InvokeOptions): Promise<GetSharedEnvironmentVariableResult>
function getSharedEnvironmentVariableOutput(args: GetSharedEnvironmentVariableOutputArgs, opts?: InvokeOptions): Output<GetSharedEnvironmentVariableResult>

def get_shared_environment_variable(id: Optional[str] = None,
                                    key: Optional[str] = None,
                                    targets: Optional[Sequence[str]] = None,
                                    team_id: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetSharedEnvironmentVariableResult
def get_shared_environment_variable_output(id: Optional[pulumi.Input[str]] = None,
                                    key: Optional[pulumi.Input[str]] = None,
                                    targets: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                                    team_id: Optional[pulumi.Input[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetSharedEnvironmentVariableResult]

func LookupSharedEnvironmentVariable(ctx *Context, args *LookupSharedEnvironmentVariableArgs, opts ...InvokeOption) (*LookupSharedEnvironmentVariableResult, error)
func LookupSharedEnvironmentVariableOutput(ctx *Context, args *LookupSharedEnvironmentVariableOutputArgs, opts ...InvokeOption) LookupSharedEnvironmentVariableResultOutput

public static class GetSharedEnvironmentVariable 
{
    public static Task<GetSharedEnvironmentVariableResult> InvokeAsync(GetSharedEnvironmentVariableArgs args, InvokeOptions? opts = null)
    public static Output<GetSharedEnvironmentVariableResult> Invoke(GetSharedEnvironmentVariableInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSharedEnvironmentVariableResult> getSharedEnvironmentVariable(GetSharedEnvironmentVariableArgs args, InvokeOptions options)
public static Output<GetSharedEnvironmentVariableResult> getSharedEnvironmentVariable(GetSharedEnvironmentVariableArgs args, InvokeOptions options)

fn::invoke:
  function: vercel:index/getSharedEnvironmentVariable:getSharedEnvironmentVariable
  arguments:
    # arguments dictionary