terraconstructs 0.0.24 → 0.1.0

package/lib/aws/compute/api-key.d.ts

@@ -0,0 +1,184 @@
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "..";
+import { IRestApi } from "./restapi";
+import { IStage } from "./stage";
+import { QuotaSettings, ThrottleSettings, UsagePlan, UsagePlanPerApiStage } from "./usage-plan";
+import * as iam from "../iam";
+/**
+ * API keys are alphanumeric string values that you distribute to
+ * app developer customers to grant access to your API
+ */
+export interface IApiKey extends IAwsConstruct {
+    /**
+     * The API key ID.
+     * @attribute
+     */
+    readonly keyId: string;
+    /**
+     * The API key ARN.
+     */
+    readonly keyArn: string;
+}
+/**
+ * The options for creating an API Key.
+ */
+export interface ApiKeyOptions extends AwsConstructProps {
+    /**
+     * A name for the API key. If you don't specify a name, AWS CloudFormation generates a unique physical ID and uses that ID for the API key name.
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-name
+     * @default automically generated name
+     */
+    readonly apiKeyName?: string;
+    /**
+     * The value of the API key. Must be at least 20 characters long.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-value
+     * @default none
+     */
+    readonly value?: string;
+    /**
+     * A description of the purpose of the API key.
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-description
+     * @default none
+     */
+    readonly description?: string;
+}
+/**
+ * ApiKey Properties.
+ */
+export interface ApiKeyProps extends ApiKeyOptions {
+    /**
+     * A list of resources this api key is associated with.
+     * Note: This property is not used by the ApiKey construct itself as direct stage association is deprecated.
+     * Stage association is handled via Usage Plans.
+     * It is kept for compatibility with RateLimitedApiKeyProps.
+     * @default none
+     * @deprecated - use `stages` instead, and associate via a UsagePlan.
+     */
+    readonly resources?: IRestApi[];
+    /**
+     * A list of Stages this api key is associated with.
+     * Note: This property is not used by the ApiKey construct itself as direct stage association is deprecated.
+     * Stage association is handled via Usage Plans.
+     * It is kept for compatibility with RateLimitedApiKeyProps.
+     * @default - the api key is not associated with any stages
+     */
+    readonly stages?: IStage[];
+    /**
+     * An AWS Marketplace customer identifier to use when integrating with the AWS SaaS Marketplace.
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-customerid
+     * @default none
+     */
+    readonly customerId?: string;
+    /**
+     * Indicates whether the API key can be used by clients.
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-enabled
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * Specifies whether the key identifier is distinct from the created API key value.
+     * This property is deprecated and not supported in the TerraConstruct.
+     * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-generatedistinctid
+     * @default false
+     * @deprecated This property is deprecated and not used.
+     */
+    readonly generateDistinctId?: boolean;
+}
+/**
+ * Base implementation that is common to the various implementations of IApiKey
+ */
+declare abstract class ApiKeyBase extends AwsConstructBase implements IApiKey {
+    abstract readonly keyId: string;
+    abstract readonly keyArn: string;
+    get outputs(): Record<string, any>;
+    /**
+     * Permits the IAM principal all read operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Permits the IAM principal all write operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Permits the IAM principal all read and write operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantReadWrite(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * An API Gateway ApiKey.
+ *
+ * An ApiKey can be distributed to API clients that are executing requests
+ * for Method resources that require an Api Key.
+ *
+ * @resource aws_api_gateway_api_key
+ */
+export declare class ApiKey extends ApiKeyBase {
+    /**
+     * Import an ApiKey by its Id
+     */
+    static fromApiKeyId(scope: Construct, id: string, apiKeyId: string): IApiKey;
+    readonly keyId: string;
+    readonly keyArn: string;
+    /**
+     * Auto created Usage Plan for backwards compatibility.
+     * Since August 11, 2016 usage plans are now required to associate an API key with an API stage.
+     *
+     * Note: This property may be udnefined as direct stage association is deprecated.
+     * Stage association is handled via Usage Plans instead.
+     * It is kept for compatibility with RateLimitedApiKeyProps.
+     */
+    readonly usagePlan?: UsagePlan;
+    private readonly resource;
+    constructor(scope: Construct, id: string, props?: ApiKeyProps);
+    /**
+     * Render the stage keys for the ApiKey.
+     * This method handles the association of the ApiKey with either
+     * RestApi resources or Stages, depending on the provided parameters.
+     *
+     * @param resources - Optional list of RestApi resources to associate with the ApiKey.
+     * @param stages - Optional list of Stages to associate with the ApiKey.
+     */
+    private renderStageKeys;
+}
+/**
+ * RateLimitedApiKey properties.
+ */
+export interface RateLimitedApiKeyProps extends ApiKeyProps {
+    /**
+     * API Stages to be associated with the RateLimitedApiKey.
+     * If you already prepared UsagePlan resource explicitly, you should use `stages` property.
+     * If you prefer to prepare UsagePlan resource implicitly via RateLimitedApiKey,
+     * or you should specify throttle settings at each stage individually, you should use `apiStages` property.
+     *
+     * @default none
+     */
+    readonly apiStages?: UsagePlanPerApiStage[];
+    /**
+     * Number of requests clients can make in a given time period.
+     * @default none
+     */
+    readonly quota?: QuotaSettings;
+    /**
+     * Overall throttle settings for the API.
+     * @default none
+     */
+    readonly throttle?: ThrottleSettings;
+}
+/**
+ * An API Gateway ApiKey, for which a rate limiting configuration can be specified.
+ *
+ * @resource aws_api_gateway_api_key
+ */
+export declare class RateLimitedApiKey extends ApiKeyBase {
+    readonly keyId: string;
+    readonly keyArn: string;
+    readonly apiKey: ApiKey;
+    constructor(scope: Construct, id: string, props?: RateLimitedApiKeyProps);
+}
+export {};

package/lib/aws/compute/api-key.js

@@ -0,0 +1,197 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitedApiKey = exports.ApiKey = 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 __1 = require("..");
+const usage_plan_1 = require("./usage-plan");
+const iam = require("../iam");
+/**
+ * Base implementation that is common to the various implementations of IApiKey
+ */
+class ApiKeyBase extends __1.AwsConstructBase {
+    get outputs() {
+        return {
+            keyId: this.keyId,
+            keyArn: this.keyArn,
+        };
+    }
+    /**
+     * Permits the IAM principal all read operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantRead(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: readPermissions,
+            resourceArns: [this.keyArn],
+        });
+    }
+    /**
+     * Permits the IAM principal all write operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantWrite(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: writePermissions,
+            resourceArns: [this.keyArn],
+        });
+    }
+    /**
+     * Permits the IAM principal all read and write operations through this key
+     *
+     * @param grantee The principal to grant access to
+     */
+    grantReadWrite(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: [...readPermissions, ...writePermissions],
+            resourceArns: [this.keyArn],
+        });
+    }
+}
+/**
+ * An API Gateway ApiKey.
+ *
+ * An ApiKey can be distributed to API clients that are executing requests
+ * for Method resources that require an Api Key.
+ *
+ * @resource aws_api_gateway_api_key
+ */
+class ApiKey extends ApiKeyBase {
+    /**
+     * Import an ApiKey by its Id
+     */
+    static fromApiKeyId(scope, id, apiKeyId) {
+        class Import extends ApiKeyBase {
+            constructor() {
+                super(...arguments);
+                this.keyId = apiKeyId;
+                this.keyArn = this.stack.formatArn({
+                    service: "apigateway",
+                    account: "", // API Key ARNs typically don't include account ID in this segment
+                    resource: "/apikeys",
+                    arnFormat: __1.ArnFormat.SLASH_RESOURCE_NAME,
+                    resourceName: apiKeyId,
+                });
+            }
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        const name = props.apiKeyName ?? this.stack.uniqueResourceName(this);
+        this.resource = new provider_aws_1.apiGatewayApiKey.ApiGatewayApiKey(this, "Resource", {
+            name,
+            customerId: props.customerId,
+            description: props.description,
+            enabled: props.enabled ?? true,
+            value: props.value,
+        });
+        this.keyId = this.resource.id;
+        this.keyArn = this.resource.arn;
+        // copy legacy renderStageKeys logic from AWSCDK for ease of migration.
+        this.usagePlan = this.renderStageKeys(props.resources, props.stages);
+    }
+    /**
+     * Render the stage keys for the ApiKey.
+     * This method handles the association of the ApiKey with either
+     * RestApi resources or Stages, depending on the provided parameters.
+     *
+     * @param resources - Optional list of RestApi resources to associate with the ApiKey.
+     * @param stages - Optional list of Stages to associate with the ApiKey.
+     */
+    renderStageKeys(resources, stages) {
+        if (!resources && !stages) {
+            return undefined;
+        }
+        if (resources && stages) {
+            // throw new ValidationError(
+            throw new Error(`Only one of "resources" or "stages" should be provided. (${this.node.path})`);
+        }
+        if (resources) {
+            // Handle Deprecated case of associating ApiKey with RestApi resources
+            // This creates a single Usage Plan for all stages, but is deprecated.
+            const apiStages = [];
+            resources.forEach((resource) => {
+                const restApi = resource;
+                if (!restApi.deploymentStage) {
+                    // throw new ValidationError(
+                    throw new Error('Cannot add an ApiKey to a RestApi that does not contain a "deploymentStage".\n' +
+                        "Either set the RestApi.deploymentStage or create an ApiKey from a Stage");
+                }
+                apiStages.push({
+                    api: restApi,
+                    stage: restApi.deploymentStage,
+                });
+            });
+            const usagePlan = new usage_plan_1.UsagePlan(this, "UsagePlan", {
+                apiStages,
+                name: `${this.resource.nameInput}-usage-plan`,
+                description: `Usage Plan for ${this.friendlyName}`,
+            });
+            usagePlan.addApiKey(this);
+            return usagePlan;
+        }
+        if (stages && stages.length > 0) {
+            // Handle Deprecated case of associating ApiKey with multiple Stages
+            // This creates a single Usage Plan for all stages, but is also deprecated.
+            const usagePlan = new usage_plan_1.UsagePlan(this, `UsagePlan`, {
+                apiStages: stages.map((stage) => ({
+                    api: stage.restApi,
+                    // NOTE: UsagePlanPerApiStage expects Stage instead of IStage
+                    // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/usage-plan.ts#L97-L102
+                    stage: stage,
+                })),
+            });
+            usagePlan.addApiKey(this);
+            return usagePlan;
+        }
+        return undefined;
+    }
+}
+exports.ApiKey = ApiKey;
+_a = JSII_RTTI_SYMBOL_1;
+ApiKey[_a] = { fqn: "terraconstructs.aws.compute.ApiKey", version: "0.1.0" };
+/**
+ * An API Gateway ApiKey, for which a rate limiting configuration can be specified.
+ *
+ * @resource aws_api_gateway_api_key
+ */
+class RateLimitedApiKey extends ApiKeyBase {
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.apiKey = new ApiKey(this, "Resource", props);
+        if (props.apiStages || props.quota || props.throttle) {
+            if (this.apiKey.usagePlan) {
+                // NOTE: Creating an additional usage plan is default AWSCDK behavior.
+                // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/api-key.ts#L268-L275
+                cdktf_1.Annotations.of(this.apiKey).addWarning("UsagePlan is already created for this ApiKey. A separate UsagePlan with rate limiting will be created separately");
+            }
+            const usagePlan = new usage_plan_1.UsagePlan(this, "RateLimitedUsagePlan", {
+                apiStages: props.apiStages,
+                quota: props.quota,
+                throttle: props.throttle,
+            });
+            usagePlan.addApiKey(this.apiKey);
+        }
+        this.keyId = this.apiKey.keyId;
+        this.keyArn = this.apiKey.keyArn;
+    }
+}
+exports.RateLimitedApiKey = RateLimitedApiKey;
+_b = JSII_RTTI_SYMBOL_1;
+RateLimitedApiKey[_b] = { fqn: "terraconstructs.aws.compute.RateLimitedApiKey", version: "0.1.0" };
+const readPermissions = ["apigateway:GET"];
+const writePermissions = [
+    "apigateway:POST",
+    "apigateway:PUT",
+    "apigateway:PATCH",
+    "apigateway:DELETE",
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-key.js","sourceRoot":"","sources":["../../../src/aws/compute/api-key.ts"],"names":[],"mappings":";;;;;AAAA,sDAAuD;AACvD,iCAAoC;AAEpC,0BAKY;AAGZ,6CAKsB;AACtB,8BAA8B;AA4F9B;;GAEG;AACH,MAAe,UAAW,SAAQ,oBAAgB;IAIhD,IAAW,OAAO;QAChB,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,SAAS,CAAC,OAAuB;QACtC,OAAO,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC;YAC9B,OAAO;YACP,OAAO,EAAE,eAAe;YACxB,YAAY,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;SAC5B,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,UAAU,CAAC,OAAuB;QACvC,OAAO,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC;YAC9B,OAAO;YACP,OAAO,EAAE,gBAAgB;YACzB,YAAY,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;SAC5B,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,OAAuB;QAC3C,OAAO,GAAG,CAAC,KAAK,CAAC,cAAc,CAAC;YAC9B,OAAO;YACP,OAAO,EAAE,CAAC,GAAG,eAAe,EAAE,GAAG,gBAAgB,CAAC;YAClD,YAAY,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;SAC5B,CAAC,CAAC;IACL,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAa,MAAO,SAAQ,UAAU;IACpC;;OAEG;IACI,MAAM,CAAC,YAAY,CACxB,KAAgB,EAChB,EAAU,EACV,QAAgB;QAEhB,MAAM,MAAO,SAAQ,UAAU;YAA/B;;gBACS,UAAK,GAAG,QAAQ,CAAC;gBACjB,WAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;oBACnC,OAAO,EAAE,YAAY;oBACrB,OAAO,EAAE,EAAE,EAAE,kEAAkE;oBAC/E,QAAQ,EAAE,UAAU;oBACpB,SAAS,EAAE,aAAS,CAAC,mBAAmB;oBACxC,YAAY,EAAE,QAAQ;iBACvB,CAAC,CAAC;YACL,CAAC;SAAA;QAED,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/B,CAAC;IAeD,YAAY,KAAgB,EAAE,EAAU,EAAE,QAAqB,EAAE;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAErE,IAAI,CAAC,QAAQ,GAAG,IAAI,+BAAgB,CAAC,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE;YACtE,IAAI;YACJ,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;YAC9B,KAAK,EAAE,KAAK,CAAC,KAAK;SACnB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAEhC,uEAAuE;QACvE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvE,CAAC;IAED;;;;;;;OAOG;IACK,eAAe,CACrB,SAAsB,EACtB,MAAiB;QAEjB,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;YACxB,6BAA6B;YAC7B,MAAM,IAAI,KAAK,CACb,4DAA4D,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,CAE9E,CAAC;QACJ,CAAC;QAED,IAAI,SAAS,EAAE,CAAC;YACd,sEAAsE;YACtE,sEAAsE;YACtE,MAAM,SAAS,GAA2B,EAAE,CAAC;YAC7C,SAAS,CAAC,OAAO,CAAC,CAAC,QAAkB,EAAE,EAAE;gBACvC,MAAM,OAAO,GAAG,QAAQ,CAAC;gBACzB,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;oBAC7B,6BAA6B;oBAC7B,MAAM,IAAI,KAAK,CACb,gFAAgF;wBAC9E,yEAAyE,CAE5E,CAAC;gBACJ,CAAC;gBACD,SAAS,CAAC,IAAI,CAAC;oBACb,GAAG,EAAE,OAAO;oBACZ,KAAK,EAAE,OAAO,CAAC,eAAe;iBAC/B,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,MAAM,SAAS,GAAG,IAAI,sBAAS,CAAC,IAAI,EAAE,WAAW,EAAE;gBACjD,SAAS;gBACT,IAAI,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,aAAa;gBAC7C,WAAW,EAAE,kBAAkB,IAAI,CAAC,YAAY,EAAE;aACnD,CAAC,CAAC;YACH,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC1B,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChC,oEAAoE;YACpE,2EAA2E;YAC3E,MAAM,SAAS,GAAG,IAAI,sBAAS,CAAC,IAAI,EAAE,WAAW,EAAE;gBACjD,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;oBAChC,GAAG,EAAE,KAAK,CAAC,OAAO;oBAClB,6DAA6D;oBAC7D,8GAA8G;oBAC9G,KAAK,EAAE,KAAc;iBACtB,CAAC,CAAC;aACJ,CAAC,CAAC;YACH,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC1B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;;AA3HH,wBA4HC;;;AA6BD;;;;GAIG;AACH,MAAa,iBAAkB,SAAQ,UAAU;IAK/C,YACE,KAAgB,EAChB,EAAU,EACV,QAAgC,EAAE;QAElC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QAElD,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrD,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC1B,sEAAsE;gBACtE,4GAA4G;gBAC5G,mBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,UAAU,CACpC,kHAAkH,CACnH,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GAAG,IAAI,sBAAS,CAAC,IAAI,EAAE,sBAAsB,EAAE;gBAC5D,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,KAAK,EAAE,KAAK,CAAC,KAAK;gBAClB,QAAQ,EAAE,KAAK,CAAC,QAAQ;aACzB,CAAC,CAAC;YACH,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;IACnC,CAAC;;AAhCH,8CAiCC;;;AAED,MAAM,eAAe,GAAG,CAAC,gBAAgB,CAAC,CAAC;AAE3C,MAAM,gBAAgB,GAAG;IACvB,iBAAiB;IACjB,gBAAgB;IAChB,kBAAkB;IAClB,mBAAmB;CACpB,CAAC","sourcesContent":["import { apiGatewayApiKey } from \"@cdktf/provider-aws\";\nimport { Annotations } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ArnFormat,\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"..\";\nimport { IRestApi } from \"./restapi\";\nimport { IStage, Stage } from \"./stage\";\nimport {\n  QuotaSettings,\n  ThrottleSettings,\n  UsagePlan,\n  UsagePlanPerApiStage,\n} from \"./usage-plan\";\nimport * as iam from \"../iam\";\n\n/**\n * API keys are alphanumeric string values that you distribute to\n * app developer customers to grant access to your API\n */\nexport interface IApiKey extends IAwsConstruct {\n  /**\n   * The API key ID.\n   * @attribute\n   */\n  readonly keyId: string;\n\n  /**\n   * The API key ARN.\n   */\n  readonly keyArn: string;\n}\n\n/**\n * The options for creating an API Key.\n */\nexport interface ApiKeyOptions extends AwsConstructProps {\n  /**\n   * A name for the API key. If you don't specify a name, AWS CloudFormation generates a unique physical ID and uses that ID for the API key name.\n   * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-name\n   * @default automically generated name\n   */\n  readonly apiKeyName?: string;\n\n  /**\n   * The value of the API key. Must be at least 20 characters long.\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-value\n   * @default none\n   */\n  readonly value?: string;\n\n  /**\n   * A description of the purpose of the API key.\n   * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-description\n   * @default none\n   */\n  readonly description?: string;\n}\n\n/**\n * ApiKey Properties.\n */\nexport interface ApiKeyProps extends ApiKeyOptions {\n  /**\n   * A list of resources this api key is associated with.\n   * Note: This property is not used by the ApiKey construct itself as direct stage association is deprecated.\n   * Stage association is handled via Usage Plans.\n   * It is kept for compatibility with RateLimitedApiKeyProps.\n   * @default none\n   * @deprecated - use `stages` instead, and associate via a UsagePlan.\n   */\n  readonly resources?: IRestApi[];\n\n  /**\n   * A list of Stages this api key is associated with.\n   * Note: This property is not used by the ApiKey construct itself as direct stage association is deprecated.\n   * Stage association is handled via Usage Plans.\n   * It is kept for compatibility with RateLimitedApiKeyProps.\n   * @default - the api key is not associated with any stages\n   */\n  readonly stages?: IStage[];\n\n  /**\n   * An AWS Marketplace customer identifier to use when integrating with the AWS SaaS Marketplace.\n   * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-customerid\n   * @default none\n   */\n  readonly customerId?: string;\n\n  /**\n   * Indicates whether the API key can be used by clients.\n   * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-enabled\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Specifies whether the key identifier is distinct from the created API key value.\n   * This property is deprecated and not supported in the TerraConstruct.\n   * @link http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-apigateway-apikey.html#cfn-apigateway-apikey-generatedistinctid\n   * @default false\n   * @deprecated This property is deprecated and not used.\n   */\n  readonly generateDistinctId?: boolean;\n}\n\n/**\n * Base implementation that is common to the various implementations of IApiKey\n */\nabstract class ApiKeyBase extends AwsConstructBase implements IApiKey {\n  public abstract readonly keyId: string;\n  public abstract readonly keyArn: string;\n\n  public get outputs(): Record<string, any> {\n    return {\n      keyId: this.keyId,\n      keyArn: this.keyArn,\n    };\n  }\n\n  /**\n   * Permits the IAM principal all read operations through this key\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: readPermissions,\n      resourceArns: [this.keyArn],\n    });\n  }\n\n  /**\n   * Permits the IAM principal all write operations through this key\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantWrite(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: writePermissions,\n      resourceArns: [this.keyArn],\n    });\n  }\n\n  /**\n   * Permits the IAM principal all read and write operations through this key\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantReadWrite(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [...readPermissions, ...writePermissions],\n      resourceArns: [this.keyArn],\n    });\n  }\n}\n\n/**\n * An API Gateway ApiKey.\n *\n * An ApiKey can be distributed to API clients that are executing requests\n * for Method resources that require an Api Key.\n *\n * @resource aws_api_gateway_api_key\n */\nexport class ApiKey extends ApiKeyBase {\n  /**\n   * Import an ApiKey by its Id\n   */\n  public static fromApiKeyId(\n    scope: Construct,\n    id: string,\n    apiKeyId: string,\n  ): IApiKey {\n    class Import extends ApiKeyBase {\n      public keyId = apiKeyId;\n      public keyArn = this.stack.formatArn({\n        service: \"apigateway\",\n        account: \"\", // API Key ARNs typically don't include account ID in this segment\n        resource: \"/apikeys\",\n        arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n        resourceName: apiKeyId,\n      });\n    }\n\n    return new Import(scope, id);\n  }\n\n  public readonly keyId: string;\n  public readonly keyArn: string;\n  /**\n   * Auto created Usage Plan for backwards compatibility.\n   * Since August 11, 2016 usage plans are now required to associate an API key with an API stage.\n   *\n   * Note: This property may be udnefined as direct stage association is deprecated.\n   * Stage association is handled via Usage Plans instead.\n   * It is kept for compatibility with RateLimitedApiKeyProps.\n   */\n  public readonly usagePlan?: UsagePlan;\n  private readonly resource: apiGatewayApiKey.ApiGatewayApiKey;\n\n  constructor(scope: Construct, id: string, props: ApiKeyProps = {}) {\n    super(scope, id, props);\n\n    const name = props.apiKeyName ?? this.stack.uniqueResourceName(this);\n\n    this.resource = new apiGatewayApiKey.ApiGatewayApiKey(this, \"Resource\", {\n      name,\n      customerId: props.customerId,\n      description: props.description,\n      enabled: props.enabled ?? true,\n      value: props.value,\n    });\n    this.keyId = this.resource.id;\n    this.keyArn = this.resource.arn;\n\n    // copy legacy renderStageKeys logic from AWSCDK for ease of migration.\n    this.usagePlan = this.renderStageKeys(props.resources, props.stages);\n  }\n\n  /**\n   * Render the stage keys for the ApiKey.\n   * This method handles the association of the ApiKey with either\n   * RestApi resources or Stages, depending on the provided parameters.\n   *\n   * @param resources - Optional list of RestApi resources to associate with the ApiKey.\n   * @param stages - Optional list of Stages to associate with the ApiKey.\n   */\n  private renderStageKeys(\n    resources?: IRestApi[],\n    stages?: IStage[],\n  ): UsagePlan | undefined {\n    if (!resources && !stages) {\n      return undefined;\n    }\n\n    if (resources && stages) {\n      // throw new ValidationError(\n      throw new Error(\n        `Only one of \"resources\" or \"stages\" should be provided. (${this.node.path})`,\n        // this,\n      );\n    }\n\n    if (resources) {\n      // Handle Deprecated case of associating ApiKey with RestApi resources\n      // This creates a single Usage Plan for all stages, but is deprecated.\n      const apiStages: UsagePlanPerApiStage[] = [];\n      resources.forEach((resource: IRestApi) => {\n        const restApi = resource;\n        if (!restApi.deploymentStage) {\n          // throw new ValidationError(\n          throw new Error(\n            'Cannot add an ApiKey to a RestApi that does not contain a \"deploymentStage\".\\n' +\n              \"Either set the RestApi.deploymentStage or create an ApiKey from a Stage\",\n            // this,\n          );\n        }\n        apiStages.push({\n          api: restApi,\n          stage: restApi.deploymentStage,\n        });\n      });\n\n      const usagePlan = new UsagePlan(this, \"UsagePlan\", {\n        apiStages,\n        name: `${this.resource.nameInput}-usage-plan`,\n        description: `Usage Plan for ${this.friendlyName}`,\n      });\n      usagePlan.addApiKey(this);\n      return usagePlan;\n    }\n\n    if (stages && stages.length > 0) {\n      // Handle Deprecated case of associating ApiKey with multiple Stages\n      // This creates a single Usage Plan for all stages, but is also deprecated.\n      const usagePlan = new UsagePlan(this, `UsagePlan`, {\n        apiStages: stages.map((stage) => ({\n          api: stage.restApi,\n          // NOTE: UsagePlanPerApiStage expects Stage instead of IStage\n          // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/usage-plan.ts#L97-L102\n          stage: stage as Stage,\n        })),\n      });\n      usagePlan.addApiKey(this);\n      return usagePlan;\n    }\n    return undefined;\n  }\n}\n\n/**\n * RateLimitedApiKey properties.\n */\nexport interface RateLimitedApiKeyProps extends ApiKeyProps {\n  /**\n   * API Stages to be associated with the RateLimitedApiKey.\n   * If you already prepared UsagePlan resource explicitly, you should use `stages` property.\n   * If you prefer to prepare UsagePlan resource implicitly via RateLimitedApiKey,\n   * or you should specify throttle settings at each stage individually, you should use `apiStages` property.\n   *\n   * @default none\n   */\n  readonly apiStages?: UsagePlanPerApiStage[];\n\n  /**\n   * Number of requests clients can make in a given time period.\n   * @default none\n   */\n  readonly quota?: QuotaSettings;\n\n  /**\n   * Overall throttle settings for the API.\n   * @default none\n   */\n  readonly throttle?: ThrottleSettings;\n}\n\n/**\n * An API Gateway ApiKey, for which a rate limiting configuration can be specified.\n *\n * @resource aws_api_gateway_api_key\n */\nexport class RateLimitedApiKey extends ApiKeyBase {\n  public readonly keyId: string;\n  public readonly keyArn: string;\n  public readonly apiKey: ApiKey;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: RateLimitedApiKeyProps = {},\n  ) {\n    super(scope, id, props);\n\n    this.apiKey = new ApiKey(this, \"Resource\", props);\n\n    if (props.apiStages || props.quota || props.throttle) {\n      if (this.apiKey.usagePlan) {\n        // NOTE: Creating an additional usage plan is default AWSCDK behavior.\n        // https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-apigateway/lib/api-key.ts#L268-L275\n        Annotations.of(this.apiKey).addWarning(\n          \"UsagePlan is already created for this ApiKey. A separate UsagePlan with rate limiting will be created separately\",\n        );\n      }\n      const usagePlan = new UsagePlan(this, \"RateLimitedUsagePlan\", {\n        apiStages: props.apiStages,\n        quota: props.quota,\n        throttle: props.throttle,\n      });\n      usagePlan.addApiKey(this.apiKey);\n    }\n\n    this.keyId = this.apiKey.keyId;\n    this.keyArn = this.apiKey.keyArn;\n  }\n}\n\nconst readPermissions = [\"apigateway:GET\"];\n\nconst writePermissions = [\n  \"apigateway:POST\",\n  \"apigateway:PUT\",\n  \"apigateway:PATCH\",\n  \"apigateway:DELETE\",\n];\n"]}

