terraconstructs 0.0.25 → 0.1.1

package/lib/aws/compute/gateway-response.d.ts

@@ -0,0 +1,157 @@
+import { apiGatewayGatewayResponse } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IRestApi } from "./restapi";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+/**
+ * Represents gateway response resource.
+ */
+export interface IGatewayResponse extends IAwsConstruct {
+}
+/**
+ * Properties for a new gateway response.
+ */
+export interface GatewayResponseProps extends AwsConstructProps, GatewayResponseOptions {
+    /**
+     * Rest api resource to target.
+     */
+    readonly restApi: IRestApi;
+}
+/**
+ * Options to add gateway response.
+ */
+export interface GatewayResponseOptions {
+    /**
+     * Response type to associate with gateway response.
+     * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/supported-gateway-response-types.html
+     */
+    readonly type: ResponseType;
+    /**
+     * Http status code for response.
+     * @default - standard http status code for the response type.
+     */
+    readonly statusCode?: string;
+    /**
+     * Custom headers parameters for response.
+     * @default - no headers
+     */
+    readonly responseHeaders?: {
+        [key: string]: string;
+    };
+    /**
+     * Custom templates to get mapped as response.
+     * @default - Response from api will be returned without applying any transformation.
+     */
+    readonly templates?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Configure the response received by clients, produced from the API Gateway backend.
+ *
+ * @resource aws_api_gateway_gateway_response
+ */
+export declare class GatewayResponse extends AwsConstructBase implements IGatewayResponse {
+    readonly resource: apiGatewayGatewayResponse.ApiGatewayGatewayResponse;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: GatewayResponseProps);
+    private buildResponseParameters;
+}
+/**
+ * Supported types of gateway responses.
+ * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/supported-gateway-response-types.html
+ */
+export declare class ResponseType {
+    /**
+     * The gateway response for authorization failure.
+     */
+    static readonly ACCESS_DENIED: ResponseType;
+    /**
+     * The gateway response for an invalid API configuration.
+     */
+    static readonly API_CONFIGURATION_ERROR: ResponseType;
+    /**
+     * The gateway response when a custom or Amazon Cognito authorizer failed to authenticate the caller.
+     */
+    static readonly AUTHORIZER_FAILURE: ResponseType;
+    /**
+     * The gateway response for failing to connect to a custom or Amazon Cognito authorizer.
+     */
+    static readonly AUTHORIZER_CONFIGURATION_ERROR: ResponseType;
+    /**
+     * The gateway response when the request parameter cannot be validated according to an enabled request validator.
+     */
+    static readonly BAD_REQUEST_PARAMETERS: ResponseType;
+    /**
+     * The gateway response when the request body cannot be validated according to an enabled request validator.
+     */
+    static readonly BAD_REQUEST_BODY: ResponseType;
+    /**
+     * The default gateway response for an unspecified response type with the status code of 4XX.
+     */
+    static readonly DEFAULT_4XX: ResponseType;
+    /**
+     * The default gateway response for an unspecified response type with a status code of 5XX.
+     */
+    static readonly DEFAULT_5XX: ResponseType;
+    /**
+     * The gateway response for an AWS authentication token expired error.
+     */
+    static readonly EXPIRED_TOKEN: ResponseType;
+    /**
+     * The gateway response for an invalid AWS signature error.
+     */
+    static readonly INVALID_SIGNATURE: ResponseType;
+    /**
+     * The gateway response for an integration failed error.
+     */
+    static readonly INTEGRATION_FAILURE: ResponseType;
+    /**
+     * The gateway response for an integration timed out error.
+     */
+    static readonly INTEGRATION_TIMEOUT: ResponseType;
+    /**
+     * The gateway response for an invalid API key submitted for a method requiring an API key.
+     */
+    static readonly INVALID_API_KEY: ResponseType;
+    /**
+     * The gateway response for a missing authentication token error,
+     * including the cases when the client attempts to invoke an unsupported API method or resource.
+     */
+    static readonly MISSING_AUTHENTICATION_TOKEN: ResponseType;
+    /**
+     * The gateway response for the usage plan quota exceeded error.
+     */
+    static readonly QUOTA_EXCEEDED: ResponseType;
+    /**
+     * The gateway response for the request too large error.
+     */
+    static readonly REQUEST_TOO_LARGE: ResponseType;
+    /**
+     * The gateway response when API Gateway cannot find the specified resource
+     * after an API request passes authentication and authorization.
+     */
+    static readonly RESOURCE_NOT_FOUND: ResponseType;
+    /**
+     * The gateway response when usage plan, method, stage, or account level throttling limits exceeded.
+     */
+    static readonly THROTTLED: ResponseType;
+    /**
+     * The gateway response when the custom or Amazon Cognito authorizer failed to authenticate the caller.
+     */
+    static readonly UNAUTHORIZED: ResponseType;
+    /**
+     * The gateway response when a payload is of an unsupported media type, if strict passthrough behavior is enabled.
+     */
+    static readonly UNSUPPORTED_MEDIA_TYPE: ResponseType;
+    /**
+     * The gateway response when a request is blocked by AWS WAF.
+     */
+    static readonly WAF_FILTERED: ResponseType;
+    /** A custom response type to support future cases. */
+    static of(type: string): ResponseType;
+    /**
+     * Valid value of response type.
+     */
+    readonly responseType: string;
+    private constructor();
+}

package/lib/aws/compute/gateway-response.js

