auth0.CustomDomainVerification

import * as pulumi from "@pulumi/pulumi";
import * as auth0 from "@pulumi/auth0";
import * as digitalocean from "@pulumi/digitalocean";
import * as std from "@pulumi/std";

// Example of a custom domain managed through DigitalOcean and verified using this resource.
const myCustomDomain = new auth0.CustomDomain("my_custom_domain", {
    domain: "login.example.com",
    type: "auth0_managed_certs",
});
const myDomainNameRecord = new digitalocean.index.Record("my_domain_name_record", {
    domain: "example.com",
    type: std.index.upper({
        input: myCustomDomain.verifications[0].methods?.[0]?.name,
    }).result,
    name: std.index.trimsuffix({
        input: myCustomDomain.verifications[0].methods?.[0]?.domain,
        suffix: ".example.com",
    }).result,
    value: myCustomDomain.verifications[0].methods?.[0]?.record,
});
const myCustomDomainVerification = new auth0.CustomDomainVerification("my_custom_domain_verification", {customDomainId: myCustomDomain.id}, {
    dependsOn: [myDomainNameRecord],
});

import pulumi
import pulumi_auth0 as auth0
import pulumi_digitalocean as digitalocean
import pulumi_std as std

# Example of a custom domain managed through DigitalOcean and verified using this resource.
my_custom_domain = auth0.CustomDomain("my_custom_domain",
    domain="login.example.com",
    type="auth0_managed_certs")
my_domain_name_record = digitalocean.index.Record("my_domain_name_record",
    domain=example.com,
    type=std.index.upper(input=my_custom_domain.verifications[0].methods[0].name).result,
    name=std.index.trimsuffix(input=my_custom_domain.verifications[0].methods[0].domain,
        suffix=.example.com).result,
    value=my_custom_domain.verifications[0].methods[0].record)
my_custom_domain_verification = auth0.CustomDomainVerification("my_custom_domain_verification", custom_domain_id=my_custom_domain.id,
opts = pulumi.ResourceOptions(depends_on=[my_domain_name_record]))

package main

import (
	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi-digitalocean/sdk/go/digitalocean"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Example of a custom domain managed through DigitalOcean and verified using this resource.
		myCustomDomain, err := auth0.NewCustomDomain(ctx, "my_custom_domain", &auth0.CustomDomainArgs{
			Domain: pulumi.String("login.example.com"),
			Type:   pulumi.String("auth0_managed_certs"),
		})
		if err != nil {
			return err
		}
		myDomainNameRecord, err := digitalocean.NewRecord(ctx, "my_domain_name_record", &digitalocean.RecordArgs{
			Domain: "example.com",
			Type: std.Upper(ctx, map[string]interface{}{
				"input": myCustomDomain.Verifications[0].Methods[0].Name,
			}, nil).Result,
			Name: std.Trimsuffix(ctx, map[string]interface{}{
				"input":  myCustomDomain.Verifications[0].Methods[0].Domain,
				"suffix": ".example.com",
			}, nil).Result,
			Value: myCustomDomain.Verifications[0].Methods[0].Record,
		})
		if err != nil {
			return err
		}
		_, err = auth0.NewCustomDomainVerification(ctx, "my_custom_domain_verification", &auth0.CustomDomainVerificationArgs{
			CustomDomainId: myCustomDomain.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			myDomainNameRecord,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Auth0 = Pulumi.Auth0;
using Digitalocean = Pulumi.Digitalocean;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    // Example of a custom domain managed through DigitalOcean and verified using this resource.
    var myCustomDomain = new Auth0.CustomDomain("my_custom_domain", new()
    {
        Domain = "login.example.com",
        Type = "auth0_managed_certs",
    });

    var myDomainNameRecord = new Digitalocean.Index.Record("my_domain_name_record", new()
    {
        Domain = "example.com",
        Type = Std.Index.Upper.Invoke(new()
        {
            Input = myCustomDomain.Verifications[0].Methods[0]?.Name,
        }).Result,
        Name = Std.Index.Trimsuffix.Invoke(new()
        {
            Input = myCustomDomain.Verifications[0].Methods[0]?.Domain,
            Suffix = ".example.com",
        }).Result,
        Value = myCustomDomain.Verifications[0].Methods[0]?.Record,
    });

    var myCustomDomainVerification = new Auth0.CustomDomainVerification("my_custom_domain_verification", new()
    {
        CustomDomainId = myCustomDomain.Id,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myDomainNameRecord,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.CustomDomain;
import com.pulumi.auth0.CustomDomainArgs;
import com.pulumi.digitalocean.Record;
import com.pulumi.digitalocean.RecordArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.auth0.CustomDomainVerification;
import com.pulumi.auth0.CustomDomainVerificationArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        // Example of a custom domain managed through DigitalOcean and verified using this resource.
        var myCustomDomain = new CustomDomain("myCustomDomain", CustomDomainArgs.builder()
            .domain("login.example.com")
            .type("auth0_managed_certs")
            .build());

        var myDomainNameRecord = new Record("myDomainNameRecord", RecordArgs.builder()
            .domain("example.com")
            .type(StdFunctions.upper(Map.of("input", myCustomDomain.verifications()[0].methods()[0].name())).result())
            .name(StdFunctions.trimsuffix(Map.ofEntries(
                Map.entry("input", myCustomDomain.verifications()[0].methods()[0].domain()),
                Map.entry("suffix", ".example.com")
            )).result())
            .value(myCustomDomain.verifications()[0].methods()[0].record())
            .build());

        var myCustomDomainVerification = new CustomDomainVerification("myCustomDomainVerification", CustomDomainVerificationArgs.builder()
            .customDomainId(myCustomDomain.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(myDomainNameRecord)
                .build());

    }
}

resources:
  # Example of a custom domain managed through DigitalOcean and verified using this resource.
  myCustomDomain:
    type: auth0:CustomDomain
    name: my_custom_domain
    properties:
      domain: login.example.com
      type: auth0_managed_certs
  myCustomDomainVerification:
    type: auth0:CustomDomainVerification
    name: my_custom_domain_verification
    properties:
      customDomainId: ${myCustomDomain.id}
    options:
      dependsOn:
        - ${myDomainNameRecord}
  myDomainNameRecord:
    type: digitalocean:Record
    name: my_domain_name_record
    properties:
      domain: example.com
      type:
        fn::invoke:
          function: std:upper
          arguments:
            input: ${myCustomDomain.verifications[0].methods[0].name}
          return: result
      name:
        fn::invoke:
          function: std:trimsuffix
          arguments:
            input: ${myCustomDomain.verifications[0].methods[0].domain}
            suffix: .example.com
          return: result
      value: ${myCustomDomain.verifications[0].methods[0].record}

var customDomainVerificationResource = new Auth0.CustomDomainVerification("customDomainVerificationResource", new()
{
    CustomDomainId = "string",
});

example, err := auth0.NewCustomDomainVerification(ctx, "customDomainVerificationResource", &auth0.CustomDomainVerificationArgs{
	CustomDomainId: pulumi.String("string"),
})

var customDomainVerificationResource = new CustomDomainVerification("customDomainVerificationResource", CustomDomainVerificationArgs.builder()
    .customDomainId("string")
    .build());

custom_domain_verification_resource = auth0.CustomDomainVerification("customDomainVerificationResource", custom_domain_id="string")

const customDomainVerificationResource = new auth0.CustomDomainVerification("customDomainVerificationResource", {customDomainId: "string"});

type: auth0:CustomDomainVerification
properties:
    customDomainId: string