terraconstructs 0.0.10 → 0.0.12

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

@@ -0,0 +1,194 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyPair = exports.KeyPairType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/key-pair.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const provider_tls_1 = require("@cdktf/provider-tls");
+const cdktf_1 = require("cdktf");
+const machine_image_1 = require("./machine-image");
+const aws_construct_1 = require("../aws-construct");
+const parameter_1 = require("../storage/parameter");
+// /**
+//  * The format of the Key Pair
+//  */
+// export enum KeyPairFormat {
+//   /**
+//    * A PPK file, typically used with PuTTY.
+//    */
+//   PPK = "ppk",
+//   /**
+//    * A PEM file.
+//    */
+//   PEM = "pem",
+// }
+/**
+ * The type of the key pair.
+ */
+var KeyPairType;
+(function (KeyPairType) {
+    /**
+     * An RSA key.
+     */
+    KeyPairType["RSA"] = "rsa";
+    /**
+     * An ED25519 key.
+     *
+     * Note that ED25519 keys are not supported for Windows instances.
+     */
+    KeyPairType["ED25519"] = "ed25519";
+})(KeyPairType || (exports.KeyPairType = KeyPairType = {}));
+/**
+ * An EC2 Key Pair.
+ *
+ * @resource AWS::EC2::KeyPair
+ */
+class KeyPair extends aws_construct_1.AwsConstructBase {
+    /**
+     * Imports a key pair based on the name.
+     */
+    static fromKeyPairName(scope, id, keyPairName) {
+        return KeyPair.fromKeyPairAttributes(scope, id, { keyPairName });
+    }
+    /**
+     * Imports a key pair with a name and optional type.
+     */
+    static fromKeyPairAttributes(scope, id, attrs) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            get keyPairOutputs() {
+                return {
+                    keyPairName: this.keyPairName,
+                    type: this.type,
+                };
+            }
+            get outputs() {
+                return this.keyPairOutputs;
+            }
+            constructor() {
+                super(scope, id);
+                this.keyPairName = attrs.keyPairName;
+                this.type = attrs.type;
+            }
+            /**
+             * Used internally to determine whether the key pair is compatible with an OS type.
+             *
+             * @internal
+             */
+            _isOsCompatible(osType) {
+                switch (this.type) {
+                    case KeyPairType.ED25519:
+                        return osType !== machine_image_1.OperatingSystemType.WINDOWS;
+                    case KeyPairType.RSA:
+                        return true;
+                    default:
+                        return true;
+                }
+            }
+        }
+        return new Import();
+    }
+    get keyPairOutputs() {
+        return {
+            keyPairName: this.keyPairName,
+            type: this.type,
+        };
+    }
+    get outputs() {
+        return this.keyPairOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (props?.keyPairName && props?.keyPairNamePrefix) {
+            throw new Error("Cannot specify both 'keyPairName' and 'keyPairNamePrefix'");
+        }
+        const keyPairNamePrefix = props?.keyPairNamePrefix ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                maxLength: 255,
+            });
+        // Lazy.stringValue({
+        //   produce: () => AwsStack.uniqueResourceName(this, { maxLength: 255 }),
+        // });
+        if (props?.publicKeyMaterial && props?.type) {
+            throw new Error("Cannot specify 'type' for keys with imported material");
+        }
+        this._isImport = !!props?.publicKeyMaterial;
+        const keyType = props?.type ?? KeyPairType.RSA;
+        let publicKey = props?.publicKeyMaterial;
+        if (!publicKey) {
+            let algorithm;
+            switch (keyType) {
+                case KeyPairType.ED25519:
+                    algorithm = "ED25519";
+                    break;
+                case KeyPairType.RSA:
+                default:
+                    algorithm = "RSA";
+            }
+            this._privateKey = new provider_tls_1.privateKey.PrivateKey(this, "PrivateKey", {
+                algorithm,
+            });
+            publicKey = cdktf_1.Fn.trimspace(this._privateKey.publicKeyOpenssh);
+        }
+        this.resource = new provider_aws_1.keyPair.KeyPair(this, "Resource", {
+            keyName: props?.keyPairName,
+            keyNamePrefix: keyPairNamePrefix,
+            // keyFormat: props?.format ?? KeyPairFormat.PEM,
+            publicKey,
+        });
+        if (this._privateKey) {
+            // if privateKey was generated, mimic CFN behavior with SSM
+            this._privateKeySsm = new parameter_1.StringParameter(this, "PrivateKeyParameter", {
+                parameterName: `/ec2/keypair/${this.resource.id}`,
+                description: `Private key for ${this.resource.keyName}`,
+                type: parameter_1.ParameterType.SECURE_STRING,
+                sensitiveStringValue: this._privateKey.privateKeyPem,
+                simpleName: false,
+            });
+        }
+        this.keyPairName = this.resource.keyName;
+        this.keyPairFingerprint = this.resource.fingerprint;
+        this.keyPairId = this.resource.id;
+        this.type = keyType;
+        // this.format = keyFormat;
+    }
+    /**
+     * Whether the key material was imported.
+     *
+     * Keys with imported material do not have their private key material stored
+     * or returned automatically.
+     */
+    get hasImportedMaterial() {
+        return this._isImport;
+    }
+    /**
+     * The Systems Manager Parameter Store parameter with the pair's private key material.
+     */
+    get privateKey() {
+        if (this._isImport) {
+            throw new Error("An SSM parameter with private key material is not created for imported keys");
+        }
+        // else, this is guaranteed to be set
+        return this._privateKeySsm;
+    }
+    /**
+     * Used internally to determine whether the key pair is compatible with an OS type.
+     *
+     * @internal
+     */
+    _isOsCompatible(osType) {
+        switch (this.type) {
+            case KeyPairType.ED25519:
+                return osType !== machine_image_1.OperatingSystemType.WINDOWS;
+            case KeyPairType.RSA:
+                return true;
+            default:
+                return true;
+        }
+    }
+}
+exports.KeyPair = KeyPair;
+_a = JSII_RTTI_SYMBOL_1;
+KeyPair[_a] = { fqn: "terraconstructs.aws.compute.KeyPair", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-pair.js","sourceRoot":"","sources":["../../../src/aws/compute/key-pair.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/key-pair.ts\n\nimport { keyPair as tfKeyPair } from \"@cdktf/provider-aws\";\nimport { privateKey } from \"@cdktf/provider-tls\";\nimport { Fn } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { OperatingSystemType } from \"./machine-image\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  IAwsConstruct,\n} from \"../aws-construct\";\nimport {\n  StringParameter,\n  IStringParameter,\n  ParameterType,\n} from \"../storage/parameter\";\n\n// /**\n//  * The format of the Key Pair\n//  */\n// export enum KeyPairFormat {\n//   /**\n//    * A PPK file, typically used with PuTTY.\n//    */\n//   PPK = \"ppk\",\n\n//   /**\n//    * A PEM file.\n//    */\n//   PEM = \"pem\",\n// }\n\n/**\n * The type of the key pair.\n */\nexport enum KeyPairType {\n  /**\n   * An RSA key.\n   */\n  RSA = \"rsa\",\n\n  /**\n   * An ED25519 key.\n   *\n   * Note that ED25519 keys are not supported for Windows instances.\n   */\n  ED25519 = \"ed25519\",\n}\n\n/**\n * The properties of a Key Pair\n */\nexport interface KeyPairProps extends AwsConstructProps {\n  /**\n   * A unique name for the key pair.\n   *\n   * @default A generated name\n   */\n  readonly keyPairName?: string;\n\n  /**\n   * Creates a unique name beginning with the specified prefix.\n   *\n   * Conflicts with `keyPairName`. If neither `keyPairName` nor `keyPairNamePrefix` is provided,\n   * TerraConstructs will create a unique key name using the `gridUUID` as prefix.\n   *\n   * @default A generated name\n   */\n  readonly keyPairNamePrefix?: string;\n\n  // /**\n  //  * The format of the key pair.\n  //  *\n  //  * @default PEM\n  //  */\n  // readonly format?: KeyPairFormat;\n\n  /**\n   * The type of key pair.\n   *\n   * @default RSA (ignored if keyMaterial is provided)\n   */\n  readonly type?: KeyPairType;\n\n  /**\n   * The public key material.\n   *\n   * If this is provided the key is considered \"imported\". For imported\n   * keys, it is assumed that you already have the private key material\n   * so the private key material will not be returned or stored in\n   * AWS Systems Manager Parameter Store.\n   *\n   * The private key generated by this resource will be stored unencrypted\n   * in your Terraform state file.\n   *\n   * Omitting the publicKeyMaterial for production deployments is not recommended.\n   * Instead, generate a private key file outside of Terraform and distribute it\n   * securely to the system where Terraform will be run.\n   *\n   * @default a public and private key will be generated\n   */\n  readonly publicKeyMaterial?: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface KeyPairOutputs {\n  /**\n   * The unique name of the key pair.\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   *\n   * @default no type specified\n   */\n  readonly type?: KeyPairType;\n}\n\n/**\n * Attributes of a Key Pair.\n */\nexport interface KeyPairAttributes {\n  /**\n   * The unique name of the key pair.\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   *\n   * @default no type specified\n   */\n  readonly type?: KeyPairType;\n}\n\n/**\n * An EC2 Key Pair.\n */\nexport interface IKeyPair extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly keyPairOutputs: KeyPairOutputs;\n\n  /**\n   * The name of the key pair.\n   *\n   * @attribute\n   */\n  readonly keyPairName: string;\n\n  /**\n   * The type of the key pair.\n   */\n  readonly type?: KeyPairType;\n\n  /**\n   * Used internally to determine whether the key pair is compatible with an OS type.\n   *\n   * @internal\n   */\n  _isOsCompatible(osType: OperatingSystemType): boolean;\n}\n\n/**\n * An EC2 Key Pair.\n *\n * @resource AWS::EC2::KeyPair\n */\nexport class KeyPair extends AwsConstructBase implements IKeyPair {\n  /**\n   * Imports a key pair based on the name.\n   */\n  public static fromKeyPairName(\n    scope: Construct,\n    id: string,\n    keyPairName: string,\n  ): IKeyPair {\n    return KeyPair.fromKeyPairAttributes(scope, id, { keyPairName });\n  }\n\n  /**\n   * Imports a key pair with a name and optional type.\n   */\n  public static fromKeyPairAttributes(\n    scope: Construct,\n    id: string,\n    attrs: KeyPairAttributes,\n  ): IKeyPair {\n    class Import extends AwsConstructBase implements IKeyPair {\n      public readonly keyPairName: string;\n      public readonly type?: KeyPairType;\n      public get keyPairOutputs(): KeyPairOutputs {\n        return {\n          keyPairName: this.keyPairName,\n          type: this.type,\n        };\n      }\n      public get outputs(): Record<string, any> {\n        return this.keyPairOutputs;\n      }\n\n      constructor() {\n        super(scope, id);\n        this.keyPairName = attrs.keyPairName;\n        this.type = attrs.type;\n      }\n\n      /**\n       * Used internally to determine whether the key pair is compatible with an OS type.\n       *\n       * @internal\n       */\n      public _isOsCompatible(osType: OperatingSystemType): boolean {\n        switch (this.type) {\n          case KeyPairType.ED25519:\n            return osType !== OperatingSystemType.WINDOWS;\n          case KeyPairType.RSA:\n            return true;\n          default:\n            return true;\n        }\n      }\n    }\n    return new Import();\n  }\n\n  public get keyPairOutputs(): KeyPairOutputs {\n    return {\n      keyPairName: this.keyPairName,\n      type: this.type,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.keyPairOutputs;\n  }\n\n  /**\n   * The unique name of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairName: string;\n\n  /**\n   * The fingerprint of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairFingerprint: string;\n\n  /**\n   * The unique ID of the key pair.\n   *\n   * @attribute\n   */\n  public readonly keyPairId: string;\n\n  /**\n   * The type of the key pair.\n   */\n  public readonly type?: KeyPairType;\n\n  // not supported in Terraform\n  // /**\n  //  * The format of the key pair.\n  //  */\n  // public readonly format: KeyPairFormat;\n\n  private _privateKey?: privateKey.PrivateKey;\n  private _privateKeySsm?: IStringParameter;\n  private readonly _isImport: boolean;\n\n  public readonly resource: tfKeyPair.KeyPair;\n\n  constructor(scope: Construct, id: string, props?: KeyPairProps) {\n    super(scope, id, props);\n\n    if (props?.keyPairName && props?.keyPairNamePrefix) {\n      throw new Error(\n        \"Cannot specify both 'keyPairName' and 'keyPairNamePrefix'\",\n      );\n    }\n\n    const keyPairNamePrefix =\n      props?.keyPairNamePrefix ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 255,\n      });\n\n    // Lazy.stringValue({\n    //   produce: () => AwsStack.uniqueResourceName(this, { maxLength: 255 }),\n    // });\n\n    if (props?.publicKeyMaterial && props?.type) {\n      throw new Error(\"Cannot specify 'type' for keys with imported material\");\n    }\n\n    this._isImport = !!props?.publicKeyMaterial;\n\n    const keyType = props?.type ?? KeyPairType.RSA;\n    let publicKey = props?.publicKeyMaterial;\n    if (!publicKey) {\n      let algorithm: \"RSA\" | \"ECDSA\" | \"ED25519\";\n      switch (keyType) {\n        case KeyPairType.ED25519:\n          algorithm = \"ED25519\";\n          break;\n        case KeyPairType.RSA:\n        default:\n          algorithm = \"RSA\";\n      }\n      this._privateKey = new privateKey.PrivateKey(this, \"PrivateKey\", {\n        algorithm,\n      });\n      publicKey = Fn.trimspace(this._privateKey.publicKeyOpenssh);\n    }\n\n    this.resource = new tfKeyPair.KeyPair(this, \"Resource\", {\n      keyName: props?.keyPairName,\n      keyNamePrefix: keyPairNamePrefix,\n      // keyFormat: props?.format ?? KeyPairFormat.PEM,\n      publicKey,\n    });\n\n    if (this._privateKey) {\n      // if privateKey was generated, mimic CFN behavior with SSM\n      this._privateKeySsm = new StringParameter(this, \"PrivateKeyParameter\", {\n        parameterName: `/ec2/keypair/${this.resource.id}`,\n        description: `Private key for ${this.resource.keyName}`,\n        type: ParameterType.SECURE_STRING,\n        sensitiveStringValue: this._privateKey.privateKeyPem,\n        simpleName: false,\n      });\n    }\n\n    this.keyPairName = this.resource.keyName;\n    this.keyPairFingerprint = this.resource.fingerprint;\n    this.keyPairId = this.resource.id;\n    this.type = keyType;\n    // this.format = keyFormat;\n  }\n\n  /**\n   * Whether the key material was imported.\n   *\n   * Keys with imported material do not have their private key material stored\n   * or returned automatically.\n   */\n  public get hasImportedMaterial(): boolean {\n    return this._isImport;\n  }\n\n  /**\n   * The Systems Manager Parameter Store parameter with the pair's private key material.\n   */\n  public get privateKey(): IStringParameter {\n    if (this._isImport) {\n      throw new Error(\n        \"An SSM parameter with private key material is not created for imported keys\",\n      );\n    }\n    // else, this is guaranteed to be set\n    return this._privateKeySsm!;\n  }\n\n  /**\n   * Used internally to determine whether the key pair is compatible with an OS type.\n   *\n   * @internal\n   */\n  public _isOsCompatible(osType: OperatingSystemType): boolean {\n    switch (this.type) {\n      case KeyPairType.ED25519:\n        return osType !== OperatingSystemType.WINDOWS;\n      case KeyPairType.RSA:\n        return true;\n      default:\n        return true;\n    }\n  }\n}\n"]}