@@ -0,0 +1,156 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseType = exports.GatewayResponse = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * Configure the response received by clients, produced from the API Gateway backend.
+ *
+ * @resource aws_api_gateway_gateway_response
+ */
+class GatewayResponse extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            // GatewayResponse itself doesn't have specific outputs like ARN or ID in the same way other resources might.
+            // The underlying Terraform resource has an 'id' which is typically rest_api_id/response_type.
+            responseType: this.resource.responseType,
+            restApiId: this.resource.restApiId,
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const responseParameters = this.buildResponseParameters(props.responseHeaders);
+        const gatewayResponseProps = {
+            restApiId: props.restApi.restApiId,
+            responseType: props.type.responseType,
+            responseParameters: responseParameters,
+            responseTemplates: props.templates,
+            statusCode: props.statusCode,
+        };
+        this.resource = new provider_aws_1.apiGatewayGatewayResponse.ApiGatewayGatewayResponse(this, "Resource", gatewayResponseProps);
+        const deployment = props.restApi.latestDeployment;
+        if (deployment) {
+            deployment.node.addDependency(this.resource);
+            // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?
+            deployment.addToTriggers(gatewayResponseProps);
+        }
+    }
+    buildResponseParameters(responseHeaders) {
+        if (!responseHeaders) {
+            return undefined;
+        }
+        const responseParameters = {};
+        for (const [header, value] of Object.entries(responseHeaders)) {
+            responseParameters[`gatewayresponse.header.${header}`] = value;
+        }
+        return responseParameters;
+    }
+}
+exports.GatewayResponse = GatewayResponse;
+_a = JSII_RTTI_SYMBOL_1;
+GatewayResponse[_a] = { fqn: "terraconstructs.aws.compute.GatewayResponse", version: "0.1.1" };
+/**
+ * Supported types of gateway responses.
+ * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/supported-gateway-response-types.html
+ */
+class ResponseType {
+    /** A custom response type to support future cases. */
+    static of(type) {
+        return new ResponseType(type.toUpperCase());
+    }
+    constructor(type) {
+        this.responseType = type;
+    }
+}
+exports.ResponseType = ResponseType;
+_b = JSII_RTTI_SYMBOL_1;
+ResponseType[_b] = { fqn: "terraconstructs.aws.compute.ResponseType", version: "0.1.1" };
+/**
+ * The gateway response for authorization failure.
+ */
+ResponseType.ACCESS_DENIED = new ResponseType("ACCESS_DENIED");
+/**
+ * The gateway response for an invalid API configuration.
+ */
+ResponseType.API_CONFIGURATION_ERROR = new ResponseType("API_CONFIGURATION_ERROR");
+/**
+ * The gateway response when a custom or Amazon Cognito authorizer failed to authenticate the caller.
+ */
+ResponseType.AUTHORIZER_FAILURE = new ResponseType("AUTHORIZER_FAILURE");
+/**
+ * The gateway response for failing to connect to a custom or Amazon Cognito authorizer.
+ */
+ResponseType.AUTHORIZER_CONFIGURATION_ERROR = new ResponseType("AUTHORIZER_CONFIGURATION_ERROR");
+/**
+ * The gateway response when the request parameter cannot be validated according to an enabled request validator.
+ */
+ResponseType.BAD_REQUEST_PARAMETERS = new ResponseType("BAD_REQUEST_PARAMETERS");
+/**
+ * The gateway response when the request body cannot be validated according to an enabled request validator.
+ */
+ResponseType.BAD_REQUEST_BODY = new ResponseType("BAD_REQUEST_BODY");
+/**
+ * The default gateway response for an unspecified response type with the status code of 4XX.
+ */
+ResponseType.DEFAULT_4XX = new ResponseType("DEFAULT_4XX");
+/**
+ * The default gateway response for an unspecified response type with a status code of 5XX.
+ */
+ResponseType.DEFAULT_5XX = new ResponseType("DEFAULT_5XX");
+/**
+ * The gateway response for an AWS authentication token expired error.
+ */
+ResponseType.EXPIRED_TOKEN = new ResponseType("EXPIRED_TOKEN");
+/**
+ * The gateway response for an invalid AWS signature error.
+ */
+ResponseType.INVALID_SIGNATURE = new ResponseType("INVALID_SIGNATURE");
+/**
+ * The gateway response for an integration failed error.
+ */
+ResponseType.INTEGRATION_FAILURE = new ResponseType("INTEGRATION_FAILURE");
+/**
+ * The gateway response for an integration timed out error.
+ */
+ResponseType.INTEGRATION_TIMEOUT = new ResponseType("INTEGRATION_TIMEOUT");
+/**
+ * The gateway response for an invalid API key submitted for a method requiring an API key.
+ */
+ResponseType.INVALID_API_KEY = new ResponseType("INVALID_API_KEY");
+/**
+ * The gateway response for a missing authentication token error,
+ * including the cases when the client attempts to invoke an unsupported API method or resource.
+ */
+ResponseType.MISSING_AUTHENTICATION_TOKEN = new ResponseType("MISSING_AUTHENTICATION_TOKEN");
+/**
+ * The gateway response for the usage plan quota exceeded error.
+ */
+ResponseType.QUOTA_EXCEEDED = new ResponseType("QUOTA_EXCEEDED");
+/**
+ * The gateway response for the request too large error.
+ */
+ResponseType.REQUEST_TOO_LARGE = new ResponseType("REQUEST_TOO_LARGE");
+/**
+ * The gateway response when API Gateway cannot find the specified resource
+ * after an API request passes authentication and authorization.
+ */
+ResponseType.RESOURCE_NOT_FOUND = new ResponseType("RESOURCE_NOT_FOUND");
+/**
+ * The gateway response when usage plan, method, stage, or account level throttling limits exceeded.
+ */
+ResponseType.THROTTLED = new ResponseType("THROTTLED");
+/**
+ * The gateway response when the custom or Amazon Cognito authorizer failed to authenticate the caller.
+ */
+ResponseType.UNAUTHORIZED = new ResponseType("UNAUTHORIZED");
+/**
+ * The gateway response when a payload is of an unsupported media type, if strict passthrough behavior is enabled.
+ */
+ResponseType.UNSUPPORTED_MEDIA_TYPE = new ResponseType("UNSUPPORTED_MEDIA_TYPE");
+/**
+ * The gateway response when a request is blocked by AWS WAF.
+ */
+ResponseType.WAF_FILTERED = new ResponseType("WAF_FILTERED");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gateway-response.js","sourceRoot":"","sources":["../../../src/aws/compute/gateway-response.ts"],"names":[],"mappings":"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","sourcesContent":["import { apiGatewayGatewayResponse } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { IRestApi } from \"./restapi\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\n// import { Fn } from \"../../terra-func\";\n\n/**\n * Represents gateway response resource.\n */\nexport interface IGatewayResponse extends IAwsConstruct {}\n\n/**\n * Properties for a new gateway response.\n */\nexport interface GatewayResponseProps\n  extends AwsConstructProps,\n    GatewayResponseOptions {\n  /**\n   * Rest api resource to target.\n   */\n  readonly restApi: IRestApi;\n}\n\n/**\n * Options to add gateway response.\n */\nexport interface GatewayResponseOptions {\n  /**\n   * Response type to associate with gateway response.\n   * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/supported-gateway-response-types.html\n   */\n  readonly type: ResponseType;\n\n  /**\n   * Http status code for response.\n   * @default - standard http status code for the response type.\n   */\n  readonly statusCode?: string;\n\n  /**\n   * Custom headers parameters for response.\n   * @default - no headers\n   */\n  readonly responseHeaders?: { [key: string]: string };\n\n  /**\n   * Custom templates to get mapped as response.\n   * @default - Response from api will be returned without applying any transformation.\n   */\n  readonly templates?: { [key: string]: string };\n}\n\n/**\n * Configure the response received by clients, produced from the API Gateway backend.\n *\n * @resource aws_api_gateway_gateway_response\n */\nexport class GatewayResponse\n  extends AwsConstructBase\n  implements IGatewayResponse\n{\n  public readonly resource: apiGatewayGatewayResponse.ApiGatewayGatewayResponse;\n\n  public get outputs(): Record<string, any> {\n    return {\n      // GatewayResponse itself doesn't have specific outputs like ARN or ID in the same way other resources might.\n      // The underlying Terraform resource has an 'id' which is typically rest_api_id/response_type.\n      responseType: this.resource.responseType,\n      restApiId: this.resource.restApiId,\n    };\n  }\n\n  constructor(scope: Construct, id: string, props: GatewayResponseProps) {\n    super(scope, id, props);\n\n    const responseParameters = this.buildResponseParameters(\n      props.responseHeaders,\n    );\n\n    const gatewayResponseProps: apiGatewayGatewayResponse.ApiGatewayGatewayResponseConfig =\n      {\n        restApiId: props.restApi.restApiId,\n        responseType: props.type.responseType,\n        responseParameters: responseParameters,\n        responseTemplates: props.templates,\n        statusCode: props.statusCode,\n      };\n    this.resource = new apiGatewayGatewayResponse.ApiGatewayGatewayResponse(\n      this,\n      \"Resource\",\n      gatewayResponseProps,\n    );\n\n    const deployment = props.restApi.latestDeployment;\n    if (deployment) {\n      deployment.node.addDependency(this.resource);\n      // Fn.sha1(Fn.jsonencode()) causes nested Tokens and Resolver errors?\n      deployment.addToTriggers(gatewayResponseProps);\n    }\n  }\n\n  private buildResponseParameters(responseHeaders?: {\n    [key: string]: string;\n  }): { [key: string]: string } | undefined {\n    if (!responseHeaders) {\n      return undefined;\n    }\n\n    const responseParameters: { [key: string]: string } = {};\n    for (const [header, value] of Object.entries(responseHeaders)) {\n      responseParameters[`gatewayresponse.header.${header}`] = value;\n    }\n    return responseParameters;\n  }\n}\n\n/**\n * Supported types of gateway responses.\n * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/supported-gateway-response-types.html\n */\nexport class ResponseType {\n  /**\n   * The gateway response for authorization failure.\n   */\n  public static readonly ACCESS_DENIED = new ResponseType(\"ACCESS_DENIED\");\n\n  /**\n   * The gateway response for an invalid API configuration.\n   */\n  public static readonly API_CONFIGURATION_ERROR = new ResponseType(\n    \"API_CONFIGURATION_ERROR\",\n  );\n\n  /**\n   * The gateway response when a custom or Amazon Cognito authorizer failed to authenticate the caller.\n   */\n  public static readonly AUTHORIZER_FAILURE = new ResponseType(\n    \"AUTHORIZER_FAILURE\",\n  );\n\n  /**\n   * The gateway response for failing to connect to a custom or Amazon Cognito authorizer.\n   */\n  public static readonly AUTHORIZER_CONFIGURATION_ERROR = new ResponseType(\n    \"AUTHORIZER_CONFIGURATION_ERROR\",\n  );\n\n  /**\n   * The gateway response when the request parameter cannot be validated according to an enabled request validator.\n   */\n  public static readonly BAD_REQUEST_PARAMETERS = new ResponseType(\n    \"BAD_REQUEST_PARAMETERS\",\n  );\n\n  /**\n   * The gateway response when the request body cannot be validated according to an enabled request validator.\n   */\n  public static readonly BAD_REQUEST_BODY = new ResponseType(\n    \"BAD_REQUEST_BODY\",\n  );\n\n  /**\n   * The default gateway response for an unspecified response type with the status code of 4XX.\n   */\n  public static readonly DEFAULT_4XX = new ResponseType(\"DEFAULT_4XX\");\n\n  /**\n   * The default gateway response for an unspecified response type with a status code of 5XX.\n   */\n  public static readonly DEFAULT_5XX = new ResponseType(\"DEFAULT_5XX\");\n\n  /**\n   * The gateway response for an AWS authentication token expired error.\n   */\n  public static readonly EXPIRED_TOKEN = new ResponseType(\"EXPIRED_TOKEN\");\n\n  /**\n   * The gateway response for an invalid AWS signature error.\n   */\n  public static readonly INVALID_SIGNATURE = new ResponseType(\n    \"INVALID_SIGNATURE\",\n  );\n\n  /**\n   * The gateway response for an integration failed error.\n   */\n  public static readonly INTEGRATION_FAILURE = new ResponseType(\n    \"INTEGRATION_FAILURE\",\n  );\n\n  /**\n   * The gateway response for an integration timed out error.\n   */\n  public static readonly INTEGRATION_TIMEOUT = new ResponseType(\n    \"INTEGRATION_TIMEOUT\",\n  );\n\n  /**\n   * The gateway response for an invalid API key submitted for a method requiring an API key.\n   */\n  public static readonly INVALID_API_KEY = new ResponseType(\"INVALID_API_KEY\");\n\n  /**\n   * The gateway response for a missing authentication token error,\n   * including the cases when the client attempts to invoke an unsupported API method or resource.\n   */\n  public static readonly MISSING_AUTHENTICATION_TOKEN = new ResponseType(\n    \"MISSING_AUTHENTICATION_TOKEN\",\n  );\n\n  /**\n   * The gateway response for the usage plan quota exceeded error.\n   */\n  public static readonly QUOTA_EXCEEDED = new ResponseType(\"QUOTA_EXCEEDED\");\n\n  /**\n   * The gateway response for the request too large error.\n   */\n  public static readonly REQUEST_TOO_LARGE = new ResponseType(\n    \"REQUEST_TOO_LARGE\",\n  );\n\n  /**\n   * The gateway response when API Gateway cannot find the specified resource\n   * after an API request passes authentication and authorization.\n   */\n  public static readonly RESOURCE_NOT_FOUND = new ResponseType(\n    \"RESOURCE_NOT_FOUND\",\n  );\n\n  /**\n   * The gateway response when usage plan, method, stage, or account level throttling limits exceeded.\n   */\n  public static readonly THROTTLED = new ResponseType(\"THROTTLED\");\n\n  /**\n   * The gateway response when the custom or Amazon Cognito authorizer failed to authenticate the caller.\n   */\n  public static readonly UNAUTHORIZED = new ResponseType(\"UNAUTHORIZED\");\n\n  /**\n   * The gateway response when a payload is of an unsupported media type, if strict passthrough behavior is enabled.\n   */\n  public static readonly UNSUPPORTED_MEDIA_TYPE = new ResponseType(\n    \"UNSUPPORTED_MEDIA_TYPE\",\n  );\n\n  /**\n   * The gateway response when a request is blocked by AWS WAF.\n   */\n  public static readonly WAF_FILTERED = new ResponseType(\"WAF_FILTERED\");\n\n  /** A custom response type to support future cases. */\n  public static of(type: string): ResponseType {\n    return new ResponseType(type.toUpperCase());\n  }\n\n  /**\n   * Valid value of response type.\n   */\n  public readonly responseType: string;\n\n  private constructor(type: string) {\n    this.responseType = type;\n  }\n}\n"]}

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

