terraconstructs 0.0.8

package/lib/aws/compute/function-alias.d.ts

@@ -0,0 +1,148 @@
+import { lambdaAlias } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { Architecture } from "./architecture";
+import { EventInvokeConfigOptions } from "./event-invoke-config";
+import { IFunction, QualifiedFunctionBase } from "./function-base";
+/**
+ * Outputs that can be exposed through the grid
+ */
+export interface AliasOutputs {
+    /**
+     * The Amazon Resource Name (ARN) identifying your Lambda function alias.
+     */
+    readonly name: string;
+    /**
+     * The ARN to be used for invoking Lambda Function from API Gateway - to be used in `aws_api_gateway_integration`'s uri
+     */
+    readonly invokeArn: string;
+}
+export interface IAlias extends IFunction {
+    /** strongly typed aliasOutputs */
+    readonly aliasOutputs: AliasOutputs;
+    /**
+     * Name of this alias.
+     *
+     * @attribute
+     */
+    readonly aliasName: string;
+    /**
+     * The underlying Lambda function
+     */
+    readonly lambda: IFunction;
+    /**
+     * The underlying Lambda function version.
+     */
+    readonly version: string;
+}
+/**
+ * Options for `lambda.Alias`.
+ */
+export interface AliasOptions extends EventInvokeConfigOptions {
+    /**
+     * Description for the alias
+     *
+     * @default No description
+     */
+    readonly description?: string;
+    /**
+     * Additional versions with individual weights this alias points to
+     *
+     * Individual additional version weights specified here should add up to
+     * (less than) one. All remaining weight is routed to the default
+     * version.
+     *
+     * For example, the config is
+     *
+     *    version: "1"
+     *    additionalVersions: [{ version: "2", weight: 0.05 }]
+     *
+     * Then 5% of traffic will be routed to function version 2, while
+     * the remaining 95% of traffic will be routed to function version 1.
+     *
+     * @default No additional versions
+     */
+    readonly additionalVersions?: VersionWeight[];
+}
+/**
+ * Properties for a new Lambda alias
+ */
+export interface AliasProps extends AliasOptions {
+    /**
+     * Name of this alias
+     *
+     * Minimum length of 1. Maximum length of 128.
+     * Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
+     *
+     */
+    readonly aliasName: string;
+    /**
+     * Function this alias refers to
+     */
+    readonly function: IFunction;
+    /**
+     * Function version this alias refers to
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_alias#function_version LambdaAlias#function_version}
+     * pattern (\$LATEST|[0-9]+)
+     */
+    readonly version: string;
+}
+export interface AliasAttributes {
+    readonly aliasName: string;
+    readonly function: IFunction;
+}
+/**
+ * A new alias to a particular version of a Lambda function.
+ */
+export declare class Alias extends QualifiedFunctionBase implements IAlias {
+    static fromAliasAttributes(scope: Construct, id: string, attrs: AliasAttributes): IAlias;
+    readonly resource: lambdaAlias.LambdaAlias;
+    private readonly _aliasOutputs;
+    get aliasOutputs(): AliasOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * Name of this alias.
+     *
+     * @attribute
+     */
+    readonly aliasName: string;
+    /**
+     * Name of this alias
+     *
+     * Used to be able to use Alias in place of a regular Lambda. Lambda accepts
+     * ARNs everywhere it accepts function names.
+     */
+    readonly functionName: string;
+    readonly lambda: IFunction;
+    readonly architecture: Architecture;
+    readonly version: string;
+    /**
+     * ARN of this alias
+     *
+     * Used to be able to use Alias in place of a regular Lambda. Lambda accepts
+     * ARNs everywhere it accepts function names.
+     */
+    readonly functionArn: string;
+    protected readonly qualifier: string;
+    protected readonly canCreatePermissions: boolean;
+    constructor(scope: Construct, id: string, props: AliasProps);
+    get grantPrincipal(): import("../iam").IPrincipal;
+    get role(): import("../iam").IRole | undefined;
+    /**
+     * Calculate the routingConfig parameter from the input props
+     */
+    private determineRoutingConfig;
+}
+/**
+ * A version/weight pair for routing traffic to Lambda functions
+ */
+export interface VersionWeight {
+    /**
+     * The version to route traffic to
+     */
+    readonly version: string;
+    /**
+     * How much weight to assign to this version (0..1)
+     */
+    readonly weight: number;
+}

