harness.platform.getInfraProviderVersions

import * as pulumi from "@pulumi/pulumi";
import * as harness from "@pulumi/harness";
import * as std from "@pulumi/std";

const awsVersions = harness.platform.getInfraProviderVersions({
    account: "your-account-id",
    type: "aws",
});
export const allAwsVersions = awsVersions.then(awsVersions => awsVersions.versions);
const v6CompatibleVersions = Promise.all([awsVersions, std.contains({
    input: v.protocols,
    element: "6.0",
})]).then(([awsVersions, invoke]) => .filter(v => invoke.result).map(v => (v)));

import pulumi
import pulumi_harness as harness
import pulumi_std as std

aws_versions = harness.platform.get_infra_provider_versions(account="your-account-id",
    type="aws")
pulumi.export("allAwsVersions", aws_versions.versions)
v6_compatible_versions = [v for v in aws_versions.versions if std.contains(input=v.protocols,
    element="6.0").result]

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harness = Pulumi.Harness;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var awsVersions = Harness.Platform.GetInfraProviderVersions.Invoke(new()
    {
        Account = "your-account-id",
        Type = "aws",
    });

    var v6CompatibleVersions = Output.Tuple(awsVersions, Std.Contains.Invoke(new()
    {
        Input = v.Protocols,
        Element = "6.0",
    })).Apply(values =>
    {
        var awsVersions = values.Item1;
        var invoke = values.Item2;
        return ;
    });

    return new Dictionary<string, object?>
    {
        ["allAwsVersions"] = awsVersions.Apply(getInfraProviderVersionsResult => getInfraProviderVersionsResult.Versions),
    };
});

function getInfraProviderVersions(args: GetInfraProviderVersionsArgs, opts?: InvokeOptions): Promise<GetInfraProviderVersionsResult>
function getInfraProviderVersionsOutput(args: GetInfraProviderVersionsOutputArgs, opts?: InvokeOptions): Output<GetInfraProviderVersionsResult>

def get_infra_provider_versions(account: Optional[str] = None,
                                type: Optional[str] = None,
                                opts: Optional[InvokeOptions] = None) -> GetInfraProviderVersionsResult
def get_infra_provider_versions_output(account: Optional[pulumi.Input[str]] = None,
                                type: Optional[pulumi.Input[str]] = None,
                                opts: Optional[InvokeOptions] = None) -> Output[GetInfraProviderVersionsResult]

func GetInfraProviderVersions(ctx *Context, args *GetInfraProviderVersionsArgs, opts ...InvokeOption) (*GetInfraProviderVersionsResult, error)
func GetInfraProviderVersionsOutput(ctx *Context, args *GetInfraProviderVersionsOutputArgs, opts ...InvokeOption) GetInfraProviderVersionsResultOutput

public static class GetInfraProviderVersions 
{
    public static Task<GetInfraProviderVersionsResult> InvokeAsync(GetInfraProviderVersionsArgs args, InvokeOptions? opts = null)
    public static Output<GetInfraProviderVersionsResult> Invoke(GetInfraProviderVersionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetInfraProviderVersionsResult> getInfraProviderVersions(GetInfraProviderVersionsArgs args, InvokeOptions options)
public static Output<GetInfraProviderVersionsResult> getInfraProviderVersions(GetInfraProviderVersionsArgs args, InvokeOptions options)

fn::invoke:
  function: harness:platform/getInfraProviderVersions:getInfraProviderVersions
  arguments:
    # arguments dictionary