zpa.getCustomerVersionProfile

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

const _default = zpa.getCustomerVersionProfile({
    name: "Default",
});
const previousDefault = zpa.getCustomerVersionProfile({
    name: "Previous Default",
});
const newRelease = zpa.getCustomerVersionProfile({
    name: "New Release",
});

import pulumi
import pulumi_zpa as zpa

default = zpa.get_customer_version_profile(name="Default")
previous_default = zpa.get_customer_version_profile(name="Previous Default")
new_release = zpa.get_customer_version_profile(name="New Release")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := zpa.GetCustomerVersionProfile(ctx, &zpa.GetCustomerVersionProfileArgs{
			Name: "Default",
		}, nil)
		if err != nil {
			return err
		}
		_, err = zpa.GetCustomerVersionProfile(ctx, &zpa.GetCustomerVersionProfileArgs{
			Name: "Previous Default",
		}, nil)
		if err != nil {
			return err
		}
		_, err = zpa.GetCustomerVersionProfile(ctx, &zpa.GetCustomerVersionProfileArgs{
			Name: "New Release",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @default = Zpa.GetCustomerVersionProfile.Invoke(new()
    {
        Name = "Default",
    });

    var previousDefault = Zpa.GetCustomerVersionProfile.Invoke(new()
    {
        Name = "Previous Default",
    });

    var newRelease = Zpa.GetCustomerVersionProfile.Invoke(new()
    {
        Name = "New Release",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetCustomerVersionProfileArgs;
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 default = ZpaFunctions.getCustomerVersionProfile(GetCustomerVersionProfileArgs.builder()
            .name("Default")
            .build());

        final var previousDefault = ZpaFunctions.getCustomerVersionProfile(GetCustomerVersionProfileArgs.builder()
            .name("Previous Default")
            .build());

        final var newRelease = ZpaFunctions.getCustomerVersionProfile(GetCustomerVersionProfileArgs.builder()
            .name("New Release")
            .build());

    }
}

variables:
  default:
    fn::invoke:
      function: zpa:getCustomerVersionProfile
      arguments:
        name: Default
  previousDefault:
    fn::invoke:
      function: zpa:getCustomerVersionProfile
      arguments:
        name: Previous Default
  newRelease:
    fn::invoke:
      function: zpa:getCustomerVersionProfile
      arguments:
        name: New Release

function getCustomerVersionProfile(args: GetCustomerVersionProfileArgs, opts?: InvokeOptions): Promise<GetCustomerVersionProfileResult>
function getCustomerVersionProfileOutput(args: GetCustomerVersionProfileOutputArgs, opts?: InvokeOptions): Output<GetCustomerVersionProfileResult>

def get_customer_version_profile(name: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetCustomerVersionProfileResult
def get_customer_version_profile_output(name: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetCustomerVersionProfileResult]

func GetCustomerVersionProfile(ctx *Context, args *GetCustomerVersionProfileArgs, opts ...InvokeOption) (*GetCustomerVersionProfileResult, error)
func GetCustomerVersionProfileOutput(ctx *Context, args *GetCustomerVersionProfileOutputArgs, opts ...InvokeOption) GetCustomerVersionProfileResultOutput

public static class GetCustomerVersionProfile 
{
    public static Task<GetCustomerVersionProfileResult> InvokeAsync(GetCustomerVersionProfileArgs args, InvokeOptions? opts = null)
    public static Output<GetCustomerVersionProfileResult> Invoke(GetCustomerVersionProfileInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCustomerVersionProfileResult> getCustomerVersionProfile(GetCustomerVersionProfileArgs args, InvokeOptions options)
public static Output<GetCustomerVersionProfileResult> getCustomerVersionProfile(GetCustomerVersionProfileArgs args, InvokeOptions options)

fn::invoke:
  function: zpa:index/getCustomerVersionProfile:getCustomerVersionProfile
  arguments:
    # arguments dictionary