package/lib/aws/compute/function-alias.js

@@ -0,0 +1,176 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alias = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const function_base_1 = require("./function-base");
+/**
+ * A new alias to a particular version of a Lambda function.
+ */
+class Alias extends function_base_1.QualifiedFunctionBase {
+    static fromAliasAttributes(scope, id, attrs) {
+        class Imported extends function_base_1.QualifiedFunctionBase {
+            /**
+             * Lambda function version which the alias uses.
+             */
+            get version() {
+                return this.resource.functionVersion;
+            }
+            get aliasOutputs() {
+                return {
+                    name: attrs.aliasName,
+                    invokeArn: this.resource.invokeArn,
+                };
+            }
+            get outputs() {
+                return this.aliasOutputs;
+            }
+            constructor(s, i) {
+                super(s, i);
+                this.aliasName = attrs.aliasName;
+                this.lambda = attrs.function;
+                this.functionArn = `${attrs.function.functionArn}:${attrs.aliasName}`;
+                this.functionName = `${attrs.function.functionName}:${attrs.aliasName}`;
+                this.grantPrincipal = attrs.function.grantPrincipal;
+                this.role = attrs.function.role;
+                this.architecture = attrs.function.architecture;
+                this.canCreatePermissions = this._isStackAccount();
+                this.qualifier = attrs.aliasName;
+                this.resource = new provider_aws_1.dataAwsLambdaAlias.DataAwsLambdaAlias(this, "Resource", {
+                    name: this.aliasName,
+                    functionName: attrs.function.functionName,
+                });
+            }
+        }
+        return new Imported(scope, id);
+    }
+    get aliasOutputs() {
+        return this._aliasOutputs;
+    }
+    get outputs() {
+        return this._aliasOutputs;
+    }
+    // // TODO: Re-Add scalable functions
+    // private scalableAlias?: ScalableFunctionAttribute;
+    // private readonly scalingRole: iam.IRole;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.canCreatePermissions = true;
+        this.lambda = props.function;
+        // TODO: Does it make sense to just prefix aliasName with GridUUID?
+        // should use this.stack.uniqueResourceName instead?
+        this.aliasName = `${this.gridUUID}-${props.aliasName}`;
+        this.version = props.version;
+        this.architecture = this.lambda.architecture;
+        this.resource = new provider_aws_1.lambdaAlias.LambdaAlias(this, "Resource", {
+            name: this.aliasName,
+            description: props.description,
+            functionName: this.lambda.functionName,
+            functionVersion: props.version,
+            routingConfig: this.determineRoutingConfig(props),
+        });
+        // TODO: Add aws_lambda_provisioned_concurrency_config
+        // // Use a Service Linked Role
+        // // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html
+        // this.scalingRole = iam.Role.fromRoleArn(
+        //   this,
+        //   "ScalingRole",
+        //   this.stack.formatArn({
+        //     service: "iam",
+        //     region: "",
+        //     resource:
+        //       "role/aws-service-role/lambda.application-autoscaling.amazonaws.com",
+        //     resourceName:
+        //       "AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency",
+        //   }),
+        // );
+        // includes qualifier
+        this.functionArn = this.resource.invokeArn;
+        // this.getResourceArnAttribute(alias.ref, {
+        //   service: "lambda",
+        //   resource: "function",
+        //   resourceName: `${this.lambda.functionName}:${this.aliasName}`,
+        //   arnFormat: ArnFormat.COLON_RESOURCE_NAME,
+        // });
+        this.qualifier = this.aliasName;
+        if (props.onFailure ||
+            props.onSuccess ||
+            props.maxEventAge ||
+            props.retryAttempts !== undefined) {
+            this.configureAsyncInvoke({
+                onFailure: props.onFailure,
+                onSuccess: props.onSuccess,
+                maxEventAge: props.maxEventAge,
+                retryAttempts: props.retryAttempts,
+            });
+        }
+        // ARN parsing splits on `:`, so we can only get the function's name from the ARN as resourceName...
+        // And we're parsing it out (instead of using the underlying function directly) in order to have use of it incur
+        // an implicit dependency on the resource.
+        //`${this.stack.splitArn(this.functionArn, ArnFormat.COLON_RESOURCE_NAME).resourceName!}:${this.aliasName}`;
+        this.functionName = this.resource.functionName;
+        this._aliasOutputs = {
+            invokeArn: this.resource.invokeArn,
+            name: this.aliasName,
+        };
+    }
+    get grantPrincipal() {
+        return this.lambda.grantPrincipal;
+    }
+    get role() {
+        return this.lambda.role;
+    }
+    // /**
+    //  * Configure provisioned concurrency autoscaling on a function alias. Returns a scalable attribute that can call
+    //  * `scaleOnUtilization()` and `scaleOnSchedule()`.
+    //  *
+    //  * @param options Autoscaling options
+    //  */
+    // public addAutoScaling(
+    //   options: AutoScalingOptions,
+    // ): IScalableFunctionAttribute {
+    //   if (this.scalableAlias) {
+    //     throw new Error("AutoScaling already enabled for this alias");
+    //   }
+    //   return (this.scalableAlias = new ScalableFunctionAttribute(
+    //     this,
+    //     "AliasScaling",
+    //     {
+    //       minCapacity: options.minCapacity ?? 1,
+    //       maxCapacity: options.maxCapacity,
+    //       resourceId: `function:${this.functionName}`,
+    //       dimension: "lambda:function:ProvisionedConcurrency",
+    //       serviceNamespace: appscaling.ServiceNamespace.LAMBDA,
+    //       role: this.scalingRole,
+    //     },
+    //   ));
+    // }
+    /**
+     * Calculate the routingConfig parameter from the input props
+     */
+    determineRoutingConfig(props) {
+        if (!props.additionalVersions || props.additionalVersions.length === 0) {
+            return undefined;
+        }
+        let total = 0;
+        const additionalVersionWeights = {};
+        for (const vw of props.additionalVersions) {
+            if (vw.weight < 0 || vw.weight > 1) {
+                throw new Error(`Additional version weight must be between 0 and 1, got: ${vw.weight}`);
+            }
+            total += vw.weight;
+            additionalVersionWeights[vw.version] = vw.weight;
+        }
+        if (total > 1) {
+            throw new Error(`Sum of additional version weights must not exceed 1, got: ${total}`);
+        }
+        return {
+            additionalVersionWeights,
+        };
+    }
+}
+exports.Alias = Alias;
+_a = JSII_RTTI_SYMBOL_1;
+Alias[_a] = { fqn: "terraconstructs.aws.compute.Alias", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-alias.js","sourceRoot":"","sources":["../../../src/aws/compute/function-alias.ts"],"names":[],"mappings":"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","sourcesContent":["import { lambdaAlias, dataAwsLambdaAlias } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Architecture } from \"./architecture\";\nimport { EventInvokeConfigOptions } from \"./event-invoke-config\";\nimport { IFunction, QualifiedFunctionBase } from \"./function-base\";\n// import { ScalableFunctionAttribute } from \"./private/scalable-function-attribute\";\n// import {\n//   AutoScalingOptions,\n//   IScalableFunctionAttribute,\n// } from \"./scalable-attribute-api\";\n// import { ArnFormat } from \"../\";\n\n/**\n * Outputs that can be exposed through the grid\n */\nexport interface AliasOutputs {\n  /**\n   * The Amazon Resource Name (ARN) identifying your Lambda function alias.\n   */\n  readonly name: string;\n\n  /**\n   * The ARN to be used for invoking Lambda Function from API Gateway - to be used in `aws_api_gateway_integration`'s uri\n   */\n  readonly invokeArn: string;\n}\n\nexport interface IAlias extends IFunction {\n  /** strongly typed aliasOutputs */\n  readonly aliasOutputs: AliasOutputs;\n\n  /**\n   * Name of this alias.\n   *\n   * @attribute\n   */\n  readonly aliasName: string;\n\n  /**\n   * The underlying Lambda function\n   */\n  readonly lambda: IFunction;\n\n  /**\n   * The underlying Lambda function version.\n   */\n  readonly version: string;\n}\n\n/**\n * Options for `lambda.Alias`.\n */\nexport interface AliasOptions extends EventInvokeConfigOptions {\n  /**\n   * Description for the alias\n   *\n   * @default No description\n   */\n  readonly description?: string;\n\n  /**\n   * Additional versions with individual weights this alias points to\n   *\n   * Individual additional version weights specified here should add up to\n   * (less than) one. All remaining weight is routed to the default\n   * version.\n   *\n   * For example, the config is\n   *\n   *    version: \"1\"\n   *    additionalVersions: [{ version: \"2\", weight: 0.05 }]\n   *\n   * Then 5% of traffic will be routed to function version 2, while\n   * the remaining 95% of traffic will be routed to function version 1.\n   *\n   * @default No additional versions\n   */\n  readonly additionalVersions?: VersionWeight[];\n\n  // TODO: re-add support for provisioned concurrency\n  // /**\n  //  * Specifies a provisioned concurrency configuration for a function's alias.\n  //  *\n  //  * @default No provisioned concurrency\n  //  */\n  // readonly provisionedConcurrentExecutions?: number;\n}\n\n/**\n * Properties for a new Lambda alias\n */\nexport interface AliasProps extends AliasOptions {\n  /**\n   * Name of this alias\n   *\n   * Minimum length of 1. Maximum length of 128.\n   * Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)\n   *\n   */\n  readonly aliasName: string;\n\n  /**\n   * Function this alias refers to\n   */\n  readonly function: IFunction;\n\n  /**\n   * Function version this alias refers to\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_alias#function_version LambdaAlias#function_version}\n   * pattern (\\$LATEST|[0-9]+)\n   */\n  readonly version: string;\n}\n\nexport interface AliasAttributes {\n  readonly aliasName: string;\n  readonly function: IFunction;\n}\n\n/**\n * A new alias to a particular version of a Lambda function.\n */\nexport class Alias extends QualifiedFunctionBase implements IAlias {\n  public static fromAliasAttributes(\n    scope: Construct,\n    id: string,\n    attrs: AliasAttributes,\n  ): IAlias {\n    class Imported extends QualifiedFunctionBase implements IAlias {\n      public readonly resource: dataAwsLambdaAlias.DataAwsLambdaAlias;\n      public readonly aliasName = attrs.aliasName;\n      /**\n       * Lambda function version which the alias uses.\n       */\n      public get version() {\n        return this.resource.functionVersion;\n      }\n      public readonly lambda = attrs.function;\n      public readonly functionArn = `${attrs.function.functionArn}:${attrs.aliasName}`;\n      public readonly functionName = `${attrs.function.functionName}:${attrs.aliasName}`;\n      public readonly grantPrincipal = attrs.function.grantPrincipal;\n      public readonly role = attrs.function.role;\n      public readonly architecture = attrs.function.architecture;\n\n      public get aliasOutputs(): AliasOutputs {\n        return {\n          name: attrs.aliasName,\n          invokeArn: this.resource.invokeArn,\n        };\n      }\n      public get outputs() {\n        return this.aliasOutputs;\n      }\n      protected readonly canCreatePermissions = this._isStackAccount();\n      protected readonly qualifier = attrs.aliasName;\n      constructor(s: Construct, i: string) {\n        super(s, i);\n        this.resource = new dataAwsLambdaAlias.DataAwsLambdaAlias(\n          this,\n          \"Resource\",\n          {\n            name: this.aliasName,\n            functionName: attrs.function.functionName,\n          },\n        );\n      }\n    }\n\n    return new Imported(scope, id);\n  }\n\n  public readonly resource: lambdaAlias.LambdaAlias;\n  private readonly _aliasOutputs: AliasOutputs;\n  public get aliasOutputs(): AliasOutputs {\n    return this._aliasOutputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this._aliasOutputs;\n  }\n\n  /**\n   * Name of this alias.\n   *\n   * @attribute\n   */\n  public readonly aliasName: string;\n\n  /**\n   * Name of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionName: string;\n\n  public readonly lambda: IFunction;\n\n  public readonly architecture: Architecture;\n\n  public readonly version: string;\n\n  /**\n   * ARN of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionArn: string;\n\n  protected readonly qualifier: string;\n\n  protected readonly canCreatePermissions: boolean = true;\n\n  // // TODO: Re-Add scalable functions\n  // private scalableAlias?: ScalableFunctionAttribute;\n  // private readonly scalingRole: iam.IRole;\n\n  constructor(scope: Construct, id: string, props: AliasProps) {\n    super(scope, id, props);\n\n    this.lambda = props.function;\n    // TODO: Does it make sense to just prefix aliasName with GridUUID?\n    // should use this.stack.uniqueResourceName instead?\n    this.aliasName = `${this.gridUUID}-${props.aliasName}`;\n    this.version = props.version;\n    this.architecture = this.lambda.architecture;\n\n    this.resource = new lambdaAlias.LambdaAlias(this, \"Resource\", {\n      name: this.aliasName,\n      description: props.description,\n      functionName: this.lambda.functionName,\n      functionVersion: props.version,\n      routingConfig: this.determineRoutingConfig(props),\n    });\n\n    // TODO: Add aws_lambda_provisioned_concurrency_config\n\n    // // Use a Service Linked Role\n    // // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html\n    // this.scalingRole = iam.Role.fromRoleArn(\n    //   this,\n    //   \"ScalingRole\",\n    //   this.stack.formatArn({\n    //     service: \"iam\",\n    //     region: \"\",\n    //     resource:\n    //       \"role/aws-service-role/lambda.application-autoscaling.amazonaws.com\",\n    //     resourceName:\n    //       \"AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency\",\n    //   }),\n    // );\n\n    // includes qualifier\n    this.functionArn = this.resource.invokeArn;\n\n    // this.getResourceArnAttribute(alias.ref, {\n    //   service: \"lambda\",\n    //   resource: \"function\",\n    //   resourceName: `${this.lambda.functionName}:${this.aliasName}`,\n    //   arnFormat: ArnFormat.COLON_RESOURCE_NAME,\n    // });\n\n    this.qualifier = this.aliasName;\n\n    if (\n      props.onFailure ||\n      props.onSuccess ||\n      props.maxEventAge ||\n      props.retryAttempts !== undefined\n    ) {\n      this.configureAsyncInvoke({\n        onFailure: props.onFailure,\n        onSuccess: props.onSuccess,\n        maxEventAge: props.maxEventAge,\n        retryAttempts: props.retryAttempts,\n      });\n    }\n\n    // ARN parsing splits on `:`, so we can only get the function's name from the ARN as resourceName...\n    // And we're parsing it out (instead of using the underlying function directly) in order to have use of it incur\n    // an implicit dependency on the resource.\n\n    //`${this.stack.splitArn(this.functionArn, ArnFormat.COLON_RESOURCE_NAME).resourceName!}:${this.aliasName}`;\n    this.functionName = this.resource.functionName;\n    this._aliasOutputs = {\n      invokeArn: this.resource.invokeArn,\n      name: this.aliasName,\n    };\n  }\n\n  public get grantPrincipal() {\n    return this.lambda.grantPrincipal;\n  }\n\n  public get role() {\n    return this.lambda.role;\n  }\n\n  // /**\n  //  * Configure provisioned concurrency autoscaling on a function alias. Returns a scalable attribute that can call\n  //  * `scaleOnUtilization()` and `scaleOnSchedule()`.\n  //  *\n  //  * @param options Autoscaling options\n  //  */\n  // public addAutoScaling(\n  //   options: AutoScalingOptions,\n  // ): IScalableFunctionAttribute {\n  //   if (this.scalableAlias) {\n  //     throw new Error(\"AutoScaling already enabled for this alias\");\n  //   }\n  //   return (this.scalableAlias = new ScalableFunctionAttribute(\n  //     this,\n  //     \"AliasScaling\",\n  //     {\n  //       minCapacity: options.minCapacity ?? 1,\n  //       maxCapacity: options.maxCapacity,\n  //       resourceId: `function:${this.functionName}`,\n  //       dimension: \"lambda:function:ProvisionedConcurrency\",\n  //       serviceNamespace: appscaling.ServiceNamespace.LAMBDA,\n  //       role: this.scalingRole,\n  //     },\n  //   ));\n  // }\n\n  /**\n   * Calculate the routingConfig parameter from the input props\n   */\n  private determineRoutingConfig(\n    props: AliasProps,\n  ): lambdaAlias.LambdaAliasRoutingConfig | undefined {\n    if (!props.additionalVersions || props.additionalVersions.length === 0) {\n      return undefined;\n    }\n\n    let total = 0;\n    const additionalVersionWeights: { [key: string]: number } = {};\n    for (const vw of props.additionalVersions) {\n      if (vw.weight < 0 || vw.weight > 1) {\n        throw new Error(\n          `Additional version weight must be between 0 and 1, got: ${vw.weight}`,\n        );\n      }\n      total += vw.weight;\n      additionalVersionWeights[vw.version] = vw.weight;\n    }\n    if (total > 1) {\n      throw new Error(\n        `Sum of additional version weights must not exceed 1, got: ${total}`,\n      );\n    }\n\n    return {\n      additionalVersionWeights,\n    };\n  }\n\n  // /**\n  //  * Validate that the provisionedConcurrentExecutions makes sense\n  //  *\n  //  * Member must have value greater than or equal to 1\n  //  */\n  // private determineProvisionedConcurrency(\n  //   props: AliasProps,\n  // ):\n  //   | lambdaAlias.LambdaAlias.ProvisionedConcurrencyConfigurationProperty\n  //   | undefined {\n  //   if (!props.provisionedConcurrentExecutions) {\n  //     return undefined;\n  //   }\n\n  //   if (props.provisionedConcurrentExecutions <= 0) {\n  //     throw new Error(\n  //       \"provisionedConcurrentExecutions must have value greater than or equal to 1\",\n  //     );\n  //   }\n\n  //   return {\n  //     provisionedConcurrentExecutions: props.provisionedConcurrentExecutions,\n  //   };\n  // }\n}\n\n/**\n * A version/weight pair for routing traffic to Lambda functions\n */\nexport interface VersionWeight {\n  /**\n   * The version to route traffic to\n   */\n  readonly version: string;\n\n  /**\n   * How much weight to assign to this version (0..1)\n   */\n  readonly weight: number;\n}\n"]}