@@ -0,0 +1,10 @@
+/**
+ * Lambda function handler
+ */
+export declare class Handler {
+    /**
+     * A special handler when the function handler is part of a Docker image.
+     */
+    static readonly FROM_IMAGE = "FROM_IMAGE";
+    private constructor();
+}

package/lib/aws/compute/handler.js

@@ -0,0 +1,20 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handler = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-lambda/lib/handler.ts
+/**
+ * Lambda function handler
+ */
+class Handler {
+    constructor() { }
+}
+exports.Handler = Handler;
+_a = JSII_RTTI_SYMBOL_1;
+Handler[_a] = { fqn: "terraconstructs.aws.compute.Handler", version: "0.1.1" };
+/**
+ * A special handler when the function handler is part of a Docker image.
+ */
+Handler.FROM_IMAGE = "FROM_IMAGE";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hd3MvY29tcHV0ZS9oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsOEZBQThGO0FBRTlGOztHQUVHO0FBQ0gsTUFBYSxPQUFPO0lBTWxCLGdCQUF1QixDQUFDOztBQU4xQiwwQkFPQzs7O0FBTkM7O0dBRUc7QUFDb0Isa0JBQVUsR0FBRyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi92Mi4xODYuMC9wYWNrYWdlcy9hd3MtY2RrLWxpYi9hd3MtbGFtYmRhL2xpYi9oYW5kbGVyLnRzXG5cbi8qKlxuICogTGFtYmRhIGZ1bmN0aW9uIGhhbmRsZXJcbiAqL1xuZXhwb3J0IGNsYXNzIEhhbmRsZXIge1xuICAvKipcbiAgICogQSBzcGVjaWFsIGhhbmRsZXIgd2hlbiB0aGUgZnVuY3Rpb24gaGFuZGxlciBpcyBwYXJ0IG9mIGEgRG9ja2VyIGltYWdlLlxuICAgKi9cbiAgcHVibGljIHN0YXRpYyByZWFkb25seSBGUk9NX0lNQUdFID0gXCJGUk9NX0lNQUdFXCI7XG5cbiAgcHJpdmF0ZSBjb25zdHJ1Y3RvcigpIHt9XG59XG4iXX0=

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