package/lib/aws/compute/apigateway-canned-metrics.generated.d.ts

@@ -0,0 +1,169 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class ApiGatewayMetrics {
+    static _4XxErrorSum(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static _4XxErrorSum(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static _4XxErrorSum(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static _5XxErrorSum(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static _5XxErrorSum(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static _5XxErrorSum(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static cacheHitCountSum(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static cacheHitCountSum(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static cacheHitCountSum(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static cacheMissCountSum(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static cacheMissCountSum(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static cacheMissCountSum(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static countSum(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static countSum(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static countSum(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static integrationLatencyAverage(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static integrationLatencyAverage(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static integrationLatencyAverage(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+    static latencyAverage(dimensions: {
+        ApiName: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Stage: string;
+    }>;
+    static latencyAverage(dimensions: {
+        ApiName: string;
+    }): MetricWithDims<{
+        ApiName: string;
+    }>;
+    static latencyAverage(dimensions: {
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }): MetricWithDims<{
+        ApiName: string;
+        Method: string;
+        Resource: string;
+        Stage: string;
+    }>;
+}

package/lib/aws/compute/apigateway-canned-metrics.generated.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiGatewayMetrics = void 0;
+class ApiGatewayMetrics {
+    static _4XxErrorSum(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "4XXError",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static _5XxErrorSum(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "5XXError",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static cacheHitCountSum(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "CacheHitCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static cacheMissCountSum(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "CacheMissCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static countSum(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "Count",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static integrationLatencyAverage(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "IntegrationLatency",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+    static latencyAverage(dimensions) {
+        return {
+            "namespace": "AWS/ApiGateway",
+            "metricName": "Latency",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+}
+exports.ApiGatewayMetrics = ApiGatewayMetrics;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apigateway-canned-metrics.generated.js","sourceRoot":"","sources":["../../../src/aws/compute/apigateway-canned-metrics.generated.ts"],"names":[],"mappings":";;;AAWA,MAAa,iBAAiB;IAOrB,MAAM,CAAC,YAAY,CAAC,UAAe;QACxC,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,UAAU;YACxB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,YAAY,CAAC,UAAe;QACxC,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,UAAU;YACxB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,gBAAgB,CAAC,UAAe;QAC5C,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,eAAe;YAC7B,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,iBAAiB,CAAC,UAAe;QAC7C,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,gBAAgB;YAC9B,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,QAAQ,CAAC,UAAe;QACpC,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,OAAO;YACrB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,KAAK;SACnB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,yBAAyB,CAAC,UAAe;QACrD,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,oBAAoB;YAClC,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,SAAS;SACvB,CAAC;IACJ,CAAC;IAQM,MAAM,CAAC,cAAc,CAAC,UAAe;QAC1C,OAAO;YACL,WAAW,EAAE,gBAAgB;YAC7B,YAAY,EAAE,SAAS;YACvB,eAAe,EAAE,UAAU;YAC3B,WAAW,EAAE,SAAS;SACvB,CAAC;IACJ,CAAC;CACF;AAzGD,8CAyGC","sourcesContent":["/* eslint-disable prettier/prettier,max-len */\nexport interface MetricWithDims<D> {\n  readonly namespace: string;\n\n  readonly metricName: string;\n\n  readonly statistic: string;\n\n  readonly dimensionsMap: D;\n}\n\nexport class ApiGatewayMetrics {\n  public static _4XxErrorSum(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static _4XxErrorSum(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static _4XxErrorSum(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static _4XxErrorSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"4XXError\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static _5XxErrorSum(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static _5XxErrorSum(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static _5XxErrorSum(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static _5XxErrorSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"5XXError\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static cacheHitCountSum(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static cacheHitCountSum(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static cacheHitCountSum(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static cacheHitCountSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"CacheHitCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static cacheMissCountSum(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static cacheMissCountSum(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static cacheMissCountSum(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static cacheMissCountSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"CacheMissCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static countSum(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static countSum(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static countSum(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static countSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"Count\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static integrationLatencyAverage(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static integrationLatencyAverage(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static integrationLatencyAverage(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static integrationLatencyAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"IntegrationLatency\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n\n  public static latencyAverage(dimensions: { ApiName: string; Stage: string; }): MetricWithDims<{ ApiName: string; Stage: string; }>;\n\n  public static latencyAverage(dimensions: { ApiName: string; }): MetricWithDims<{ ApiName: string; }>;\n\n  public static latencyAverage(dimensions: { ApiName: string; Method: string; Resource: string; Stage: string; }): MetricWithDims<{ ApiName: string; Method: string; Resource: string; Stage: string; }>;\n\n  public static latencyAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ApiGateway\",\n      \"metricName\": \"Latency\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n}"]}