package/lib/aws/compute/function-base.d.ts

@@ -0,0 +1,314 @@
+import { IResolvable } from "cdktf";
+import { Node } from "constructs";
+import { AwsConstructBase, IAwsConstruct } from "../aws-construct";
+import { Architecture } from "./architecture";
+import { EventInvokeConfigOptions } from "./event-invoke-config";
+import { EventSourceMapping, EventSourceMappingOptions } from "./event-source-mapping";
+import { Permission } from "./function-permission";
+import { FunctionUrlOptions, FunctionUrl } from "./function-url";
+import * as iam from "../iam";
+/**
+ * Represents a Lambda function defined outside of this stack.
+ */
+export interface FunctionAttributes {
+    /**
+     * The ARN of the Lambda function.
+     *
+     * Format: arn:<partition>:lambda:<region>:<account-id>:function:<function-name>
+     */
+    readonly functionArn: string;
+    /**
+     * The IAM execution role associated with this function.
+     *
+     * If the role is not specified, any role-related operations will no-op.
+     */
+    readonly role?: iam.IRole;
+    /**
+     * The security group of this Lambda, if in a VPC.
+     *
+     * This needs to be given in order to support allowing connections
+     * to this Lambda.
+     */
+    readonly securityGroup?: string | IResolvable;
+    /**
+     * Setting this property informs the CDK that the imported function is in the same environment as the stack.
+     * This affects certain behaviours such as, whether this function's permission can be modified.
+     * When not configured, the CDK attempts to auto-determine this. For environment agnostic stacks, i.e., stacks
+     * where the account is not specified with the `env` property, this is determined to be false.
+     *
+     * Set this to property *ONLY IF* the imported function is in the same account as the stack
+     * it's imported in.
+     * @default - depends: true, if the Stack is configured with an explicit `env` (account and region) and the account is the same as this function.
+     * For environment-agnostic stacks this will default to `false`.
+     */
+    readonly sameEnvironment?: boolean;
+    /**
+     * Setting this property informs the TerraConstruct that the imported function ALREADY HAS the necessary permissions
+     * for what you are trying to do. When not configured, E.T, attempts to auto-determine whether or not
+     * additional permissions are necessary on the function when grant APIs are used. If TerraConstruct tried to add
+     * permissions on an imported lambda, it will fail.
+     *
+     * Set this property *ONLY IF* you are committing to manage the imported function's permissions outside of
+     * this TerraConstruct stack. You are acknowledging that your TerraConstruct code alone will have insufficient permissions to access the
+     * imported function.
+     *
+     * @default false
+     */
+    readonly skipPermissions?: boolean;
+    /**
+     * The architecture of this Lambda Function (this is an optional attribute and defaults to X86_64).
+     * @default - Architecture.X86_64
+     */
+    readonly architecture?: Architecture;
+}
+/**
+ * A Lambda function.
+ */
+export interface IFunction extends IAwsConstruct, iam.IGrantable {
+    /**
+     * The name of the function.
+     *
+     * @attribute
+     */
+    readonly functionName: string;
+    /**
+     * The ARN of the function.
+     *
+     * @attribute
+     */
+    readonly functionArn: string;
+    /**
+     * The IAM role associated with this function.
+     */
+    readonly role?: iam.IRole;
+    /**
+     * The construct node where permissions are attached.
+     */
+    readonly permissionsNode: Node;
+    /**
+     * The system architectures compatible with this lambda function.
+     */
+    readonly architecture: Architecture;
+    /**
+     * Adds an event source that maps to this AWS Lambda function.
+     * @param id construct ID
+     * @param options mapping options
+     */
+    addEventSourceMapping(id: string, options: EventSourceMappingOptions): EventSourceMapping;
+    /**
+     * Adds an event source to this function.
+     *
+     * The following example adds an SQS Queue as an event source:
+     * ```
+     * import { compute } from 'terraconstructs';
+     * myFunction.addEventSource(new compute.SqsEventSource(myQueue));
+     * ```
+     */
+    addEventSource(source: IEventSource): void;
+    /**
+     * Adds a permission to the Lambda resource policy.
+     * @param id The id for the permission construct
+     * @param permission The permission to grant to this Lambda function. @see Permission for details.
+     */
+    addPermission(id: string, permission: Permission): void;
+    /**
+     * Adds a statement to the IAM role assumed by the instance.
+     */
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    /**
+     * Grant the given identity permissions to invoke this Lambda
+     */
+    grantInvoke(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke the $LATEST version or
+     * unqualified version of this Lambda
+     */
+    grantInvokeLatestVersion(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke the given (or latest) version of this Lambda
+     */
+    grantInvokeVersion(identity: iam.IGrantable, version: string): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke this Lambda Function URL
+     */
+    grantInvokeUrl(identity: iam.IGrantable): iam.Grant;
+    /**
+     * Grant multiple principals the ability to invoke this Lambda via CompositePrincipal
+     */
+    grantInvokeCompositePrincipal(compositePrincipal: iam.CompositePrincipal): iam.Grant[];
+    /**
+     * Configures options for asynchronous invocation.
+     */
+    configureAsyncInvoke(options: EventInvokeConfigOptions): void;
+    /**
+     * Adds a url to this lambda function.
+     */
+    addFunctionUrl(options?: FunctionUrlOptions): FunctionUrl;
+}
+export declare abstract class LambdaFunctionBase extends AwsConstructBase implements IFunction {
+    /**
+     * The name of the function.
+     */
+    abstract readonly functionName: string;
+    /**
+     * The principal this Lambda Function is running as
+     */
+    abstract readonly grantPrincipal: iam.IPrincipal;
+    /**
+     * The ARN fo the function.
+     *
+     * Should include version (if versioning is enabled via publish = true)
+     */
+    abstract readonly functionArn: string;
+    /**
+     * Latest published version of your Lambda Function.
+     *
+     * Used as qualifier of the version or alias of this function.
+     * A qualifier is the identifier that's appended to a version or alias ARN.
+     * @see https://docs.aws.amazon.com/lambda/latest/dg/API_GetFunctionConfiguration.html#API_GetFunctionConfiguration_RequestParameters
+     */
+    abstract readonly version: string;
+    /**
+     * The qualifier of the version or alias of this function.
+     * A qualifier is the identifier that's appended to a version or alias ARN.
+     * @see https://docs.aws.amazon.com/lambda/latest/dg/API_GetFunctionConfiguration.html#API_GetFunctionConfiguration_RequestParameters
+     */
+    /**
+     * The IAM role associated with this function.
+     *
+     * Undefined if the function was imported without a role.
+     */
+    abstract readonly role?: iam.IRole;
+    /**
+     * The construct node where permissions are attached.
+     */
+    abstract readonly permissionsNode: Node;
+    /**
+     * The architecture of this Lambda Function.
+     */
+    abstract readonly architecture: Architecture;
+    /**
+     * Whether the addPermission() call adds any permissions
+     *
+     * True for new Lambdas, false for version $LATEST and imported Lambdas
+     * from different accounts.
+     */
+    protected abstract readonly canCreatePermissions: boolean;
+    /**
+     * The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()
+     */
+    abstract readonly resourceArnsForGrantInvoke: string[];
+    /**
+     * Whether the user decides to skip adding permissions.
+     * The only use case is for cross-account, imported lambdas
+     * where the user commits to modifying the permisssions
+     * on the imported lambda outside this TerraConstruct Spec.
+     * @internal
+     */
+    protected readonly _skipPermissions?: boolean;
+    /**
+     * Mapping of invocation principals to grants. Used to de-dupe `grantInvoke()` calls.
+     * @internal
+     */
+    protected _invocationGrants: Record<string, iam.Grant>;
+    /**
+     * Mapping of fucntion URL invocation principals to grants. Used to de-dupe `grantInvokeUrl()` calls.
+     * @internal
+     */
+    protected _functionUrlInvocationGrants: Record<string, iam.Grant>;
+    /**
+     * Adds a permission to the Lambda resource policy.
+     * @param id The id for the permission construct
+     * @param permission The permission to grant to this Lambda function. @see Permission for details.
+     */
+    addPermission(id: string, permission: Permission): void;
+    /**
+     * Adds a statement to the IAM role assumed by the instance.
+     */
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    addEventSourceMapping(id: string, options: EventSourceMappingOptions): EventSourceMapping;
+    /**
+     * Grant the given identity permissions to invoke this Lambda
+     */
+    grantInvoke(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke the $LATEST version or
+     * unqualified version of this Lambda
+     */
+    grantInvokeLatestVersion(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke the given version of this Lambda
+     */
+    grantInvokeVersion(grantee: iam.IGrantable, version: string): iam.Grant;
+    /**
+     * Grant the given identity permissions to invoke this Lambda Function URL
+     */
+    grantInvokeUrl(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grant multiple principals the ability to invoke this Lambda via CompositePrincipal
+     */
+    grantInvokeCompositePrincipal(compositePrincipal: iam.CompositePrincipal): iam.Grant[];
+    addEventSource(source: IEventSource): void;
+    configureAsyncInvoke(options: EventInvokeConfigOptions): void;
+    /**
+     * A function URL is a dedicated HTTP(S) endpoint for a Lambda function.
+     */
+    addFunctionUrl(options?: FunctionUrlOptions): FunctionUrl;
+    /**
+     * Returns the construct tree node that corresponds to the lambda function.
+     * For use internally for constructs, when the tree is set up in non-standard ways. Ex: SingletonFunction.
+     * @internal
+     */
+    protected _functionNode(): Node;
+    /**
+     * Given the function arn, check if the account id matches this account
+     *
+     * Function ARNs look like this:
+     *
+     *   arn:aws:lambda:region:account-id:function:function-name
+     *
+     * ..which means that in order to extract the `account-id` component from the ARN, we can
+     * split the ARN using ":" and select the component in index 4.
+     *
+     * @returns true if account id of function matches the account specified on the stack, false otherwise.
+     *
+     * @internal
+     */
+    protected _isStackAccount(): boolean;
+    private grant;
+    /**
+     * Translate IPrincipal to something we can pass to aws_lambda_permission
+     * https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-Principal
+     * https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_permission#principal
+     *
+     * Do some nasty things because `Permission` supports a subset of what the
+     * full IAM principal language supports, and we may not be able to parse strings
+     * outright because they may be tokens.
+     *
+     * Try to recognize some specific Principal classes first, then try a generic
+     * fallback.
+     */
+    private parsePermissionPrincipal;
+    private validateConditionCombinations;
+    private validateConditions;
+    private isPrincipalWithConditions;
+}
+export declare abstract class QualifiedFunctionBase extends LambdaFunctionBase {
+    /** The underlying `IFunction` */
+    abstract readonly lambda: IFunction;
+    readonly permissionsNode: Node;
+    get resourceArnsForGrantInvoke(): string[];
+    configureAsyncInvoke(options: EventInvokeConfigOptions): void;
+}
+/**
+ * An abstract class which represents an AWS Lambda event source.
+ */
+export interface IEventSource {
+    /**
+     * Called by `lambda.addEventSource` to allow the event source to bind to this
+     * function.
+     *
+     * @param target That lambda function to bind to.
+     */
+    bind(target: IFunction): void;
+}