DomainName class

Registers a custom domain name for use with AWS API Gateway. Additional information about this functionality can be found in the API Gateway Developer Guide.

This resource just establishes ownership of and the TLS settings for a particular domain name. An API can be attached to a particular path under the registered domain name using the aws.apigateway.BasePathMapping resource.

API Gateway domains can be defined as either 'edge-optimized' or 'regional'. In an edge-optimized configuration, API Gateway internally creates and manages a CloudFront distribution to route requests on the given hostname. In addition to this resource it's necessary to create a DNS record corresponding to the given domain name which is an alias (either Route53 alias or traditional CNAME) to the Cloudfront domain name exported in the cloudfrontDomainName attribute.

In a regional configuration, API Gateway does not create a CloudFront distribution to route requests to the API, though a distribution can be created if needed. In either case, it is necessary to create a DNS record corresponding to the given domain name which is an alias (either Route53 alias or traditional CNAME) to the regional domain name exported in the regionalDomainName attribute.

> Note: API Gateway requires the use of AWS Certificate Manager (ACM) certificates instead of Identity and Access Management (IAM) certificates in regions that support ACM. Regions that support ACM can be found in the Regions and Endpoints Documentation. To import an existing private key and certificate into ACM or request an ACM certificate, see the aws.acm.Certificate resource.

> Note: The aws.apigateway.DomainName resource expects dependency on the aws.acm.CertificateValidation as only verified certificates can be used. This can be made either explicitly by adding the dependsOn = [aws_acm_certificate_validation.cert] attribute. Or implicitly by referring certificate ARN from the validation resource where it will be available after the resource creation: regionalCertificateArn = aws_acm_certificate_validation.cert.certificate_arn.

Example Usage

Edge Optimized (ACM Certificate)

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

const example = new aws.apigateway.DomainName("example", {
    certificateArn: exampleAwsAcmCertificateValidation.certificateArn,
    domainName: "api.example.com",
});
// Example DNS record using Route53.
// Route53 is not specifically required; any DNS host can be used.
const exampleRecord = new aws.route53.Record("example", {
    aliases: [{
        evaluateTargetHealth: true,
        name: example.cloudfrontDomainName,
        zoneId: example.cloudfrontZoneId,
    }],
    name: example.domainName,
    type: aws.route53.RecordType.A,
    zoneId: exampleAwsRoute53Zone.id,
});
import pulumi
import pulumi_aws as aws

example = aws.apigateway.DomainName("example",
    certificate_arn=example_aws_acm_certificate_validation["certificateArn"],
    domain_name="api.example.com")