package/lib/aws/compute/lambda-augmentations.generated.d.ts

@@ -0,0 +1,65 @@
+import * as cw from "../cloudwatch";
+declare module "./function-base" {
+    interface IFunction {
+        /**
+         * Return the given named metric for this Function
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How often this Lambda is throttled
+         *
+         * Sum over 5 minutes
+         */
+        metricThrottles(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How often this Lambda is invoked
+         *
+         * Sum over 5 minutes
+         */
+        metricInvocations(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How many invocations of this Lambda fail
+         *
+         * Sum over 5 minutes
+         */
+        metricErrors(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How long execution of this Lambda takes
+         *
+         * Average over 5 minutes
+         */
+        metricDuration(props?: cw.MetricOptions): cw.Metric;
+    }
+}
+declare module "./function-base" {
+    interface LambdaFunctionBase {
+        /**
+         * Return the given named metric for this Function
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How often this Lambda is throttled
+         *
+         * Sum over 5 minutes
+         */
+        metricThrottles(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How often this Lambda is invoked
+         *
+         * Sum over 5 minutes
+         */
+        metricInvocations(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How many invocations of this Lambda fail
+         *
+         * Sum over 5 minutes
+         */
+        metricErrors(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * How long execution of this Lambda takes
+         *
+         * Average over 5 minutes
+         */
+        metricDuration(props?: cw.MetricOptions): cw.Metric;
+    }
+}

package/lib/aws/compute/lambda-augmentations.generated.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright 2012-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+/* eslint-disable prettier/prettier,max-len */
+const cw = require("../cloudwatch");
+const function_base_1 = require("./function-base");
+function_base_1.LambdaFunctionBase.prototype.metric = function (metricName, props) {
+    return new cw.Metric({
+        "namespace": "AWS/Lambda",
+        "metricName": metricName,
+        "dimensionsMap": {
+            "FunctionName": this.functionName
+        },
+        ...props
+    }).attachTo(this);
+};
+function_base_1.LambdaFunctionBase.prototype.metricThrottles = function (props) {
+    return this.metric("Throttles", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+function_base_1.LambdaFunctionBase.prototype.metricInvocations = function (props) {
+    return this.metric("Invocations", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+function_base_1.LambdaFunctionBase.prototype.metricErrors = function (props) {
+    return this.metric("Errors", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+function_base_1.LambdaFunctionBase.prototype.metricDuration = function (props) {
+    return this.metric("Duration", {
+        "statistic": "Average",
+        ...props
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,316 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class LambdaMetrics {
+    static concurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static concurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static concurrentExecutionsMaximum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static concurrentExecutionsMaximum(dimensions: {}): MetricWithDims<{}>;
+    static deadLetterErrorsSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static deadLetterErrorsSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static deadLetterErrorsSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static deadLetterErrorsSum(dimensions: {}): MetricWithDims<{}>;
+    static destinationDeliveryFailuresSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static destinationDeliveryFailuresSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static destinationDeliveryFailuresSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static destinationDeliveryFailuresSum(dimensions: {}): MetricWithDims<{}>;
+    static durationAverage(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static durationAverage(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static durationAverage(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static durationAverage(dimensions: {}): MetricWithDims<{}>;
+    static errorsSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static errorsSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static errorsSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static errorsSum(dimensions: {}): MetricWithDims<{}>;
+    static invocationsSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static invocationsSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static invocationsSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static invocationsSum(dimensions: {}): MetricWithDims<{}>;
+    static iteratorAgeAverage(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static iteratorAgeAverage(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static iteratorAgeAverage(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static iteratorAgeAverage(dimensions: {}): MetricWithDims<{}>;
+    static postRuntimeExtensionsDurationAverage(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static postRuntimeExtensionsDurationAverage(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static postRuntimeExtensionsDurationAverage(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static postRuntimeExtensionsDurationAverage(dimensions: {}): MetricWithDims<{}>;
+    static provisionedConcurrencyInvocationsSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static provisionedConcurrencyInvocationsSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencyInvocationsSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencyInvocationsSum(dimensions: {}): MetricWithDims<{}>;
+    static provisionedConcurrencySpilloverInvocationsSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static provisionedConcurrencySpilloverInvocationsSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencySpilloverInvocationsSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencySpilloverInvocationsSum(dimensions: {}): MetricWithDims<{}>;
+    static provisionedConcurrencyUtilizationMaximum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static provisionedConcurrencyUtilizationMaximum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencyUtilizationMaximum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrencyUtilizationMaximum(dimensions: {}): MetricWithDims<{}>;
+    static provisionedConcurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static provisionedConcurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrentExecutionsMaximum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static provisionedConcurrentExecutionsMaximum(dimensions: {}): MetricWithDims<{}>;
+    static throttlesSum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static throttlesSum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static throttlesSum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static throttlesSum(dimensions: {}): MetricWithDims<{}>;
+    static unreservedConcurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+    }>;
+    static unreservedConcurrentExecutionsMaximum(dimensions: {
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static unreservedConcurrentExecutionsMaximum(dimensions: {
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }): MetricWithDims<{
+        ExecutedVersion: string;
+        FunctionName: string;
+        Resource: string;
+    }>;
+    static unreservedConcurrentExecutionsMaximum(dimensions: {}): MetricWithDims<{}>;
+}