ibm.getDatabaseRemotes

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

const database = ibm.getDatabase({
    name: "mydatabase",
    location: "us-east",
});
const databaseRemotes = database.then(database => ibm.getDatabaseRemotes({
    deploymentId: database.id,
}));

import pulumi
import pulumi_ibm as ibm

database = ibm.get_database(name="mydatabase",
    location="us-east")
database_remotes = ibm.get_database_remotes(deployment_id=database.id)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/ibm/ibm"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		database, err := ibm.LookupDatabase(ctx, &ibm.LookupDatabaseArgs{
			Name:     "mydatabase",
			Location: pulumi.StringRef("us-east"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = ibm.GetDatabaseRemotes(ctx, &ibm.GetDatabaseRemotesArgs{
			DeploymentId: database.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var database = Ibm.GetDatabase.Invoke(new()
    {
        Name = "mydatabase",
        Location = "us-east",
    });

    var databaseRemotes = Ibm.GetDatabaseRemotes.Invoke(new()
    {
        DeploymentId = database.Apply(getDatabaseResult => getDatabaseResult.Id),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ibm.IbmFunctions;
import com.pulumi.ibm.inputs.GetDatabaseArgs;
import com.pulumi.ibm.inputs.GetDatabaseRemotesArgs;
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 database = IbmFunctions.getDatabase(GetDatabaseArgs.builder()
            .name("mydatabase")
            .location("us-east")
            .build());

        final var databaseRemotes = IbmFunctions.getDatabaseRemotes(GetDatabaseRemotesArgs.builder()
            .deploymentId(database.applyValue(getDatabaseResult -> getDatabaseResult.id()))
            .build());

    }
}

variables:
  database:
    fn::invoke:
      function: ibm:getDatabase
      arguments:
        name: mydatabase
        location: us-east
  databaseRemotes:
    fn::invoke:
      function: ibm:getDatabaseRemotes
      arguments:
        deploymentId: ${database.id}

function getDatabaseRemotes(args: GetDatabaseRemotesArgs, opts?: InvokeOptions): Promise<GetDatabaseRemotesResult>
function getDatabaseRemotesOutput(args: GetDatabaseRemotesOutputArgs, opts?: InvokeOptions): Output<GetDatabaseRemotesResult>

def get_database_remotes(deployment_id: Optional[str] = None,
                         id: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetDatabaseRemotesResult
def get_database_remotes_output(deployment_id: Optional[pulumi.Input[str]] = None,
                         id: Optional[pulumi.Input[str]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetDatabaseRemotesResult]

func GetDatabaseRemotes(ctx *Context, args *GetDatabaseRemotesArgs, opts ...InvokeOption) (*GetDatabaseRemotesResult, error)
func GetDatabaseRemotesOutput(ctx *Context, args *GetDatabaseRemotesOutputArgs, opts ...InvokeOption) GetDatabaseRemotesResultOutput

public static class GetDatabaseRemotes 
{
    public static Task<GetDatabaseRemotesResult> InvokeAsync(GetDatabaseRemotesArgs args, InvokeOptions? opts = null)
    public static Output<GetDatabaseRemotesResult> Invoke(GetDatabaseRemotesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDatabaseRemotesResult> getDatabaseRemotes(GetDatabaseRemotesArgs args, InvokeOptions options)
public static Output<GetDatabaseRemotesResult> getDatabaseRemotes(GetDatabaseRemotesArgs args, InvokeOptions options)

fn::invoke:
  function: ibm:index/getDatabaseRemotes:getDatabaseRemotes
  arguments:
    # arguments dictionary