# Example DNS record using Route53.
# Route53 is not specifically required; any DNS host can be used.
example_record = aws.route53.Record("example",
    aliases=[{
        "evaluate_target_health": True,
        "name": example.cloudfront_domain_name,
        "zone_id": example.cloudfront_zone_id,
    }],
    name=example.domain_name,
    type=aws.route53.RecordType.A,
    zone_id=example_aws_route53_zone["id"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGateway.DomainName("example", new()
    {
        CertificateArn = exampleAwsAcmCertificateValidation.CertificateArn,
        Domain = "api.example.com",
    });

    // Example DNS record using Route53.
    // Route53 is not specifically required; any DNS host can be used.
    var exampleRecord = new Aws.Route53.Record("example", new()
    {
        Aliases = new[]
        {
            new Aws.Route53.Inputs.RecordAliasArgs
            {
                EvaluateTargetHealth = true,
                Name = example.CloudfrontDomainName,
                ZoneId = example.CloudfrontZoneId,
            },
        },
        Name = example.Domain,
        Type = Aws.Route53.RecordType.A,
        ZoneId = exampleAwsRoute53Zone.Id,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apigateway"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := apigateway.NewDomainName(ctx, "example", &apigateway.DomainNameArgs{
			CertificateArn: pulumi.Any(exampleAwsAcmCertificateValidation.CertificateArn),
			DomainName:     pulumi.String("api.example.com"),
		})
		if err != nil {
			return err
		}
		// Example DNS record using Route53.
		// Route53 is not specifically required; any DNS host can be used.
		_, err = route53.NewRecord(ctx, "example", &route53.RecordArgs{
			Aliases: route53.RecordAliasArray{
				&route53.RecordAliasArgs{
					EvaluateTargetHealth: pulumi.Bool(true),
					Name:                 example.CloudfrontDomainName,
					ZoneId:               example.CloudfrontZoneId,
				},
			},
			Name:   example.DomainName,
			Type:   pulumi.String(route53.RecordTypeA),
			ZoneId: pulumi.Any(exampleAwsRoute53Zone.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apigateway_domainname" "example" {
  certificate_arn = exampleAwsAcmCertificateValidation.certificateArn
  domain_name     = "api.example.com"
}
# Example DNS record using Route53.
# Route53 is not specifically required; any DNS host can be used.
resource "aws_route53_record" "example" {
  aliases {
    evaluate_target_health = true
    name                   = aws_apigateway_domainname.example.cloudfront_domain_name
    zone_id                = aws_apigateway_domainname.example.cloudfront_zone_id
  }
  name    = aws_apigateway_domainname.example.domain_name
  type    = "A"
  zone_id = exampleAwsRoute53Zone.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apigateway.DomainName;
import com.pulumi.aws.apigateway.DomainNameArgs;
import com.pulumi.aws.route53.Record;
import com.pulumi.aws.route53.RecordArgs;
import com.pulumi.aws.route53.inputs.RecordAliasArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new DomainName("example", DomainNameArgs.builder()
            .certificateArn(exampleAwsAcmCertificateValidation.certificateArn())
            .domainName("api.example.com")
            .build());

        // Example DNS record using Route53.
        // Route53 is not specifically required; any DNS host can be used.
        var exampleRecord = new Record("exampleRecord", RecordArgs.builder()
            .aliases(RecordAliasArgs.builder()
                .evaluateTargetHealth(true)
                .name(example.cloudfrontDomainName())
                .zoneId(example.cloudfrontZoneId())
                .build())
            .name(example.domainName())
            .type("A")
            .zoneId(exampleAwsRoute53Zone.id())
            .build());

    }
}
resources:
  example:
    type: aws:apigateway:DomainName
    properties:
      certificateArn: ${exampleAwsAcmCertificateValidation.certificateArn}
      domainName: api.example.com
  # Example DNS record using Route53.
  # Route53 is not specifically required; any DNS host can be used.
  exampleRecord:
    type: aws:route53:Record
    name: example
    properties:
      aliases:
        - evaluateTargetHealth: true
          name: ${example.cloudfrontDomainName}
          zoneId: ${example.cloudfrontZoneId}
      name: ${example.domainName}
      type: A
      zoneId: ${exampleAwsRoute53Zone.id}

Regional (ACM Certificate)

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

const example = new aws.apigateway.DomainName("example", {
    endpointConfiguration: {
        types: "REGIONAL",
    },
    domainName: "api.example.com",
    regionalCertificateArn: exampleAwsAcmCertificateValidation.certificateArn,
});
// Example DNS record using Route53.
// Route53 is not specifically required; any DNS host can be used.
const exampleRecord = new aws.route53.Record("example", {
    aliases: [{
        evaluateTargetHealth: true,
        name: example.regionalDomainName,
        zoneId: example.regionalZoneId,
    }],
    name: example.domainName,
    type: aws.route53.RecordType.A,
    zoneId: exampleAwsRoute53Zone.id,
});
import pulumi
import pulumi_aws as aws

example = aws.apigateway.DomainName("example",
    endpoint_configuration={
        "types": "REGIONAL",
    },
    domain_name="api.example.com",
    regional_certificate_arn=example_aws_acm_certificate_validation["certificateArn"])
# Example DNS record using Route53.
# Route53 is not specifically required; any DNS host can be used.
example_record = aws.route53.Record("example",
    aliases=[{
        "evaluate_target_health": True,
        "name": example.regional_domain_name,
        "zone_id": example.regional_zone_id,
    }],
    name=example.domain_name,
    type=aws.route53.RecordType.A,
    zone_id=example_aws_route53_zone["id"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGateway.DomainName("example", new()
    {
        EndpointConfiguration = new Aws.ApiGateway.Inputs.DomainNameEndpointConfigurationArgs
        {
            Types = "REGIONAL",
        },
        Domain = "api.example.com",
        RegionalCertificateArn = exampleAwsAcmCertificateValidation.CertificateArn,
    });

    // Example DNS record using Route53.
    // Route53 is not specifically required; any DNS host can be used.
    var exampleRecord = new Aws.Route53.Record("example", new()
    {
        Aliases = new[]
        {
            new Aws.Route53.Inputs.RecordAliasArgs
            {
                EvaluateTargetHealth = true,
                Name = example.RegionalDomainName,
                ZoneId = example.RegionalZoneId,
            },
        },
        Name = example.Domain,
        Type = Aws.Route53.RecordType.A,
        ZoneId = exampleAwsRoute53Zone.Id,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apigateway"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/route53"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := apigateway.NewDomainName(ctx, "example", &apigateway.DomainNameArgs{
			EndpointConfiguration: &apigateway.DomainNameEndpointConfigurationArgs{
				Types: pulumi.String("REGIONAL"),
			},
			DomainName:             pulumi.String("api.example.com"),
			RegionalCertificateArn: pulumi.Any(exampleAwsAcmCertificateValidation.CertificateArn),
		})
		if err != nil {
			return err
		}
		// Example DNS record using Route53.
		// Route53 is not specifically required; any DNS host can be used.
		_, err = route53.NewRecord(ctx, "example", &route53.RecordArgs{
			Aliases: route53.RecordAliasArray{
				&route53.RecordAliasArgs{
					EvaluateTargetHealth: pulumi.Bool(true),
					Name:                 example.RegionalDomainName,
					ZoneId:               example.RegionalZoneId,
				},
			},
			Name:   example.DomainName,
			Type:   pulumi.String(route53.RecordTypeA),
			ZoneId: pulumi.Any(exampleAwsRoute53Zone.Id),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apigateway_domainname" "example" {
  endpoint_configuration = {
    types = "REGIONAL"
  }
  domain_name              = "api.example.com"
  regional_certificate_arn = exampleAwsAcmCertificateValidation.certificateArn
}
# Example DNS record using Route53.
# Route53 is not specifically required; any DNS host can be used.
resource "aws_route53_record" "example" {
  aliases {
    evaluate_target_health = true
    name                   = aws_apigateway_domainname.example.regional_domain_name
    zone_id                = aws_apigateway_domainname.example.regional_zone_id
  }
  name    = aws_apigateway_domainname.example.domain_name
  type    = "A"
  zone_id = exampleAwsRoute53Zone.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apigateway.DomainName;
import com.pulumi.aws.apigateway.DomainNameArgs;
import com.pulumi.aws.apigateway.inputs.DomainNameEndpointConfigurationArgs;
import com.pulumi.aws.route53.Record;
import com.pulumi.aws.route53.RecordArgs;
import com.pulumi.aws.route53.inputs.RecordAliasArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new DomainName("example", DomainNameArgs.builder()
            .endpointConfiguration(DomainNameEndpointConfigurationArgs.builder()
                .types("REGIONAL")
                .build())
            .domainName("api.example.com")
            .regionalCertificateArn(exampleAwsAcmCertificateValidation.certificateArn())
            .build());

        // Example DNS record using Route53.
        // Route53 is not specifically required; any DNS host can be used.
        var exampleRecord = new Record("exampleRecord", RecordArgs.builder()
            .aliases(RecordAliasArgs.builder()
                .evaluateTargetHealth(true)
                .name(example.regionalDomainName())
                .zoneId(example.regionalZoneId())
                .build())
            .name(example.domainName())
            .type("A")
            .zoneId(exampleAwsRoute53Zone.id())
            .build());

    }
}
resources:
  example:
    type: aws:apigateway:DomainName
    properties:
      endpointConfiguration:
        types: REGIONAL
      domainName: api.example.com
      regionalCertificateArn: ${exampleAwsAcmCertificateValidation.certificateArn}
  # Example DNS record using Route53.
  # Route53 is not specifically required; any DNS host can be used.
  exampleRecord:
    type: aws:route53:Record
    name: example
    properties:
      aliases:
        - evaluateTargetHealth: true
          name: ${example.regionalDomainName}
          zoneId: ${example.regionalZoneId}
      name: ${example.domainName}
      type: A
      zoneId: ${exampleAwsRoute53Zone.id}

Enhanced Security Policy

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

const example = new aws.apigateway.DomainName("example", {
    endpointConfiguration: {
        types: "REGIONAL",
    },
    domainName: "api.example.com",
    regionalCertificateArn: exampleAwsAcmCertificateValidation.certificateArn,
    securityPolicy: "SecurityPolicy_TLS13_1_3_2025_09",
    endpointAccessMode: "STRICT",
});
import pulumi
import pulumi_aws as aws

example = aws.apigateway.DomainName("example",
    endpoint_configuration={
        "types": "REGIONAL",
    },
    domain_name="api.example.com",
    regional_certificate_arn=example_aws_acm_certificate_validation["certificateArn"],
    security_policy="SecurityPolicy_TLS13_1_3_2025_09",
    endpoint_access_mode="STRICT")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.ApiGateway.DomainName("example", new()
    {
        EndpointConfiguration = new Aws.ApiGateway.Inputs.DomainNameEndpointConfigurationArgs
        {
            Types = "REGIONAL",
        },
        Domain = "api.example.com",
        RegionalCertificateArn = exampleAwsAcmCertificateValidation.CertificateArn,
        SecurityPolicy = "SecurityPolicy_TLS13_1_3_2025_09",
        EndpointAccessMode = "STRICT",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apigateway"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := apigateway.NewDomainName(ctx, "example", &apigateway.DomainNameArgs{
			EndpointConfiguration: &apigateway.DomainNameEndpointConfigurationArgs{
				Types: pulumi.String("REGIONAL"),
			},
			DomainName:             pulumi.String("api.example.com"),
			RegionalCertificateArn: pulumi.Any(exampleAwsAcmCertificateValidation.CertificateArn),
			SecurityPolicy:         pulumi.String("SecurityPolicy_TLS13_1_3_2025_09"),
			EndpointAccessMode:     pulumi.String("STRICT"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_apigateway_domainname" "example" {
  endpoint_configuration = {
    types = "REGIONAL"
  }
  domain_name              = "api.example.com"
  regional_certificate_arn = exampleAwsAcmCertificateValidation.certificateArn
  security_policy          = "SecurityPolicy_TLS13_1_3_2025_09"
  endpoint_access_mode     = "STRICT"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.apigateway.DomainName;
import com.pulumi.aws.apigateway.DomainNameArgs;
import com.pulumi.aws.apigateway.inputs.DomainNameEndpointConfigurationArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        var example = new DomainName("example", DomainNameArgs.builder()
            .endpointConfiguration(DomainNameEndpointConfigurationArgs.builder()
                .types("REGIONAL")
                .build())
            .domainName("api.example.com")
            .regionalCertificateArn(exampleAwsAcmCertificateValidation.certificateArn())
            .securityPolicy("SecurityPolicy_TLS13_1_3_2025_09")
            .endpointAccessMode("STRICT")
            .build());

    }
}
resources:
  example:
    type: aws:apigateway:DomainName
    properties:
      endpointConfiguration:
        types: REGIONAL
      domainName: api.example.com
      regionalCertificateArn: ${exampleAwsAcmCertificateValidation.certificateArn}
      securityPolicy: SecurityPolicy_TLS13_1_3_2025_09
      endpointAccessMode: STRICT

Import

For a private custom domain name:

Using pulumi import, import API Gateway domain names using their name or name and domainNameId (for private custom domain names). For example:

$ pulumi import aws:apigateway/domainName:DomainName example dev.example.com

For a private custom domain name:

$ pulumi import aws:apigateway/domainName:DomainName example dev.api.internal.example.com/abcde12345

Constructors

DomainName(String name, {DomainNameArgs? args, CustomResourceOptions? options})
Creates a new DomainName. name The Pulumi resource name. args Arguments used to configure this DomainName. The set of arguments for DomainName. options Resource options controlling this resource's behavior.
DomainName.reference(String urn)
Creates a typed reference to an existing DomainName resource.

Properties

arn ↔ Output<String>
ARN of domain name.
latefinal
certificateArn ↔ Output<String?>
ARN for an AWS-managed certificate. AWS Certificate Manager is the only supported source. Used when an edge-optimized domain name is desired. Conflicts with certificateName, certificateBody, certificateChain, certificatePrivateKey, regionalCertificateArn, and regionalCertificateName.
latefinal
certificateBody ↔ Output<String?>
Certificate issued for the domain name being registered, in PEM format. Only valid for EDGE endpoint configuration type. Conflicts with certificateArn, regionalCertificateArn, and regionalCertificateName.
latefinal
certificateChain ↔ Output<String?>
Certificate for the CA that issued the certificate, along with any intermediate CA certificates required to create an unbroken chain to a certificate trusted by the intended API clients. Only valid for EDGE endpoint configuration type. Conflicts with certificateArn, regionalCertificateArn, and regionalCertificateName.
latefinal
certificateName ↔ Output<String?>
Unique name to use when registering this certificate as an IAM server certificate. Conflicts with certificateArn, regionalCertificateArn, and regionalCertificateName. Required if certificateArn is not set.
latefinal
certificatePrivateKey ↔ Output<String?>
Private key associated with the domain certificate given in certificateBody. Only valid for EDGE endpoint configuration type. Conflicts with certificateArn, regionalCertificateArn, and regionalCertificateName.
latefinal
certificateUploadDate ↔ Output<String>
Upload date associated with the domain certificate.
latefinal
childResources → Set<Resource>
finalinherited
cloudfrontDomainName ↔ Output<String>
Hostname created by Cloudfront to represent the distribution that implements this domain name mapping.
latefinal
cloudfrontZoneId ↔ Output<String>
For convenience, the hosted zone ID (Z2FDTNDATAQYW2) that can be used to create a Route53 alias record for the distribution.
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
domainName ↔ Output<String>
Fully-qualified domain name to register.
latefinal
domainNameId ↔ Output<String>
Identifier for the domain name resource. Supported only for private custom domain names.
latefinal
endpointAccessMode ↔ Output<String?>
Endpoint access mode of the DomainName. Only available for domain names that use security policies that start with SecurityPolicy_. Valid values: BASIC, STRICT.
latefinal
endpointConfiguration ↔ Output<DomainNameEndpointConfiguration>
Configuration block defining API endpoint information including type. See below.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
mutualTlsAuthentication ↔ Output<DomainNameMutualTlsAuthentication?>
Mutual TLS authentication configuration for the domain name. See below.
latefinal
ownershipVerificationCertificateArn ↔ Output<String>
ARN of the AWS-issued certificate used to validate custom domain ownership (when certificateArn is issued via an ACM Private CA or mutualTlsAuthentication is configured with an ACM-imported certificate.)
latefinal
policy ↔ Output<String?>
Stringified JSON policy document that applies to the execute-api service for this DomainName regardless of the caller and Method configuration. Supported only for private custom domain names.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
regionalCertificateArn ↔ Output<String?>
ARN for an AWS-managed certificate. AWS Certificate Manager is the only supported source. Used when a regional domain name is desired. Conflicts with certificateArn, certificateName, certificateBody, certificateChain, and certificatePrivateKey.
latefinal
regionalCertificateName ↔ Output<String?>
User-friendly name of the certificate that will be used by regional endpoint for this domain name. Conflicts with certificateArn, certificateName, certificateBody, certificateChain, and certificatePrivateKey.
latefinal
regionalDomainName ↔ Output<String>
Hostname for the custom domain's regional endpoint.
latefinal
regionalZoneId ↔ Output<String>
Hosted zone ID that can be used to create a Route53 alias record for the regional endpoint.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
routingMode ↔ Output<String>
Mode to route traffic for the domain name. Valid values: BASE_PATH_MAPPING_ONLY, ROUTING_RULE_ONLY, ROUTING_RULE_THEN_BASE_PATH_MAPPING.
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
securityPolicy ↔ Output<String>
TLS version + cipher suite for this DomainName. Must be configured to perform drift detection. For a list of valid security policies, see DomainName in the Amazon API Gateway API Reference.
latefinal
tags ↔ Output<Map<String, String>?>
Key-value map of resource tags. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {DomainNameState? state, CustomResourceOptions? options}) → DomainName
Gets an existing DomainName resource's state with the given name and id.