@@ -9,6 +9,9 @@ export * from "./function-nodejs";
 export * from "./function-permission";
 export * from "./function-url";
 export * from "./architecture";
+export * from "./code";
+export * from "./handler";
+export * from "./runtime";
 export * from "./fields";
 export * from "./activity";
 export * from "./task-input";
@@ -104,6 +107,30 @@ export * from "./lb-shared/lb-target-group-attachment-config.generated";
 export * as sources from "./event-sources";
 export * as destinations from "./function-destinations";
 export * as tasks from "./tasks";
+export * from "./restapi";
+export * from "./resource";
+export * from "./method";
+export * from "./integration";
+export * from "./deployment";
+export * from "./stage";
+export * from "./integrations";
+export * from "./lambda-api";
+export * from "./api-key";
+export * from "./usage-plan";
+export * from "./vpc-link";
+export * from "./methodresponse";
+export * from "./model";
+export * from "./requestvalidator";
+export * from "./authorizer";
+export * from "./json-schema";
+export * from "./domain-name";
+export * from "./base-path-mapping";
+export * from "./cors";
+export * from "./authorizers";
+export * from "./access-log";
+export * from "./api-definition";
+export * from "./gateway-response";
+export * from "./stepfunctions-api";
 export * from "./function-vpc-config.generated";
 import "./ec2-augmentations.generated";
 import "./lambda-augmentations.generated";

