terraconstructs 0.0.25 → 0.1.1

package/lib/aws/compute/cors.js

@@ -0,0 +1,33 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cors = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const apigateway_util_1 = require("./apigateway-util");
+class Cors {
+    // utility class
+    constructor() { }
+}
+exports.Cors = Cors;
+_a = JSII_RTTI_SYMBOL_1;
+Cors[_a] = { fqn: "terraconstructs.aws.compute.Cors", version: "0.1.1" };
+/**
+ * All HTTP methods.
+ */
+Cors.ALL_METHODS = apigateway_util_1.ALL_METHODS;
+/**
+ * All origins.
+ */
+Cors.ALL_ORIGINS = ["*"];
+/**
+ * The set of default headers allowed for CORS and useful for API Gateway.
+ */
+Cors.DEFAULT_HEADERS = [
+    "Content-Type",
+    "X-Amz-Date",
+    "Authorization",
+    "X-Api-Key",
+    "X-Amz-Security-Token",
+    "X-Amz-User-Agent",
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/deployment.d.ts

@@ -0,0 +1,83 @@
+import { Construct } from "constructs";
+import { Method } from "./method";
+import { IRestApi } from "./restapi";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+export interface DeploymentProps extends AwsConstructProps {
+    /**
+     * The Rest API to deploy.
+     */
+    readonly api: IRestApi;
+    /**
+     * A description of the purpose of the API Gateway deployment.
+     *
+     * @default - No description.
+     */
+    readonly description?: string;
+    /**
+     * The name of the stage the API Gateway deployment deploys to.
+     * If this property is set and a stage with the corresponding name does not exist,
+     * a new stage resource will be created and associated with this deployment.
+     *
+     * @default - No stage is created or associated with this deployment.
+     */
+    readonly stageName?: string;
+}
+/**
+ * A Deployment of a REST API.
+ *
+ * An immutable representation of a RestApi resource that can be called by users
+ * using Stages. A deployment must be associated with a Stage for it to be
+ * callable over the Internet.
+ *
+ * Normally, you don't need to define deployments manually. The RestApi
+ * construct manages a Deployment resource that represents the latest model. It
+ * can be accessed through `restApi.latestDeployment` (unless `deploy: false` is
+ * set when defining the `RestApi`).
+ *
+ * If you manually define this resource, you will need to know that since
+ * deployments are immutable, their properties will not change after creation.
+ * To reflect API model changes, a new deployment must be created. This is typically
+ * achieved by changing the `triggers` property of the `ApiGatewayDeployment` resource.
+ *
+ * The `addToTriggers` method can be used to augment the set of triggers for this
+ * deployment. This ensures that if specific parts of the API model change (e.g., a Method's configuration),
+ * a new deployment is triggered. This is done automatically for the `restApi.latestDeployment` deployment.
+ *
+ * Furthermore, a deployment should depend on all API Gateway resources (Methods, Resources, etc.)
+ * that define the API. Use the `_addMethodDependency` or directly add dependencies to ensure correct
+ * provisioning order. This is also handled for `restApi.latestDeployment`.
+ */
+export declare class Deployment extends AwsConstructBase {
+    readonly deploymentId: string;
+    readonly api: IRestApi;
+    /**
+     * The name of the stage created and associated with this deployment, if `stageName` was provided.
+     */
+    readonly stageName?: string;
+    private readonly deploymentResource;
+    private stageResource?;
+    private readonly triggerComponents;
+    constructor(scope: Construct, id: string, props: DeploymentProps);
+    private calculateTriggers;
+    /**
+     * Adds a component to the set of triggers that determine if a new deployment should be created.
+     *
+     * Triggers should be preferred over Dependencies, since Dependencies can only capture dependency
+     * ordering and will not cause the resource to recreate (redeploy the REST API) with upstream
+     * configuration changes.
+     *
+     * This should be called by constructs of the API Gateway model that want to
+     * invalidate the deployment when their settings change. The component will
+     * be resolved during synthesis so tokens are welcome.
+     */
+    addToTriggers(data: any): void;
+    /**
+     * Adds a dependency from this Deployment to an API Gateway Method.
+     * This ensures that the method is created before the deployment.
+     *
+     * @param method The Method construct to add as a dependency.
+     * @internal
+     */
+    _addMethodDependency(method: Method): void;
+    get outputs(): Record<string, any>;
+}

package/lib/aws/compute/deployment.js

@@ -0,0 +1,158 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deployment = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const restapi_1 = require("./restapi");
+// import { Fn } from "../../terra-func";
+const helpers_internal_1 = require("../../helpers-internal");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * A Deployment of a REST API.
+ *
+ * An immutable representation of a RestApi resource that can be called by users
+ * using Stages. A deployment must be associated with a Stage for it to be
+ * callable over the Internet.
+ *
+ * Normally, you don't need to define deployments manually. The RestApi
+ * construct manages a Deployment resource that represents the latest model. It
+ * can be accessed through `restApi.latestDeployment` (unless `deploy: false` is
+ * set when defining the `RestApi`).
+ *
+ * If you manually define this resource, you will need to know that since
+ * deployments are immutable, their properties will not change after creation.
+ * To reflect API model changes, a new deployment must be created. This is typically
+ * achieved by changing the `triggers` property of the `ApiGatewayDeployment` resource.
+ *
+ * The `addToTriggers` method can be used to augment the set of triggers for this
+ * deployment. This ensures that if specific parts of the API model change (e.g., a Method's configuration),
+ * a new deployment is triggered. This is done automatically for the `restApi.latestDeployment` deployment.
+ *
+ * Furthermore, a deployment should depend on all API Gateway resources (Methods, Resources, etc.)
+ * that define the API. Use the `_addMethodDependency` or directly add dependencies to ensure correct
+ * provisioning order. This is also handled for `restApi.latestDeployment`.
+ */
+class Deployment extends aws_construct_1.AwsConstructBase {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.triggerComponents = new Array();
+        this.api = props.api;
+        this.deploymentResource = new provider_aws_1.apiGatewayDeployment.ApiGatewayDeployment(this, "Resource", {
+            restApiId: props.api.restApiId,
+            description: props.description,
+            // ensure lifecycle create before destroy is enabled unless explicitly set to false
+            lifecycle: {
+                createBeforeDestroy: props.lifecycle?.createBeforeDestroy ?? true, // default to true
+                ...props.lifecycle,
+            },
+        });
+        // Add triggers for redployment on checksum changes.
+        this.deploymentResource.addOverride("triggers", cdktf_1.Lazy.anyValue({
+            produce: () => this.calculateTriggers(),
+        }));
+        // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.
+        // if (props.retainDeployments) {
+        //   this.deploymentResource.addOverride("lifecycle", {
+        //     prevent_destroy: true,
+        //   });
+        // }
+        this.deploymentId = this.deploymentResource.id;
+        if (props.stageName) {
+            this.stageName = props.stageName;
+            this.stageResource = new provider_aws_1.apiGatewayStage.ApiGatewayStage(this, "Stage", {
+                restApiId: props.api.restApiId,
+                deploymentId: this.deploymentResource.id,
+                stageName: props.stageName,
+                description: props.description
+                    ? `${props.description} Stage`
+                    : undefined,
+            });
+            // Dependencies on methods should be added to the deploymentResource itself.
+            // The stageResource implicitly depends on deploymentResource via deploymentId.
+        }
+        if (props.api instanceof restapi_1.RestApiBase) {
+            // The method _attachDeployment might need to be adapted or might not exist in TerraConstructs RestApiBase
+            // This is specific to how `latestDeployment` is managed by the RestApi construct.
+            props.api._attachDeployment?.(this);
+        }
+    }
+    calculateTriggers() {
+        const triggers = [...this.triggerComponents];
+        // Ignore IRestApi that are imported
+        if (this.api instanceof restapi_1.RestApi || this.api instanceof restapi_1.SpecRestApi) {
+            const apiInternal = this.api.node
+                .defaultChild;
+            // TODO: AWSCDK Triggers redeployment on any changes (not just the body property).
+            const tfRestAPI = apiInternal.toTerraform();
+            triggers.push(tfRestAPI.resource.aws_api_gateway_rest_api);
+        }
+        // NOTE: AWSCDK calculates checksum against function properties.
+        // Terraform allows use to include the entire object, so we use that for clarity.
+        const checksum = (0, helpers_internal_1.md5hash)(triggers
+            .map((x) => this.stack.resolve(x))
+            .map((c) => JSON.stringify(c))
+            .join(""));
+        // triggers has to be Record<string, string> for Terraform to accept it.
+        return { redeployment: checksum };
+        // // NOTE: consider checksum too confusing and use full trigger objects instead?
+        // // TODO: This causes "missing attributer separator" errors
+        // return triggers.length !== 0
+        //   ? { redeployment: Fn.sha1(Fn.jsonencode(this.stack.resolve(triggers))) }
+        //   : // TODO: Wrap each trigger in sha instead? { redeployment: Fn.sha1(Fn.jsonencode()) }
+        //     // triggers.reduce(
+        //     //   (acc, curr) => {
+        //     //     const key = `trigger-${Object.keys(acc).length + 1}`;
+        //     //     acc[key] = this.stack.resolve(curr);
+        //     //     return acc;
+        //     //   },
+        //     //   {} as { [key: string]: string },
+        //     // )
+        //     undefined;
+    }
+    /**
+     * Adds a component to the set of triggers that determine if a new deployment should be created.
+     *
+     * Triggers should be preferred over Dependencies, since Dependencies can only capture dependency
+     * ordering and will not cause the resource to recreate (redeploy the REST API) with upstream
+     * configuration changes.
+     *
+     * This should be called by constructs of the API Gateway model that want to
+     * invalidate the deployment when their settings change. The component will
+     * be resolved during synthesis so tokens are welcome.
+     */
+    addToTriggers(data) {
+        if (this.node.locked) {
+            throw new Error("Cannot modify deployment triggers when the construct is locked.");
+        }
+        this.triggerComponents.push(data);
+    }
+    /**
+     * Adds a dependency from this Deployment to an API Gateway Method.
+     * This ensures that the method is created before the deployment.
+     *
+     * @param method The Method construct to add as a dependency.
+     * @internal
+     */
+    _addMethodDependency(method) {
+        // adding a dependency between the constructs using `node.addDependency()`
+        // will create additional dependencies between `aws_api_gateway_deployment`
+        // and the `aws_lambda_permission` resources (children under Method),
+        // causing cyclic dependency errors. Hence, falling back to declaring
+        // dependencies between the underlying TerraformElements.
+        this.node.addDependency(method.node.defaultChild);
+        // TODO: Triggers are recommended instead of dependencies?
+    }
+    get outputs() {
+        return {
+            deploymentId: this.deploymentId,
+            stageName: this.stageName,
+            stageInvokeUrl: this.stageResource?.invokeUrl,
+        };
+    }
+}
+exports.Deployment = Deployment;
+_a = JSII_RTTI_SYMBOL_1;
+Deployment[_a] = { fqn: "terraconstructs.aws.compute.Deployment", version: "0.1.1" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployment.js","sourceRoot":"","sources":["../../../src/aws/compute/deployment.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  apiGatewayDeployment,\n  apiGatewayMethod,\n  apiGatewayRestApi,\n  apiGatewayStage,\n} from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Method } from \"./method\";\nimport { IRestApi, RestApi, RestApiBase, SpecRestApi } from \"./restapi\";\n// import { Fn } from \"../../terra-func\";\nimport { md5hash } from \"../../helpers-internal\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\n\nexport interface DeploymentProps extends AwsConstructProps {\n  /**\n   * The Rest API to deploy.\n   */\n  readonly api: IRestApi;\n\n  /**\n   * A description of the purpose of the API Gateway deployment.\n   *\n   * @default - No description.\n   */\n  readonly description?: string;\n\n  // // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.\n  // // ref: https://github.com/hashicorp/terraform/issues/27035#issuecomment-2340348801\n  // // ref: https://developer.hashicorp.com/terraform/language/resources/syntax#removing-resources\n  // /**\n  //  * When an API Gateway model is updated, a new deployment will automatically be created.\n  //  * If this is true, the old API Gateway Deployment resource will not be deleted.\n  //  * This will allow manually reverting back to a previous deployment in case for example\n  //  *\n  //  * @default false\n  //  */\n  // readonly retainDeployments?: boolean;\n\n  /**\n   * The name of the stage the API Gateway deployment deploys to.\n   * If this property is set and a stage with the corresponding name does not exist,\n   * a new stage resource will be created and associated with this deployment.\n   *\n   * @default - No stage is created or associated with this deployment.\n   */\n  readonly stageName?: string;\n}\n\n/**\n * A Deployment of a REST API.\n *\n * An immutable representation of a RestApi resource that can be called by users\n * using Stages. A deployment must be associated with a Stage for it to be\n * callable over the Internet.\n *\n * Normally, you don't need to define deployments manually. The RestApi\n * construct manages a Deployment resource that represents the latest model. It\n * can be accessed through `restApi.latestDeployment` (unless `deploy: false` is\n * set when defining the `RestApi`).\n *\n * If you manually define this resource, you will need to know that since\n * deployments are immutable, their properties will not change after creation.\n * To reflect API model changes, a new deployment must be created. This is typically\n * achieved by changing the `triggers` property of the `ApiGatewayDeployment` resource.\n *\n * The `addToTriggers` method can be used to augment the set of triggers for this\n * deployment. This ensures that if specific parts of the API model change (e.g., a Method's configuration),\n * a new deployment is triggered. This is done automatically for the `restApi.latestDeployment` deployment.\n *\n * Furthermore, a deployment should depend on all API Gateway resources (Methods, Resources, etc.)\n * that define the API. Use the `_addMethodDependency` or directly add dependencies to ensure correct\n * provisioning order. This is also handled for `restApi.latestDeployment`.\n */\nexport class Deployment extends AwsConstructBase {\n  public readonly deploymentId: string;\n  public readonly api: IRestApi;\n  /**\n   * The name of the stage created and associated with this deployment, if `stageName` was provided.\n   */\n  public readonly stageName?: string;\n\n  private readonly deploymentResource: apiGatewayDeployment.ApiGatewayDeployment;\n  private stageResource?: apiGatewayStage.ApiGatewayStage;\n\n  private readonly triggerComponents = new Array<any>();\n\n  constructor(scope: Construct, id: string, props: DeploymentProps) {\n    super(scope, id, props);\n\n    this.api = props.api;\n\n    this.deploymentResource = new apiGatewayDeployment.ApiGatewayDeployment(\n      this,\n      \"Resource\",\n      {\n        restApiId: props.api.restApiId,\n        description: props.description,\n        // ensure lifecycle create before destroy is enabled unless explicitly set to false\n        lifecycle: {\n          createBeforeDestroy: props.lifecycle?.createBeforeDestroy ?? true, // default to true\n          ...props.lifecycle,\n        },\n      },\n    );\n\n    // Add triggers for redployment on checksum changes.\n    this.deploymentResource.addOverride(\n      \"triggers\",\n      Lazy.anyValue({\n        produce: () => this.calculateTriggers(),\n      }),\n    );\n\n    // TODO: Implement RemovalPolicy.RETAIN through removed block in Terraform.\n    // if (props.retainDeployments) {\n    //   this.deploymentResource.addOverride(\"lifecycle\", {\n    //     prevent_destroy: true,\n    //   });\n    // }\n\n    this.deploymentId = this.deploymentResource.id;\n\n    if (props.stageName) {\n      this.stageName = props.stageName;\n      this.stageResource = new apiGatewayStage.ApiGatewayStage(this, \"Stage\", {\n        restApiId: props.api.restApiId,\n        deploymentId: this.deploymentResource.id,\n        stageName: props.stageName,\n        description: props.description\n          ? `${props.description} Stage`\n          : undefined,\n      });\n      // Dependencies on methods should be added to the deploymentResource itself.\n      // The stageResource implicitly depends on deploymentResource via deploymentId.\n    }\n\n    if (props.api instanceof RestApiBase) {\n      // The method _attachDeployment might need to be adapted or might not exist in TerraConstructs RestApiBase\n      // This is specific to how `latestDeployment` is managed by the RestApi construct.\n      (props.api as any)._attachDeployment?.(this);\n    }\n  }\n\n  private calculateTriggers(): { [key: string]: string } | undefined {\n    const triggers = [...this.triggerComponents];\n\n    // Ignore IRestApi that are imported\n    if (this.api instanceof RestApi || this.api instanceof SpecRestApi) {\n      const apiInternal = this.api.node\n        .defaultChild as apiGatewayRestApi.ApiGatewayRestApi;\n      // TODO: AWSCDK Triggers redeployment on any changes (not just the body property).\n      const tfRestAPI = apiInternal.toTerraform();\n      triggers.push(tfRestAPI.resource.aws_api_gateway_rest_api);\n    }\n\n    // NOTE: AWSCDK calculates checksum against function properties.\n    // Terraform allows use to include the entire object, so we use that for clarity.\n    const checksum = md5hash(\n      triggers\n        .map((x) => this.stack.resolve(x))\n        .map((c) => JSON.stringify(c))\n        .join(\"\"),\n    );\n    // triggers has to be Record<string, string> for Terraform to accept it.\n    return { redeployment: checksum };\n\n    // // NOTE: consider checksum too confusing and use full trigger objects instead?\n    // // TODO: This causes \"missing attributer separator\" errors\n    // return triggers.length !== 0\n    //   ? { redeployment: Fn.sha1(Fn.jsonencode(this.stack.resolve(triggers))) }\n    //   : // TODO: Wrap each trigger in sha instead? { redeployment: Fn.sha1(Fn.jsonencode()) }\n    //     // triggers.reduce(\n    //     //   (acc, curr) => {\n    //     //     const key = `trigger-${Object.keys(acc).length + 1}`;\n    //     //     acc[key] = this.stack.resolve(curr);\n    //     //     return acc;\n    //     //   },\n    //     //   {} as { [key: string]: string },\n    //     // )\n    //     undefined;\n  }\n\n  /**\n   * Adds a component to the set of triggers that determine if a new deployment should be created.\n   *\n   * Triggers should be preferred over Dependencies, since Dependencies can only capture dependency\n   * ordering and will not cause the resource to recreate (redeploy the REST API) with upstream\n   * configuration changes.\n   *\n   * This should be called by constructs of the API Gateway model that want to\n   * invalidate the deployment when their settings change. The component will\n   * be resolved during synthesis so tokens are welcome.\n   */\n  public addToTriggers(data: any) {\n    if (this.node.locked) {\n      throw new Error(\n        \"Cannot modify deployment triggers when the construct is locked.\",\n      );\n    }\n    this.triggerComponents.push(data);\n  }\n\n  /**\n   * Adds a dependency from this Deployment to an API Gateway Method.\n   * This ensures that the method is created before the deployment.\n   *\n   * @param method The Method construct to add as a dependency.\n   * @internal\n   */\n  public _addMethodDependency(method: Method) {\n    // adding a dependency between the constructs using `node.addDependency()`\n    // will create additional dependencies between `aws_api_gateway_deployment`\n    // and the `aws_lambda_permission` resources (children under Method),\n    // causing cyclic dependency errors. Hence, falling back to declaring\n    // dependencies between the underlying TerraformElements.\n    this.node.addDependency(\n      method.node.defaultChild as apiGatewayMethod.ApiGatewayMethod,\n    );\n\n    // TODO: Triggers are recommended instead of dependencies?\n  }\n\n  public get outputs(): Record<string, any> {\n    return {\n      deploymentId: this.deploymentId,\n      stageName: this.stageName,\n      stageInvokeUrl: this.stageResource?.invokeUrl,\n    };\n  }\n}\n"]}

