fastly.getTlsActivationIds

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

const example = fastly.getTlsActivationIds({
    certificateId: exampleFastlyTlsCertificate.id,
});
const exampleGetTlsActivation = example.then(example => .reduce((__obj, [, ]) => ({ ...__obj, [__key]: fastly.getTlsActivation({
    id: __value,
}) })));
export const activationDomains = exampleGetTlsActivation.apply(exampleGetTlsActivation => Object.values(exampleGetTlsActivation).map(a => (a.domain)));

import pulumi
import pulumi_fastly as fastly

example = fastly.get_tls_activation_ids(certificate_id=example_fastly_tls_certificate["id"])
example_get_tls_activation = {__key: fastly.get_tls_activation(id=__value) for __key, __value in example.ids}
pulumi.export("activationDomains", [a.domain for a in example_get_tls_activation])

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

return await Deployment.RunAsync(() => 
{
    var example = Fastly.GetTlsActivationIds.Invoke(new()
    {
        CertificateId = exampleFastlyTlsCertificate.Id,
    });

    var exampleGetTlsActivation = ;

    return new Dictionary<string, object?>
    {
        ["activationDomains"] = exampleGetTlsActivation.Apply(exampleGetTlsActivation => (exampleGetTlsActivation).Values.Select(a => 
        {
            return a.Domain;
        }).ToList()),
    };
});

function getTlsActivationIds(args: GetTlsActivationIdsArgs, opts?: InvokeOptions): Promise<GetTlsActivationIdsResult>
function getTlsActivationIdsOutput(args: GetTlsActivationIdsOutputArgs, opts?: InvokeOptions): Output<GetTlsActivationIdsResult>

def get_tls_activation_ids(certificate_id: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetTlsActivationIdsResult
def get_tls_activation_ids_output(certificate_id: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetTlsActivationIdsResult]

func GetTlsActivationIds(ctx *Context, args *GetTlsActivationIdsArgs, opts ...InvokeOption) (*GetTlsActivationIdsResult, error)
func GetTlsActivationIdsOutput(ctx *Context, args *GetTlsActivationIdsOutputArgs, opts ...InvokeOption) GetTlsActivationIdsResultOutput

public static class GetTlsActivationIds 
{
    public static Task<GetTlsActivationIdsResult> InvokeAsync(GetTlsActivationIdsArgs args, InvokeOptions? opts = null)
    public static Output<GetTlsActivationIdsResult> Invoke(GetTlsActivationIdsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTlsActivationIdsResult> getTlsActivationIds(GetTlsActivationIdsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: fastly:index/getTlsActivationIds:getTlsActivationIds
  arguments:
    # arguments dictionary