package/lib/aws/compute/index.js

@@ -26,6 +26,9 @@ __exportStar(require("./function-nodejs"), exports);
 __exportStar(require("./function-permission"), exports);
 __exportStar(require("./function-url"), exports);
 __exportStar(require("./architecture"), exports);
+__exportStar(require("./code"), exports);
+__exportStar(require("./handler"), exports);
+__exportStar(require("./runtime"), exports);
 // stepfunctions
 __exportStar(require("./fields"), exports);
 __exportStar(require("./activity"), exports);
@@ -134,8 +137,33 @@ __exportStar(require("./lb-shared/lb-target-group-attachment-config.generated"),
 exports.sources = require("./event-sources");
 exports.destinations = require("./function-destinations");
 exports.tasks = require("./tasks"); // State Machine Tasks
+// API Gateway
+__exportStar(require("./restapi"), exports);
+__exportStar(require("./resource"), exports);
+__exportStar(require("./method"), exports);
+__exportStar(require("./integration"), exports);
+__exportStar(require("./deployment"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./integrations"), exports);
+__exportStar(require("./lambda-api"), exports);
+__exportStar(require("./api-key"), exports);
+__exportStar(require("./usage-plan"), exports);
+__exportStar(require("./vpc-link"), exports);
+__exportStar(require("./methodresponse"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./requestvalidator"), exports);
+__exportStar(require("./authorizer"), exports);
+__exportStar(require("./json-schema"), exports);
+__exportStar(require("./domain-name"), exports);
+__exportStar(require("./base-path-mapping"), exports);
+__exportStar(require("./cors"), exports);
+__exportStar(require("./authorizers"), exports);
+__exportStar(require("./access-log"), exports);
+__exportStar(require("./api-definition"), exports);
+__exportStar(require("./gateway-response"), exports);
+__exportStar(require("./stepfunctions-api"), exports);
 // generated by JSII Struct builder to please JSII pacman
 __exportStar(require("./function-vpc-config.generated"), exports);
 require("./ec2-augmentations.generated");
 require("./lambda-augmentations.generated");
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/aws/compute/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,yDAAuC;AACvC,wDAAsC;AACtC,kDAAgC;AAChC,6CAA2B;AAC3B,mDAAiC;AACjC,yDAAuC;AACvC,oDAAkC;AAClC,wDAAsC;AACtC,iDAA+B;AAC/B,iDAA+B;AAC/B,gBAAgB;AAChB,2CAAyB;AACzB,6CAA2B;AAC3B,+CAA6B;AAC7B,0CAAwB;AACxB,8CAA4B;AAC5B,kDAAgC;AAChC,2DAAyC;AACzC,oFAAoF;AACpF,8CAA8C;AAC9C,0CAAwB;AACxB,gDAA8B;AAC9B,wDAAsC;AAEtC,kDAAgC;AAChC,gDAA8B;AAC9B,oDAAkC;AAClC,gDAA8B;AAC9B,iDAA+B;AAC/B,mDAAiC;AACjC,gDAA8B;AAC9B,gDAA8B;AAC9B,+CAA6B;AAC7B,2DAAyC;AACzC,wEAAsD;AACtD,uEAAqD;AACrD,yEAAuD;AACvD,wDAAsC;AAEtC,oDAAkC;AAClC,qDAAmC;AACnC,qDAAmC;AAEnC,MAAM;AACN,kEAAgD;AAChD,iDAA+B;AAC/B,gDAA8B;AAC9B,8BAA8B;AAC9B,uCAAuC;AACvC,mDAAiC;AACjC,6CAA2B;AAC3B,oDAAkC;AAClC,kDAAgC;AAChC,wCAAsB;AACtB,gDAA8B;AAC9B,sDAAoC;AACpC,yCAAuB;AACvB,gDAA8B;AAC9B,mDAAiC;AACjC,2CAAyB;AACzB,yCAAuB;AACvB,2CAAyB;AACzB,wCAAsB;AACtB,+CAA6B;AAC7B,wCAAsB;AACtB,iDAA+B;AAC/B,yDAAuC;AACvC,8CAA4B;AAC5B,qDAAmC;AACnC,kDAAgC;AAChC,8DAA4C;AAC5C,wDAAsC;AACtC,kEAAgD;AAChD,qDAAmC;AACnC,iDAA+B;AAC/B,kDAAgC;AAChC,oDAAkC;AAClC,6CAA2B;AAC3B,YAAY;AACZ,yCAAuC;AAEvC,uBAAuB;AACvB,kDAAgC;AAChC,yBAAyB;AACzB,6DAA2C;AAC3C,yEAAuD;AACvD,kEAAgD;AAChD,kEAAgD;AAChD,iEAA+C;AAC/C,oEAAkD;AAClD,mDAAiC;AACjC,oDAAkC;AAClC,+DAA6C;AAE7C,yDAAuC;AACvC,8DAA4C;AAC5C,6DAA2C;AAC3C,gEAA8C;AAE9C,iCAAiC;AACjC,4CAA0C;AAE1C,qBAAqB;AACrB,4DAA0D;AAE1D,iBAAiB;AACjB,4DAA0C;AAC1C,6CAA2B;AAC3B,oDAAkC;AAClC,wDAAsC;AACtC,wDAAsC;AACtC,mEAAiD;AAEjD,sCAAsC;AACtC,gEAA8C;AAC9C,4DAA0C;AAC1C,iEAA+C;AAC/C,gEAA8C;AAC9C,oDAAkC;AAClC,oEAAkD;AAClD,mEAAiD;AACjD,8DAA4C;AAC5C,2EAAyD;AACzD,0FAAwE;AAExE,6CAA2C;AAC3C,0DAAwD;AACxD,mCAAiC,CAAC,sBAAsB;AAExD,yDAAyD;AACzD,kEAAgD;AAEhD,yCAAuC;AACvC,4CAA0C","sourcesContent":["export * from \"./event-source-filter\";\nexport * from \"./event-source-mapping\";\nexport * from \"./event-invoke-config\";\nexport * from \"./function-base\";\nexport * from \"./function\";\nexport * from \"./function-alias\";\nexport * from \"./function-destination\";\nexport * from \"./function-nodejs\";\nexport * from \"./function-permission\";\nexport * from \"./function-url\";\nexport * from \"./architecture\";\n// stepfunctions\nexport * from \"./fields\";\nexport * from \"./activity\";\nexport * from \"./task-input\";\nexport * from \"./types\";\nexport * from \"./condition\";\nexport * from \"./state-machine\";\nexport * from \"./state-machine-fragment\";\n// TODO: When re-adding, make sure to also add test/state-transition-metrics.test.ts\n// export * from \"./state-transition-metrics\";\nexport * from \"./chain\";\nexport * from \"./state-graph\";\nexport * from \"./step-functions-task\";\n\nexport * from \"./states/choice\";\nexport * from \"./states/fail\";\nexport * from \"./states/parallel\";\nexport * from \"./states/pass\";\nexport * from \"./states/state\";\nexport * from \"./states/succeed\";\nexport * from \"./states/task\";\nexport * from \"./states/wait\";\nexport * from \"./states/map\";\nexport * from \"./states/distributed-map\";\nexport * from \"./states/distributed-map/item-batcher\";\nexport * from \"./states/distributed-map/item-reader\";\nexport * from \"./states/distributed-map/result-writer\";\nexport * from \"./states/custom-state\";\n\nexport * from \"./states/map-base\";\nexport * from \"./states/task-base\";\nexport * from \"./task-credentials\";\n\n// ec2\nexport * from \"./aspects/require-imdsv2-aspect\";\nexport * from \"./bastion-host\";\nexport * from \"./connections\";\n// export * from \"./cfn-init\";\n// export * from \"./cfn-init-elements\";\nexport * from \"./instance-types\";\nexport * from \"./instance\";\nexport * from \"./launch-template\";\nexport * from \"./machine-image\";\nexport * from \"./nat\";\nexport * from \"./network-acl\";\nexport * from \"./network-acl-types\";\nexport * from \"./port\";\nexport * from \"./prefix-list\";\nexport * from \"./security-group\";\nexport * from \"./subnet\";\nexport * from \"./peer\";\nexport * from \"./volume\";\nexport * from \"./vpc\";\nexport * from \"./vpc-lookup\";\nexport * from \"./vpn\";\nexport * from \"./vpc-endpoint\";\nexport * from \"./vpc-endpoint-service\";\nexport * from \"./user-data\";\nexport * from \"./windows-versions\";\nexport * from \"./vpc-flow-logs\";\nexport * from \"./client-vpn-endpoint-types\";\nexport * from \"./client-vpn-endpoint\";\nexport * from \"./client-vpn-authorization-rule\";\nexport * from \"./client-vpn-route\";\nexport * from \"./ip-addresses\";\nexport * from \"./machine-image\";\nexport * from \"./placement-group\";\nexport * from \"./key-pair\";\n// ec2-alpha\nexport * as alpha from \"./index-alpha\";\n\n// elasticloadbalancing\nexport * from \"./load-balancer\";\n// elasticloadbalancingv2\nexport * from \"./alb/application-listener\";\nexport * from \"./alb/application-listener-certificate\";\nexport * from \"./alb/application-listener-rule\";\nexport * from \"./alb/application-load-balancer\";\nexport * from \"./alb/application-target-group\";\nexport * from \"./alb/application-listener-action\";\nexport * from \"./alb/conditions\";\nexport * from \"./alb/trust-store\";\nexport * from \"./alb/trust-store-revocation\";\n\nexport * from \"./nlb/network-listener\";\nexport * from \"./nlb/network-load-balancer\";\nexport * from \"./nlb/network-target-group\";\nexport * from \"./nlb/network-listener-action\";\n\n// elasticloadbalancingv2-targets\nexport * as lbtargets from \"./lb-targets\";\n\n// autoscaling-common\nexport * as autoscalingcommon from \"./autoscaling-common\";\n\n// appautoscaling\nexport * from \"./base-scalable-attribute\";\nexport * from \"./schedule\";\nexport * from \"./scalable-target\";\nexport * from \"./step-scaling-policy\";\nexport * from \"./step-scaling-action\";\nexport * from \"./target-tracking-scaling-policy\";\n\n// temp export, required by base types\nexport * from \"./lb-shared/grid-lookup-types\";\nexport * from \"./lb-shared/base-listener\";\nexport * from \"./lb-shared/base-load-balancer\";\nexport * from \"./lb-shared/base-target-group\";\nexport * from \"./lb-shared/enums\";\nexport * from \"./lb-shared/load-balancer-targets\";\nexport * from \"./lb-shared/listener-certificate\";\nexport * from \"./lb-shared/listener-action\";\nexport * from \"./lb-shared/lb-listener-config.generated\";\nexport * from \"./lb-shared/lb-target-group-attachment-config.generated\";\n\nexport * as sources from \"./event-sources\";\nexport * as destinations from \"./function-destinations\";\nexport * as tasks from \"./tasks\"; // State Machine Tasks\n\n// generated by JSII Struct builder to please JSII pacman\nexport * from \"./function-vpc-config.generated\";\n\nimport \"./ec2-augmentations.generated\";\nimport \"./lambda-augmentations.generated\";\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/aws/compute/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,yDAAuC;AACvC,wDAAsC;AACtC,kDAAgC;AAChC,6CAA2B;AAC3B,mDAAiC;AACjC,yDAAuC;AACvC,oDAAkC;AAClC,wDAAsC;AACtC,iDAA+B;AAC/B,iDAA+B;AAC/B,yCAAuB;AACvB,4CAA0B;AAC1B,4CAA0B;AAC1B,gBAAgB;AAChB,2CAAyB;AACzB,6CAA2B;AAC3B,+CAA6B;AAC7B,0CAAwB;AACxB,8CAA4B;AAC5B,kDAAgC;AAChC,2DAAyC;AACzC,oFAAoF;AACpF,8CAA8C;AAC9C,0CAAwB;AACxB,gDAA8B;AAC9B,wDAAsC;AAEtC,kDAAgC;AAChC,gDAA8B;AAC9B,oDAAkC;AAClC,gDAA8B;AAC9B,iDAA+B;AAC/B,mDAAiC;AACjC,gDAA8B;AAC9B,gDAA8B;AAC9B,+CAA6B;AAC7B,2DAAyC;AACzC,wEAAsD;AACtD,uEAAqD;AACrD,yEAAuD;AACvD,wDAAsC;AAEtC,oDAAkC;AAClC,qDAAmC;AACnC,qDAAmC;AAEnC,MAAM;AACN,kEAAgD;AAChD,iDAA+B;AAC/B,gDAA8B;AAC9B,8BAA8B;AAC9B,uCAAuC;AACvC,mDAAiC;AACjC,6CAA2B;AAC3B,oDAAkC;AAClC,kDAAgC;AAChC,wCAAsB;AACtB,gDAA8B;AAC9B,sDAAoC;AACpC,yCAAuB;AACvB,gDAA8B;AAC9B,mDAAiC;AACjC,2CAAyB;AACzB,yCAAuB;AACvB,2CAAyB;AACzB,wCAAsB;AACtB,+CAA6B;AAC7B,wCAAsB;AACtB,iDAA+B;AAC/B,yDAAuC;AACvC,8CAA4B;AAC5B,qDAAmC;AACnC,kDAAgC;AAChC,8DAA4C;AAC5C,wDAAsC;AACtC,kEAAgD;AAChD,qDAAmC;AACnC,iDAA+B;AAC/B,kDAAgC;AAChC,oDAAkC;AAClC,6CAA2B;AAC3B,YAAY;AACZ,yCAAuC;AAEvC,uBAAuB;AACvB,kDAAgC;AAChC,yBAAyB;AACzB,6DAA2C;AAC3C,yEAAuD;AACvD,kEAAgD;AAChD,kEAAgD;AAChD,iEAA+C;AAC/C,oEAAkD;AAClD,mDAAiC;AACjC,oDAAkC;AAClC,+DAA6C;AAE7C,yDAAuC;AACvC,8DAA4C;AAC5C,6DAA2C;AAC3C,gEAA8C;AAE9C,iCAAiC;AACjC,4CAA0C;AAE1C,qBAAqB;AACrB,4DAA0D;AAE1D,iBAAiB;AACjB,4DAA0C;AAC1C,6CAA2B;AAC3B,oDAAkC;AAClC,wDAAsC;AACtC,wDAAsC;AACtC,mEAAiD;AAEjD,sCAAsC;AACtC,gEAA8C;AAC9C,4DAA0C;AAC1C,iEAA+C;AAC/C,gEAA8C;AAC9C,oDAAkC;AAClC,oEAAkD;AAClD,mEAAiD;AACjD,8DAA4C;AAC5C,2EAAyD;AACzD,0FAAwE;AAExE,6CAA2C;AAC3C,0DAAwD;AACxD,mCAAiC,CAAC,sBAAsB;AAExD,cAAc;AACd,4CAA0B;AAC1B,6CAA2B;AAC3B,2CAAyB;AACzB,gDAA8B;AAC9B,+CAA6B;AAC7B,0CAAwB;AACxB,iDAA+B;AAC/B,+CAA6B;AAC7B,4CAA0B;AAC1B,+CAA6B;AAC7B,6CAA2B;AAC3B,mDAAiC;AACjC,0CAAwB;AACxB,qDAAmC;AACnC,+CAA6B;AAC7B,gDAA8B;AAC9B,gDAA8B;AAC9B,sDAAoC;AACpC,yCAAuB;AACvB,gDAA8B;AAC9B,+CAA6B;AAC7B,mDAAiC;AACjC,qDAAmC;AACnC,sDAAoC;AAEpC,yDAAyD;AACzD,kEAAgD;AAEhD,yCAAuC;AACvC,4CAA0C","sourcesContent":["export * from \"./event-source-filter\";\nexport * from \"./event-source-mapping\";\nexport * from \"./event-invoke-config\";\nexport * from \"./function-base\";\nexport * from \"./function\";\nexport * from \"./function-alias\";\nexport * from \"./function-destination\";\nexport * from \"./function-nodejs\";\nexport * from \"./function-permission\";\nexport * from \"./function-url\";\nexport * from \"./architecture\";\nexport * from \"./code\";\nexport * from \"./handler\";\nexport * from \"./runtime\";\n// stepfunctions\nexport * from \"./fields\";\nexport * from \"./activity\";\nexport * from \"./task-input\";\nexport * from \"./types\";\nexport * from \"./condition\";\nexport * from \"./state-machine\";\nexport * from \"./state-machine-fragment\";\n// TODO: When re-adding, make sure to also add test/state-transition-metrics.test.ts\n// export * from \"./state-transition-metrics\";\nexport * from \"./chain\";\nexport * from \"./state-graph\";\nexport * from \"./step-functions-task\";\n\nexport * from \"./states/choice\";\nexport * from \"./states/fail\";\nexport * from \"./states/parallel\";\nexport * from \"./states/pass\";\nexport * from \"./states/state\";\nexport * from \"./states/succeed\";\nexport * from \"./states/task\";\nexport * from \"./states/wait\";\nexport * from \"./states/map\";\nexport * from \"./states/distributed-map\";\nexport * from \"./states/distributed-map/item-batcher\";\nexport * from \"./states/distributed-map/item-reader\";\nexport * from \"./states/distributed-map/result-writer\";\nexport * from \"./states/custom-state\";\n\nexport * from \"./states/map-base\";\nexport * from \"./states/task-base\";\nexport * from \"./task-credentials\";\n\n// ec2\nexport * from \"./aspects/require-imdsv2-aspect\";\nexport * from \"./bastion-host\";\nexport * from \"./connections\";\n// export * from \"./cfn-init\";\n// export * from \"./cfn-init-elements\";\nexport * from \"./instance-types\";\nexport * from \"./instance\";\nexport * from \"./launch-template\";\nexport * from \"./machine-image\";\nexport * from \"./nat\";\nexport * from \"./network-acl\";\nexport * from \"./network-acl-types\";\nexport * from \"./port\";\nexport * from \"./prefix-list\";\nexport * from \"./security-group\";\nexport * from \"./subnet\";\nexport * from \"./peer\";\nexport * from \"./volume\";\nexport * from \"./vpc\";\nexport * from \"./vpc-lookup\";\nexport * from \"./vpn\";\nexport * from \"./vpc-endpoint\";\nexport * from \"./vpc-endpoint-service\";\nexport * from \"./user-data\";\nexport * from \"./windows-versions\";\nexport * from \"./vpc-flow-logs\";\nexport * from \"./client-vpn-endpoint-types\";\nexport * from \"./client-vpn-endpoint\";\nexport * from \"./client-vpn-authorization-rule\";\nexport * from \"./client-vpn-route\";\nexport * from \"./ip-addresses\";\nexport * from \"./machine-image\";\nexport * from \"./placement-group\";\nexport * from \"./key-pair\";\n// ec2-alpha\nexport * as alpha from \"./index-alpha\";\n\n// elasticloadbalancing\nexport * from \"./load-balancer\";\n// elasticloadbalancingv2\nexport * from \"./alb/application-listener\";\nexport * from \"./alb/application-listener-certificate\";\nexport * from \"./alb/application-listener-rule\";\nexport * from \"./alb/application-load-balancer\";\nexport * from \"./alb/application-target-group\";\nexport * from \"./alb/application-listener-action\";\nexport * from \"./alb/conditions\";\nexport * from \"./alb/trust-store\";\nexport * from \"./alb/trust-store-revocation\";\n\nexport * from \"./nlb/network-listener\";\nexport * from \"./nlb/network-load-balancer\";\nexport * from \"./nlb/network-target-group\";\nexport * from \"./nlb/network-listener-action\";\n\n// elasticloadbalancingv2-targets\nexport * as lbtargets from \"./lb-targets\";\n\n// autoscaling-common\nexport * as autoscalingcommon from \"./autoscaling-common\";\n\n// appautoscaling\nexport * from \"./base-scalable-attribute\";\nexport * from \"./schedule\";\nexport * from \"./scalable-target\";\nexport * from \"./step-scaling-policy\";\nexport * from \"./step-scaling-action\";\nexport * from \"./target-tracking-scaling-policy\";\n\n// temp export, required by base types\nexport * from \"./lb-shared/grid-lookup-types\";\nexport * from \"./lb-shared/base-listener\";\nexport * from \"./lb-shared/base-load-balancer\";\nexport * from \"./lb-shared/base-target-group\";\nexport * from \"./lb-shared/enums\";\nexport * from \"./lb-shared/load-balancer-targets\";\nexport * from \"./lb-shared/listener-certificate\";\nexport * from \"./lb-shared/listener-action\";\nexport * from \"./lb-shared/lb-listener-config.generated\";\nexport * from \"./lb-shared/lb-target-group-attachment-config.generated\";\n\nexport * as sources from \"./event-sources\";\nexport * as destinations from \"./function-destinations\";\nexport * as tasks from \"./tasks\"; // State Machine Tasks\n\n// API Gateway\nexport * from \"./restapi\";\nexport * from \"./resource\";\nexport * from \"./method\";\nexport * from \"./integration\";\nexport * from \"./deployment\";\nexport * from \"./stage\";\nexport * from \"./integrations\";\nexport * from \"./lambda-api\";\nexport * from \"./api-key\";\nexport * from \"./usage-plan\";\nexport * from \"./vpc-link\";\nexport * from \"./methodresponse\";\nexport * from \"./model\";\nexport * from \"./requestvalidator\";\nexport * from \"./authorizer\";\nexport * from \"./json-schema\";\nexport * from \"./domain-name\";\nexport * from \"./base-path-mapping\";\nexport * from \"./cors\";\nexport * from \"./authorizers\";\nexport * from \"./access-log\";\nexport * from \"./api-definition\";\nexport * from \"./gateway-response\";\nexport * from \"./stepfunctions-api\";\n\n// generated by JSII Struct builder to please JSII pacman\nexport * from \"./function-vpc-config.generated\";\n\nimport \"./ec2-augmentations.generated\";\nimport \"./lambda-augmentations.generated\";\n"]}