databricks.getCurrentConfig

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

function singleOrNone<T>(elements: pulumi.Input<T>[]): pulumi.Input<T> {
    if (elements.length != 1) {
        throw new Error("singleOrNone expected input list to have a single element");
    }
    return elements[0];
}

const this = databricks.getCurrentConfig({});
const external = new databricks.StorageCredential("external", {
    awsIamRole: singleOrNone(.map(entry => ({
        roleArn: cloudCredentialId,
    }))),
    azureManagedIdentity: singleOrNone(.map(entry => ({
        accessConnectorId: cloudCredentialId,
    }))),
    databricksGcpServiceAccount: singleOrNone(.map(entry => ({}))),
    name: "storage_cred",
    comment: "Managed by TF",
});

import pulumi
import pulumi_databricks as databricks

def single_or_none(elements):
    if len(elements) != 1:
        raise Exception("single_or_none expected input list to have a single element")
    return elements[0]


this = databricks.get_current_config()
external = databricks.StorageCredential("external",
    aws_iam_role=single_or_none([{
        "roleArn": cloud_credential_id,
    } for entry in [{"key": k, "value": v} for k, v in {} if this.cloud_type == "aws" else {
        "aws": True,
    }]]),
    azure_managed_identity=single_or_none([{
        "accessConnectorId": cloud_credential_id,
    } for entry in [{"key": k, "value": v} for k, v in {} if this.cloud_type == "azure" else {
        "azure": True,
    }]]),
    databricks_gcp_service_account=single_or_none([{} for entry in [{"key": k, "value": v} for k, v in {} if this.cloud_type == "gcp" else {
        "gcp": True,
    }]]),
    name="storage_cred",
    comment="Managed by TF")

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

return await Deployment.RunAsync(() => 
{
    var @this = Databricks.GetCurrentConfig.Invoke();

    var external = new Databricks.StorageCredential("external", new()
    {
        AwsIamRole = Enumerable.Single(),
        AzureManagedIdentity = Enumerable.Single(),
        DatabricksGcpServiceAccount = Enumerable.Single(),
        Name = "storage_cred",
        Comment = "Managed by TF",
    });

});

function getCurrentConfig(args: GetCurrentConfigArgs, opts?: InvokeOptions): Promise<GetCurrentConfigResult>
function getCurrentConfigOutput(args: GetCurrentConfigOutputArgs, opts?: InvokeOptions): Output<GetCurrentConfigResult>

def get_current_config(account_id: Optional[str] = None,
                       auth_type: Optional[str] = None,
                       cloud_type: Optional[str] = None,
                       host: Optional[str] = None,
                       is_account: Optional[bool] = None,
                       opts: Optional[InvokeOptions] = None) -> GetCurrentConfigResult
def get_current_config_output(account_id: Optional[pulumi.Input[str]] = None,
                       auth_type: Optional[pulumi.Input[str]] = None,
                       cloud_type: Optional[pulumi.Input[str]] = None,
                       host: Optional[pulumi.Input[str]] = None,
                       is_account: Optional[pulumi.Input[bool]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetCurrentConfigResult]

func GetCurrentConfig(ctx *Context, args *GetCurrentConfigArgs, opts ...InvokeOption) (*GetCurrentConfigResult, error)
func GetCurrentConfigOutput(ctx *Context, args *GetCurrentConfigOutputArgs, opts ...InvokeOption) GetCurrentConfigResultOutput

public static class GetCurrentConfig 
{
    public static Task<GetCurrentConfigResult> InvokeAsync(GetCurrentConfigArgs args, InvokeOptions? opts = null)
    public static Output<GetCurrentConfigResult> Invoke(GetCurrentConfigInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetCurrentConfigResult> getCurrentConfig(GetCurrentConfigArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: databricks:index/getCurrentConfig:getCurrentConfig
  arguments:
    # arguments dictionary