package/lib/aws/compute/domain-name.d.ts

@@ -0,0 +1,153 @@
+import { Construct } from "constructs";
+import { BasePathMapping, BasePathMappingOptions } from "./base-path-mapping";
+import { EndpointType, IRestApi } from "./restapi";
+import { IStage } from "./stage";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+import * as acm from "../edge";
+import { IBucket } from "../storage";
+/**
+ * Options for creating an api mapping
+ */
+export interface ApiMappingOptions {
+    /**
+     * The api path name that callers of the API must provide in the URL after
+     * the domain name (e.g. `example.com/base-path`). If you specify this
+     * property, it can't be an empty string.
+     *
+     * If this is undefined, a mapping will be added for the empty path. Any request
+     * that does not match a mapping will get sent to the API that has been mapped
+     * to the empty path.
+     *
+     * @default - map requests from the domain root (e.g. `example.com`).
+     */
+    readonly basePath?: string;
+}
+/**
+ * The minimum version of the SSL protocol that you want API Gateway to use for HTTPS connections.
+ */
+export declare enum SecurityPolicy {
+    /** Cipher suite TLS 1.0 */
+    TLS_1_0 = "TLS_1_0",
+    /** Cipher suite TLS 1.2 */
+    TLS_1_2 = "TLS_1_2"
+}
+export interface DomainNameOptions {
+    /**
+     * The custom domain name for your API. Uppercase letters are not supported.
+     */
+    readonly domainName: string;
+    /**
+     * The reference to an AWS-managed certificate for use by the edge-optimized
+     * endpoint for the domain name. For "EDGE" domain names, the certificate
+     * needs to be in the US East (N. Virginia) region.
+     */
+    readonly certificate: acm.ICertificate;
+    /**
+     * The type of endpoint for this DomainName.
+     * @default REGIONAL
+     */
+    readonly endpointType?: EndpointType;
+    /**
+     * The Transport Layer Security (TLS) version + cipher suite for this domain name.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-domainname.html
+     * @default SecurityPolicy.TLS_1_2
+     */
+    readonly securityPolicy?: SecurityPolicy;
+    /**
+     * The mutual TLS authentication configuration for a custom domain name.
+     * @default - mTLS is not configured.
+     */
+    readonly mtls?: MTLSConfig;
+    /**
+     * The base path name that callers of the API must provide in the URL after
+     * the domain name (e.g. `example.com/base-path`). If you specify this
+     * property, it can't be an empty string.
+     *
+     * @default - map requests from the domain root (e.g. `example.com`).
+     */
+    readonly basePath?: string;
+}
+export interface DomainNameProps extends DomainNameOptions, AwsConstructProps {
+    /**
+     * If specified, all requests to this domain will be mapped to the production
+     * deployment of this API. If you wish to map this domain to multiple APIs
+     * with different base paths, use `addBasePathMapping` or `addApiMapping`.
+     *
+     * @default - you will have to call `addBasePathMapping` to map this domain to
+     * API endpoints.
+     */
+    readonly mapping?: IRestApi;
+}
+export interface IDomainName extends IAwsConstruct {
+    /**
+     * The domain name (e.g. `example.com`)
+     *
+     * @attribute DomainName
+     */
+    readonly domainName: string;
+    /**
+     * The Route53 alias target to use in order to connect a record set to this domain through an alias.
+     *
+     * @attribute DistributionDomainName,RegionalDomainName
+     */
+    readonly domainNameAliasDomainName: string;
+    /**
+     * The Route53 hosted zone ID to use in order to connect a record set to this domain through an alias.
+     *
+     * @attribute DistributionHostedZoneId,RegionalHostedZoneId
+     */
+    readonly domainNameAliasHostedZoneId: string;
+}
+export declare class DomainName extends AwsConstructBase implements IDomainName {
+    /**
+     * Imports an existing domain name.
+     */
+    static fromDomainNameAttributes(scope: Construct, id: string, attrs: DomainNameAttributes): IDomainName;
+    readonly domainName: string;
+    readonly domainNameAliasDomainName: string;
+    readonly domainNameAliasHostedZoneId: string;
+    private readonly basePaths;
+    private readonly securityPolicy?;
+    private readonly endpointType;
+    private readonly resource;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: DomainNameProps);
+    private validateBasePath;
+    private isMultiLevel;
+    addBasePathMapping(targetApi: IRestApi, options?: BasePathMappingOptions): BasePathMapping;
+    addApiMapping(targetStage: IStage, options?: ApiMappingOptions): void;
+    private configureMTLS;
+}
+export interface DomainNameAttributes {
+    /**
+     * The domain name (e.g. `example.com`)
+     */
+    readonly domainName: string;
+    /**
+     * The Route53 alias target to use in order to connect a record set to this domain through an alias.
+     */
+    readonly domainNameAliasTarget: string;
+    /**
+     * The Route53 hosted zone ID to use in order to connect a record set to this domain through an alias.
+     */
+    readonly domainNameAliasHostedZoneId: string;
+}
+/**
+ * The mTLS authentication configuration for a custom domain name.
+ */
+export interface MTLSConfig {
+    /**
+     * The bucket that the trust store is hosted in.
+     */
+    readonly bucket: IBucket;
+    /**
+     * The key in S3 to look at for the trust store.
+     */
+    readonly key: string;
+    /**
+     *  The version of the S3 object that contains your truststore.
+     *  To specify a version, you must have versioning enabled for the S3 bucket.
+     *  @default - latest version
+     */
+    readonly version?: string;
+}