alicloud.ros.getStackInstances

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

const ids = alicloud.ros.getStackInstances({
    stackGroupName: "example_value",
    ids: [
        "example_value-1",
        "example_value-2",
    ],
    enableDetails: true,
});
export const rosStackInstanceId1 = ids.then(ids => ids.instances?.[0]?.id);
const status = alicloud.ros.getStackInstances({
    stackGroupName: "example_value",
    status: "CURRENT",
    enableDetails: true,
});
export const rosStackInstanceId2 = status.then(status => status.instances?.[0]?.id);
const regionId = alicloud.ros.getStackInstances({
    stackGroupName: "example_value",
    stackInstanceRegionId: "example_value",
    enableDetails: true,
});
export const rosStackInstanceId3 = regionId.then(regionId => regionId.instances?.[0]?.id);
const accountId = alicloud.ros.getStackInstances({
    stackGroupName: "example_value",
    stackInstanceAccountId: "example_value",
    enableDetails: true,
});
export const rosStackInstanceId4 = accountId.then(accountId => accountId.instances?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

ids = alicloud.ros.get_stack_instances(stack_group_name="example_value",
    ids=[
        "example_value-1",
        "example_value-2",
    ],
    enable_details=True)
pulumi.export("rosStackInstanceId1", ids.instances[0].id)
status = alicloud.ros.get_stack_instances(stack_group_name="example_value",
    status="CURRENT",
    enable_details=True)
pulumi.export("rosStackInstanceId2", status.instances[0].id)
region_id = alicloud.ros.get_stack_instances(stack_group_name="example_value",
    stack_instance_region_id="example_value",
    enable_details=True)
pulumi.export("rosStackInstanceId3", region_id.instances[0].id)
account_id = alicloud.ros.get_stack_instances(stack_group_name="example_value",
    stack_instance_account_id="example_value",
    enable_details=True)
pulumi.export("rosStackInstanceId4", account_id.instances[0].id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ids, err := ros.GetStackInstances(ctx, &ros.GetStackInstancesArgs{
			StackGroupName: "example_value",
			Ids: []string{
				"example_value-1",
				"example_value-2",
			},
			EnableDetails: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("rosStackInstanceId1", ids.Instances[0].Id)
		status, err := ros.GetStackInstances(ctx, &ros.GetStackInstancesArgs{
			StackGroupName: "example_value",
			Status:         pulumi.StringRef("CURRENT"),
			EnableDetails:  pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("rosStackInstanceId2", status.Instances[0].Id)
		regionId, err := ros.GetStackInstances(ctx, &ros.GetStackInstancesArgs{
			StackGroupName:        "example_value",
			StackInstanceRegionId: pulumi.StringRef("example_value"),
			EnableDetails:         pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("rosStackInstanceId3", regionId.Instances[0].Id)
		accountId, err := ros.GetStackInstances(ctx, &ros.GetStackInstancesArgs{
			StackGroupName:         "example_value",
			StackInstanceAccountId: pulumi.StringRef("example_value"),
			EnableDetails:          pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("rosStackInstanceId4", accountId.Instances[0].Id)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var ids = AliCloud.Ros.GetStackInstances.Invoke(new()
    {
        StackGroupName = "example_value",
        Ids = new[]
        {
            "example_value-1",
            "example_value-2",
        },
        EnableDetails = true,
    });

    var status = AliCloud.Ros.GetStackInstances.Invoke(new()
    {
        StackGroupName = "example_value",
        Status = "CURRENT",
        EnableDetails = true,
    });

    var regionId = AliCloud.Ros.GetStackInstances.Invoke(new()
    {
        StackGroupName = "example_value",
        StackInstanceRegionId = "example_value",
        EnableDetails = true,
    });

    var accountId = AliCloud.Ros.GetStackInstances.Invoke(new()
    {
        StackGroupName = "example_value",
        StackInstanceAccountId = "example_value",
        EnableDetails = true,
    });

    return new Dictionary<string, object?>
    {
        ["rosStackInstanceId1"] = ids.Apply(getStackInstancesResult => getStackInstancesResult.Instances[0]?.Id),
        ["rosStackInstanceId2"] = status.Apply(getStackInstancesResult => getStackInstancesResult.Instances[0]?.Id),
        ["rosStackInstanceId3"] = regionId.Apply(getStackInstancesResult => getStackInstancesResult.Instances[0]?.Id),
        ["rosStackInstanceId4"] = accountId.Apply(getStackInstancesResult => getStackInstancesResult.Instances[0]?.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.ros.RosFunctions;
import com.pulumi.alicloud.ros.inputs.GetStackInstancesArgs;
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 ids = RosFunctions.getStackInstances(GetStackInstancesArgs.builder()
            .stackGroupName("example_value")
            .ids(            
                "example_value-1",
                "example_value-2")
            .enableDetails(true)
            .build());

        ctx.export("rosStackInstanceId1", ids.applyValue(getStackInstancesResult -> getStackInstancesResult.instances()[0].id()));
        final var status = RosFunctions.getStackInstances(GetStackInstancesArgs.builder()
            .stackGroupName("example_value")
            .status("CURRENT")
            .enableDetails(true)
            .build());

        ctx.export("rosStackInstanceId2", status.applyValue(getStackInstancesResult -> getStackInstancesResult.instances()[0].id()));
        final var regionId = RosFunctions.getStackInstances(GetStackInstancesArgs.builder()
            .stackGroupName("example_value")
            .stackInstanceRegionId("example_value")
            .enableDetails(true)
            .build());

        ctx.export("rosStackInstanceId3", regionId.applyValue(getStackInstancesResult -> getStackInstancesResult.instances()[0].id()));
        final var accountId = RosFunctions.getStackInstances(GetStackInstancesArgs.builder()
            .stackGroupName("example_value")
            .stackInstanceAccountId("example_value")
            .enableDetails(true)
            .build());

        ctx.export("rosStackInstanceId4", accountId.applyValue(getStackInstancesResult -> getStackInstancesResult.instances()[0].id()));
    }
}

variables:
  ids:
    fn::invoke:
      Function: alicloud:ros:getStackInstances
      Arguments:
        stackGroupName: example_value
        ids:
          - example_value-1
          - example_value-2
        enableDetails: true
  status:
    fn::invoke:
      Function: alicloud:ros:getStackInstances
      Arguments:
        stackGroupName: example_value
        status: CURRENT
        enableDetails: true
  regionId:
    fn::invoke:
      Function: alicloud:ros:getStackInstances
      Arguments:
        stackGroupName: example_value
        stackInstanceRegionId: example_value
        enableDetails: true
  accountId:
    fn::invoke:
      Function: alicloud:ros:getStackInstances
      Arguments:
        stackGroupName: example_value
        stackInstanceAccountId: example_value
        enableDetails: true
outputs:
  rosStackInstanceId1: ${ids.instances[0].id}
  rosStackInstanceId2: ${status.instances[0].id}
  rosStackInstanceId3: ${regionId.instances[0].id}
  rosStackInstanceId4: ${accountId.instances[0].id}

function getStackInstances(args: GetStackInstancesArgs, opts?: InvokeOptions): Promise<GetStackInstancesResult>
function getStackInstancesOutput(args: GetStackInstancesOutputArgs, opts?: InvokeOptions): Output<GetStackInstancesResult>

def get_stack_instances(enable_details: Optional[bool] = None,
                        ids: Optional[Sequence[str]] = None,
                        output_file: Optional[str] = None,
                        stack_group_name: Optional[str] = None,
                        stack_instance_account_id: Optional[str] = None,
                        stack_instance_region_id: Optional[str] = None,
                        status: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetStackInstancesResult
def get_stack_instances_output(enable_details: Optional[pulumi.Input[bool]] = None,
                        ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                        output_file: Optional[pulumi.Input[str]] = None,
                        stack_group_name: Optional[pulumi.Input[str]] = None,
                        stack_instance_account_id: Optional[pulumi.Input[str]] = None,
                        stack_instance_region_id: Optional[pulumi.Input[str]] = None,
                        status: Optional[pulumi.Input[str]] = None,
                        opts: Optional[InvokeOptions] = None) -> Output[GetStackInstancesResult]

func GetStackInstances(ctx *Context, args *GetStackInstancesArgs, opts ...InvokeOption) (*GetStackInstancesResult, error)
func GetStackInstancesOutput(ctx *Context, args *GetStackInstancesOutputArgs, opts ...InvokeOption) GetStackInstancesResultOutput

public static class GetStackInstances 
{
    public static Task<GetStackInstancesResult> InvokeAsync(GetStackInstancesArgs args, InvokeOptions? opts = null)
    public static Output<GetStackInstancesResult> Invoke(GetStackInstancesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetStackInstancesResult> getStackInstances(GetStackInstancesArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: alicloud:ros/getStackInstances:getStackInstances
  arguments:
    # arguments dictionary