hsdp.getCdrOrg

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

const sandbox = hsdp.getCdrFhirStore({
    baseUrl: "https://cdr-stu3-sandbox.hsdp.io",
    fhirOrgId: _var.root_org_id,
});
const hospital = sandbox.then(sandbox => hsdp.getCdrOrg({
    fhirStore: sandbox.endpoint,
    orgId: _var.sub_org_id,
    version: "r4",
}));
export const cdrOrgName = hospital.then(hospital => hospital.name);

import pulumi
import pulumi_hsdp as hsdp

sandbox = hsdp.get_cdr_fhir_store(base_url="https://cdr-stu3-sandbox.hsdp.io",
    fhir_org_id=var["root_org_id"])
hospital = hsdp.get_cdr_org(fhir_store=sandbox.endpoint,
    org_id=var["sub_org_id"],
    version="r4")
pulumi.export("cdrOrgName", hospital.name)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		sandbox, err := hsdp.GetCdrFhirStore(ctx, &hsdp.GetCdrFhirStoreArgs{
			BaseUrl:   "https://cdr-stu3-sandbox.hsdp.io",
			FhirOrgId: _var.Root_org_id,
		}, nil)
		if err != nil {
			return err
		}
		hospital, err := hsdp.LookupCdrOrg(ctx, &hsdp.LookupCdrOrgArgs{
			FhirStore: sandbox.Endpoint,
			OrgId:     _var.Sub_org_id,
			Version:   pulumi.StringRef("r4"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("cdrOrgName", hospital.Name)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var sandbox = Hsdp.GetCdrFhirStore.Invoke(new()
    {
        BaseUrl = "https://cdr-stu3-sandbox.hsdp.io",
        FhirOrgId = @var.Root_org_id,
    });

    var hospital = Hsdp.GetCdrOrg.Invoke(new()
    {
        FhirStore = sandbox.Apply(getCdrFhirStoreResult => getCdrFhirStoreResult.Endpoint),
        OrgId = @var.Sub_org_id,
        Version = "r4",
    });

    return new Dictionary<string, object?>
    {
        ["cdrOrgName"] = hospital.Apply(getCdrOrgResult => getCdrOrgResult.Name),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hsdp.HsdpFunctions;
import com.pulumi.hsdp.inputs.GetCdrFhirStoreArgs;
import com.pulumi.hsdp.inputs.GetCdrOrgArgs;
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 sandbox = HsdpFunctions.getCdrFhirStore(GetCdrFhirStoreArgs.builder()
            .baseUrl("https://cdr-stu3-sandbox.hsdp.io")
            .fhirOrgId(var_.root_org_id())
            .build());

        final var hospital = HsdpFunctions.getCdrOrg(GetCdrOrgArgs.builder()
            .fhirStore(sandbox.applyValue(getCdrFhirStoreResult -> getCdrFhirStoreResult.endpoint()))
            .orgId(var_.sub_org_id())
            .version("r4")
            .build());

        ctx.export("cdrOrgName", hospital.applyValue(getCdrOrgResult -> getCdrOrgResult.name()));
    }
}

variables:
  sandbox:
    fn::invoke:
      function: hsdp:getCdrFhirStore
      arguments:
        baseUrl: https://cdr-stu3-sandbox.hsdp.io
        fhirOrgId: ${var.root_org_id}
  hospital:
    fn::invoke:
      function: hsdp:getCdrOrg
      arguments:
        fhirStore: ${sandbox.endpoint}
        orgId: ${var.sub_org_id}
        version: r4
outputs:
  cdrOrgName: ${hospital.name}

function getCdrOrg(args: GetCdrOrgArgs, opts?: InvokeOptions): Promise<GetCdrOrgResult>
function getCdrOrgOutput(args: GetCdrOrgOutputArgs, opts?: InvokeOptions): Output<GetCdrOrgResult>

def get_cdr_org(fhir_store: Optional[str] = None,
                id: Optional[str] = None,
                org_id: Optional[str] = None,
                version: Optional[str] = None,
                opts: Optional[InvokeOptions] = None) -> GetCdrOrgResult
def get_cdr_org_output(fhir_store: Optional[pulumi.Input[str]] = None,
                id: Optional[pulumi.Input[str]] = None,
                org_id: Optional[pulumi.Input[str]] = None,
                version: Optional[pulumi.Input[str]] = None,
                opts: Optional[InvokeOptions] = None) -> Output[GetCdrOrgResult]

func LookupCdrOrg(ctx *Context, args *LookupCdrOrgArgs, opts ...InvokeOption) (*LookupCdrOrgResult, error)
func LookupCdrOrgOutput(ctx *Context, args *LookupCdrOrgOutputArgs, opts ...InvokeOption) LookupCdrOrgResultOutput

public static class GetCdrOrg 
{
    public static Task<GetCdrOrgResult> InvokeAsync(GetCdrOrgArgs args, InvokeOptions? opts = null)
    public static Output<GetCdrOrgResult> Invoke(GetCdrOrgInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCdrOrgResult> getCdrOrg(GetCdrOrgArgs args, InvokeOptions options)
public static Output<GetCdrOrgResult> getCdrOrg(GetCdrOrgArgs args, InvokeOptions options)

fn::invoke:
  function: hsdp:index/getCdrOrg:getCdrOrg
  arguments:
    # arguments dictionary