incapsula.getAccountData

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

const accountData = incapsula.getAccountData({});
const example_account_policy_association_parent = new incapsula.AccountPolicyAssociation("example-account-policy-association-parent", {
    accountId: accountData.then(accountData => accountData.currentAccount),
    defaultNonMandatoryPolicyIds: ["123456"],
    defaultWafPolicyId: "789012",
});

import pulumi
import pulumi_incapsula as incapsula

account_data = incapsula.get_account_data()
example_account_policy_association_parent = incapsula.AccountPolicyAssociation("example-account-policy-association-parent",
    account_id=account_data.current_account,
    default_non_mandatory_policy_ids=["123456"],
    default_waf_policy_id="789012")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		accountData, err := incapsula.GetAccountData(ctx, &incapsula.GetAccountDataArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = incapsula.NewAccountPolicyAssociation(ctx, "example-account-policy-association-parent", &incapsula.AccountPolicyAssociationArgs{
			AccountId: pulumi.String(accountData.CurrentAccount),
			DefaultNonMandatoryPolicyIds: pulumi.StringArray{
				pulumi.String("123456"),
			},
			DefaultWafPolicyId: pulumi.String("789012"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var accountData = Incapsula.GetAccountData.Invoke();

    var example_account_policy_association_parent = new Incapsula.AccountPolicyAssociation("example-account-policy-association-parent", new()
    {
        AccountId = accountData.Apply(getAccountDataResult => getAccountDataResult.CurrentAccount),
        DefaultNonMandatoryPolicyIds = new[]
        {
            "123456",
        },
        DefaultWafPolicyId = "789012",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.incapsula.IncapsulaFunctions;
import com.pulumi.incapsula.inputs.GetAccountDataArgs;
import com.pulumi.incapsula.AccountPolicyAssociation;
import com.pulumi.incapsula.AccountPolicyAssociationArgs;
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 accountData = IncapsulaFunctions.getAccountData();

        var example_account_policy_association_parent = new AccountPolicyAssociation("example-account-policy-association-parent", AccountPolicyAssociationArgs.builder()
            .accountId(accountData.applyValue(getAccountDataResult -> getAccountDataResult.currentAccount()))
            .defaultNonMandatoryPolicyIds("123456")
            .defaultWafPolicyId("789012")
            .build());

    }
}

resources:
  example-account-policy-association-parent:
    type: incapsula:AccountPolicyAssociation
    properties:
      accountId: ${accountData.currentAccount}
      defaultNonMandatoryPolicyIds:
        - '123456'
      defaultWafPolicyId: '789012'
variables:
  accountData:
    fn::invoke:
      function: incapsula:getAccountData
      arguments: {}

function getAccountData(args: GetAccountDataArgs, opts?: InvokeOptions): Promise<GetAccountDataResult>
function getAccountDataOutput(args: GetAccountDataOutputArgs, opts?: InvokeOptions): Output<GetAccountDataResult>

def get_account_data(id: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetAccountDataResult
def get_account_data_output(id: Optional[pulumi.Input[str]] = None,
                     opts: Optional[InvokeOptions] = None) -> Output[GetAccountDataResult]

func GetAccountData(ctx *Context, args *GetAccountDataArgs, opts ...InvokeOption) (*GetAccountDataResult, error)
func GetAccountDataOutput(ctx *Context, args *GetAccountDataOutputArgs, opts ...InvokeOption) GetAccountDataResultOutput

public static class GetAccountData 
{
    public static Task<GetAccountDataResult> InvokeAsync(GetAccountDataArgs args, InvokeOptions? opts = null)
    public static Output<GetAccountDataResult> Invoke(GetAccountDataInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAccountDataResult> getAccountData(GetAccountDataArgs args, InvokeOptions options)
public static Output<GetAccountDataResult> getAccountData(GetAccountDataArgs args, InvokeOptions options)

fn::invoke:
  function: incapsula:index/getAccountData:getAccountData
  arguments:
    # arguments dictionary