cdk-nextjs 0.0.0

package/lib/generated-structs/OptionalDockerImageFunctionProps.d.ts

@@ -0,0 +1,399 @@
+import type { aws_codeguruprofiler, aws_ec2, aws_iam, aws_kms, aws_lambda, aws_logs, aws_sns, aws_sqs, Duration, Size } from 'aws-cdk-lib';
+/**
+ * OptionalDockerImageFunctionProps
+ */
+export interface OptionalDockerImageFunctionProps {
+    /**
+     * The source code of your Lambda function.
+     * You can point to a file in an
+     * Amazon Simple Storage Service (Amazon S3) bucket or specify your source
+     * code as inline text.
+     * @stability stable
+     */
+    readonly code?: aws_lambda.DockerImageCode;
+    /**
+     * Where to place the network interfaces within the VPC.
+     * This requires `vpc` to be specified in order for interfaces to actually be
+     * placed in the subnets. If `vpc` is not specify, this will raise an error.
+     *
+     * Note: Internet access for Lambda Functions requires a NAT Gateway, so picking
+     * public subnets is not allowed (unless `allowPublicSubnet` is set to `true`).
+     * @default - the Vpc default strategy if not specified
+     * @stability stable
+     */
+    readonly vpcSubnets?: aws_ec2.SubnetSelection;
+    /**
+     * VPC network to place Lambda network interfaces.
+     * Specify this if the Lambda function needs to access resources in a VPC.
+     * This is required when `vpcSubnets` is specified.
+     * @default - Function is not placed within a VPC.
+     * @stability stable
+     */
+    readonly vpc?: aws_ec2.IVpc;
+    /**
+     * Enable AWS X-Ray Tracing for Lambda Function.
+     * @default Tracing.Disabled
+     * @stability stable
+     */
+    readonly tracing?: aws_lambda.Tracing;
+    /**
+     * The function execution time (in seconds) after which Lambda terminates the function.
+     * Because the execution time affects cost, set this value
+     * based on the function's expected execution time.
+     * @default Duration.seconds(3)
+     * @stability stable
+     */
+    readonly timeout?: Duration;
+    /**
+     * Sets the system log level for the function.
+     * @default SystemLogLevel.INFO
+     * @stability stable
+     */
+    readonly systemLogLevelV2?: aws_lambda.SystemLogLevel;
+    /**
+     * Sets the system log level for the function.
+     * @default "INFO"
+     * @deprecated Use `systemLogLevelV2` as a property instead.
+     * @stability deprecated
+     */
+    readonly systemLogLevel?: string;
+    /**
+     * Enable SnapStart for Lambda Function.
+     * SnapStart is currently supported only for Java 11, 17 runtime
+     * @default - No snapstart
+     * @stability stable
+     */
+    readonly snapStart?: aws_lambda.SnapStartConf;
+    /**
+     * The list of security groups to associate with the Lambda's network interfaces.
+     * Only used if 'vpc' is supplied.
+     * @default - If the function is placed within a VPC and a security group is
+  not specified, either by this or securityGroup prop, a dedicated security
+  group will be created for this function.
+     * @stability stable
+     */
+    readonly securityGroups?: Array<aws_ec2.ISecurityGroup>;
+    /**
+     * Sets the runtime management configuration for a function's version.
+     * @default Auto
+     * @stability stable
+     */
+    readonly runtimeManagementMode?: aws_lambda.RuntimeManagementMode;
+    /**
+     * Lambda execution role.
+     * This is the role that will be assumed by the function upon execution.
+     * It controls the permissions that the function will have. The Role must
+     * be assumable by the 'lambda.amazonaws.com' service principal.
+     *
+     * The default Role automatically has permissions granted for Lambda execution. If you
+     * provide a Role, you must add the relevant AWS managed policies yourself.
+     *
+     * The relevant managed policies are "service-role/AWSLambdaBasicExecutionRole" and
+     * "service-role/AWSLambdaVPCAccessExecutionRole".
+     * @default - A unique role will be generated for this lambda function.
+  Both supplied and generated roles can always be changed by calling `addToRolePolicy`.
+     * @stability stable
+     */
+    readonly role?: aws_iam.IRole;
+    /**
+     * The maximum of concurrent executions you want to reserve for the function.
+     * @default - No specific limit - account limit.
+     * @stability stable
+     */
+    readonly reservedConcurrentExecutions?: number;
+    /**
+     * Sets the Recursive Loop Protection for Lambda Function.
+     * It lets Lambda detect and terminate unintended recusrive loops.
+     * @default RecursiveLoop.Terminate
+     * @stability stable
+     */
+    readonly recursiveLoop?: aws_lambda.RecursiveLoop;
+    /**
+     * Profiling Group.
+     * @default - A new profiling group will be created if `profiling` is set.
+     * @stability stable
+     */
+    readonly profilingGroup?: aws_codeguruprofiler.IProfilingGroup;
+    /**
+     * Enable profiling.
+     * @default - No profiling.
+     * @stability stable
+     */
+    readonly profiling?: boolean;
+    /**
+     * Specify the configuration of Parameters and Secrets Extension.
+     * @default - No Parameters and Secrets Extension
+     * @stability stable
+     */
+    readonly paramsAndSecrets?: aws_lambda.ParamsAndSecretsLayerVersion;
+    /**
+     * The amount of memory, in MB, that is allocated to your Lambda function.
+     * Lambda uses this value to proportionally allocate the amount of CPU
+     * power. For more information, see Resource Model in the AWS Lambda
+     * Developer Guide.
+     * @default 128
+     * @stability stable
+     */
+    readonly memorySize?: number;
+    /**
+     * The IAM role for the Lambda function associated with the custom resource that sets the retention policy.
+     * This is a legacy API and we strongly recommend you migrate to `logGroup` if you can.
+     * `logGroup` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it.
+     * @default - A new role is created.
+     * @stability stable
+     */
+    readonly logRetentionRole?: aws_iam.IRole;
+    /**
+     * When log retention is specified, a custom resource attempts to create the CloudWatch log group.
+     * These options control the retry policy when interacting with CloudWatch APIs.
+     *
+     * This is a legacy API and we strongly recommend you migrate to `logGroup` if you can.
+     * `logGroup` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it.
+     * @default - Default AWS SDK retry options.
+     * @stability stable
+     */
+    readonly logRetentionRetryOptions?: aws_lambda.LogRetentionRetryOptions;
+    /**
+     * The number of days log events are kept in CloudWatch Logs.
+     * When updating
+     * this property, unsetting it doesn't remove the log retention policy. To
+     * remove the retention policy, set the value to `INFINITE`.
+     *
+     * This is a legacy API and we strongly recommend you move away from it if you can.
+     * Instead create a fully customizable log group with `logs.LogGroup` and use the `logGroup` property
+     * to instruct the Lambda function to send logs to it.
+     * Migrating from `logRetention` to `logGroup` will cause the name of the log group to change.
+     * Users and code and referencing the name verbatim will have to adjust.
+     *
+     * In AWS CDK code, you can access the log group name directly from the LogGroup construct:
+     * ```ts
+     * import * as logs from 'aws-cdk-lib/aws-logs';
+     *
+     * declare const myLogGroup: logs.LogGroup;
+     * myLogGroup.logGroupName;
+     * ```
+     * @default logs.RetentionDays.INFINITE
+     * @stability stable
+     */
+    readonly logRetention?: aws_logs.RetentionDays;
+    /**
+     * The log group the function sends logs to.
+     * By default, Lambda functions send logs to an automatically created default log group named /aws/lambda/\<function name\>.
+     * However you cannot change the properties of this auto-created log group using the AWS CDK, e.g. you cannot set a different log retention.
+     *
+     * Use the `logGroup` property to create a fully customizable LogGroup ahead of time, and instruct the Lambda function to send logs to it.
+     *
+     * Providing a user-controlled log group was rolled out to commercial regions on 2023-11-16.
+     * If you are deploying to another type of region, please check regional availability first.
+     * @default `/aws/lambda/${this.functionName}` - default log group created by Lambda
+     * @stability stable
+     */
+    readonly logGroup?: aws_logs.ILogGroup;
+    /**
+     * Sets the loggingFormat for the function.
+     * @default LoggingFormat.TEXT
+     * @stability stable
+     */
+    readonly loggingFormat?: aws_lambda.LoggingFormat;
+    /**
+     * Sets the logFormat for the function.
+     * @default "Text"
+     * @deprecated Use `loggingFormat` as a property instead.
+     * @stability deprecated
+     */
+    readonly logFormat?: string;
+    /**
+     * A list of layers to add to the function's execution environment.
+     * You can configure your Lambda function to pull in
+     * additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies
+     * that can be used by multiple functions.
+     * @default - No layers.
+     * @stability stable
+     */
+    readonly layers?: Array<aws_lambda.ILayerVersion>;
+    /**
+     * Allows outbound IPv6 traffic on VPC functions that are connected to dual-stack subnets.
+     * Only used if 'vpc' is supplied.
+     * @default false
+     * @stability stable
+     */
+    readonly ipv6AllowedForDualStack?: boolean;
+    /**
+     * Specify the version of CloudWatch Lambda insights to use for monitoring.
+     * @default - No Lambda Insights
+     * @stability stable
+     */
+    readonly insightsVersion?: aws_lambda.LambdaInsightsVersion;
+    /**
+     * Initial policy statements to add to the created Lambda Role.
+     * You can call `addToRolePolicy` to the created lambda to add statements post creation.
+     * @default - No policy statements are added to the created Lambda role.
+     * @stability stable
+     */
+    readonly initialPolicy?: Array<aws_iam.PolicyStatement>;
+    /**
+     * A name for the function.
+     * @default - AWS CloudFormation generates a unique physical ID and uses that
+  ID for the function's name. For more information, see Name Type.
+     * @stability stable
+     */
+    readonly functionName?: string;
+    /**
+     * The filesystem configuration for the lambda function.
+     * @default - will not mount any filesystem
+     * @stability stable
+     */
+    readonly filesystem?: aws_lambda.FileSystem;
+    /**
+     * Event sources for this function.
+     * You can also add event sources using `addEventSource`.
+     * @default - No event sources.
+     * @stability stable
+     */
+    readonly events?: Array<aws_lambda.IEventSource>;
+    /**
+     * The size of the function’s /tmp directory in MiB.
+     * @default 512 MiB
+     * @stability stable
+     */
+    readonly ephemeralStorageSize?: Size;
+    /**
+     * The AWS KMS key that's used to encrypt your function's environment variables.
+     * @default - AWS Lambda creates and uses an AWS managed customer master key (CMK).
+     * @stability stable
+     */
+    readonly environmentEncryption?: aws_kms.IKey;
+    /**
+     * Key-value pairs that Lambda caches and makes available for your Lambda functions.
+     * Use environment variables to apply configuration changes, such
+     * as test and production environment configurations, without changing your
+     * Lambda function source code.
+     * @default - No environment variables.
+     * @stability stable
+     */
+    readonly environment?: Record<string, string>;
+    /**
+     * A description of the function.
+     * @default - No description.
+     * @stability stable
+     */
+    readonly description?: string;
+    /**
+     * The SNS topic to use as a DLQ.
+     * Note that if `deadLetterQueueEnabled` is set to `true`, an SQS queue will be created
+     * rather than an SNS topic. Using an SNS topic as a DLQ requires this property to be set explicitly.
+     * @default - no SNS topic
+     * @stability stable
+     */
+    readonly deadLetterTopic?: aws_sns.ITopic;
+    /**
+     * Enabled DLQ.
+     * If `deadLetterQueue` is undefined,
+     * an SQS queue with default options will be defined for your Function.
+     * @default - false unless `deadLetterQueue` is set, which implies DLQ is enabled.
+     * @stability stable
+     */
+    readonly deadLetterQueueEnabled?: boolean;
+    /**
+     * The SQS queue to use if DLQ is enabled.
+     * If SNS topic is desired, specify `deadLetterTopic` property instead.
+     * @default - SQS queue with 14 day retention period if `deadLetterQueueEnabled` is `true`
+     * @stability stable
+     */
+    readonly deadLetterQueue?: aws_sqs.IQueue;
+    /**
+     * Options for the `lambda.Version` resource automatically created by the `fn.currentVersion` method.
+     * @default - default options as described in `VersionOptions`
+     * @stability stable
+     */
+    readonly currentVersionOptions?: aws_lambda.VersionOptions;
+    /**
+     * Code signing config associated with this function.
+     * @default - Not Sign the Code
+     * @stability stable
+     */
+    readonly codeSigningConfig?: aws_lambda.ICodeSigningConfig;
+    /**
+     * The system architectures compatible with this lambda function.
+     * @default Architecture.X86_64
+     * @stability stable
+     */
+    readonly architecture?: aws_lambda.Architecture;
+    /**
+     * Sets the application log level for the function.
+     * @default ApplicationLogLevel.INFO
+     * @stability stable
+     */
+    readonly applicationLogLevelV2?: aws_lambda.ApplicationLogLevel;
+    /**
+     * Sets the application log level for the function.
+     * @default "INFO"
+     * @deprecated Use `applicationLogLevelV2` as a property instead.
+     * @stability deprecated
+     */
+    readonly applicationLogLevel?: string;
+    /**
+     * Lambda Functions in a public subnet can NOT access the internet.
+     * Use this property to acknowledge this limitation and still place the function in a public subnet.
+     * @default false
+     * @stability stable
+     */
+    readonly allowPublicSubnet?: boolean;
+    /**
+     * Whether to allow the Lambda to send all network traffic (except ipv6).
+     * If set to false, you must individually add traffic rules to allow the
+     * Lambda to connect to network targets.
+     *
+     * Do not specify this property if the `securityGroups` or `securityGroup` property is set.
+     * Instead, configure `allowAllOutbound` directly on the security group.
+     * @default true
+     * @stability stable
+     */
+    readonly allowAllOutbound?: boolean;
+    /**
+     * Whether to allow the Lambda to send all ipv6 network traffic.
+     * If set to true, there will only be a single egress rule which allows all
+     * outbound ipv6 traffic. If set to false, you must individually add traffic rules to allow the
+     * Lambda to connect to network targets using ipv6.
+     *
+     * Do not specify this property if the `securityGroups` or `securityGroup` property is set.
+     * Instead, configure `allowAllIpv6Outbound` directly on the security group.
+     * @default false
+     * @stability stable
+     */
+    readonly allowAllIpv6Outbound?: boolean;
+    /**
+     * Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation.
+     * @default - No ADOT instrumentation
+     * @stability stable
+     */
+    readonly adotInstrumentation?: aws_lambda.AdotInstrumentationConfig;
+    /**
+     * The maximum number of times to retry when the function returns an error.
+     * Minimum: 0
+     * Maximum: 2
+     * @default 2
+     * @stability stable
+     */
+    readonly retryAttempts?: number;
+    /**
+     * The destination for successful invocations.
+     * @default - no destination
+     * @stability stable
+     */
+    readonly onSuccess?: aws_lambda.IDestination;
+    /**
+     * The destination for failed invocations.
+     * @default - no destination
+     * @stability stable
+     */
+    readonly onFailure?: aws_lambda.IDestination;
+    /**
+     * The maximum age of a request that Lambda sends to a function for processing.
+     * Minimum: 60 seconds
+     * Maximum: 6 hours
+     * @default Duration.hours(6)
+     * @stability stable
+     */
+    readonly maxEventAge?: Duration;
+}

package/lib/generated-structs/OptionalDockerImageFunctionProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OptionalDockerImageFunctionProps.js","sourceRoot":"","sources":["../../src/generated-structs/OptionalDockerImageFunctionProps.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"pnpm dlx projen\".\nimport type { aws_codeguruprofiler, aws_ec2, aws_iam, aws_kms, aws_lambda, aws_logs, aws_sns, aws_sqs, Duration, Size } from 'aws-cdk-lib';\n\n/**\n * OptionalDockerImageFunctionProps\n */\nexport interface OptionalDockerImageFunctionProps {\n  /**\n   * The source code of your Lambda function.\n   * You can point to a file in an\n   * Amazon Simple Storage Service (Amazon S3) bucket or specify your source\n   * code as inline text.\n   * @stability stable\n   */\n  readonly code?: aws_lambda.DockerImageCode;\n  /**\n   * Where to place the network interfaces within the VPC.\n   * This requires `vpc` to be specified in order for interfaces to actually be\n   * placed in the subnets. If `vpc` is not specify, this will raise an error.\n   *\n   * Note: Internet access for Lambda Functions requires a NAT Gateway, so picking\n   * public subnets is not allowed (unless `allowPublicSubnet` is set to `true`).\n   * @default - the Vpc default strategy if not specified\n   * @stability stable\n   */\n  readonly vpcSubnets?: aws_ec2.SubnetSelection;\n  /**\n   * VPC network to place Lambda network interfaces.\n   * Specify this if the Lambda function needs to access resources in a VPC.\n   * This is required when `vpcSubnets` is specified.\n   * @default - Function is not placed within a VPC.\n   * @stability stable\n   */\n  readonly vpc?: aws_ec2.IVpc;\n  /**\n   * Enable AWS X-Ray Tracing for Lambda Function.\n   * @default Tracing.Disabled\n   * @stability stable\n   */\n  readonly tracing?: aws_lambda.Tracing;\n  /**\n   * The function execution time (in seconds) after which Lambda terminates the function.\n   * Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   * @default Duration.seconds(3)\n   * @stability stable\n   */\n  readonly timeout?: Duration;\n  /**\n   * Sets the system log level for the function.\n   * @default SystemLogLevel.INFO\n   * @stability stable\n   */\n  readonly systemLogLevelV2?: aws_lambda.SystemLogLevel;\n  /**\n   * Sets the system log level for the function.\n   * @default \"INFO\"\n   * @deprecated Use `systemLogLevelV2` as a property instead.\n   * @stability deprecated\n   */\n  readonly systemLogLevel?: string;\n  /**\n   * Enable SnapStart for Lambda Function.\n   * SnapStart is currently supported only for Java 11, 17 runtime\n   * @default - No snapstart\n   * @stability stable\n   */\n  readonly snapStart?: aws_lambda.SnapStartConf;\n  /**\n   * The list of security groups to associate with the Lambda's network interfaces.\n   * Only used if 'vpc' is supplied.\n   * @default - If the function is placed within a VPC and a security group is\nnot specified, either by this or securityGroup prop, a dedicated security\ngroup will be created for this function.\n   * @stability stable\n   */\n  readonly securityGroups?: Array<aws_ec2.ISecurityGroup>;\n  /**\n   * Sets the runtime management configuration for a function's version.\n   * @default Auto\n   * @stability stable\n   */\n  readonly runtimeManagementMode?: aws_lambda.RuntimeManagementMode;\n  /**\n   * Lambda execution role.\n   * This is the role that will be assumed by the function upon execution.\n   * It controls the permissions that the function will have. The Role must\n   * be assumable by the 'lambda.amazonaws.com' service principal.\n   *\n   * The default Role automatically has permissions granted for Lambda execution. If you\n   * provide a Role, you must add the relevant AWS managed policies yourself.\n   *\n   * The relevant managed policies are \"service-role/AWSLambdaBasicExecutionRole\" and\n   * \"service-role/AWSLambdaVPCAccessExecutionRole\".\n   * @default - A unique role will be generated for this lambda function.\nBoth supplied and generated roles can always be changed by calling `addToRolePolicy`.\n   * @stability stable\n   */\n  readonly role?: aws_iam.IRole;\n  /**\n   * The maximum of concurrent executions you want to reserve for the function.\n   * @default - No specific limit - account limit.\n   * @stability stable\n   */\n  readonly reservedConcurrentExecutions?: number;\n  /**\n   * Sets the Recursive Loop Protection for Lambda Function.\n   * It lets Lambda detect and terminate unintended recusrive loops.\n   * @default RecursiveLoop.Terminate\n   * @stability stable\n   */\n  readonly recursiveLoop?: aws_lambda.RecursiveLoop;\n  /**\n   * Profiling Group.\n   * @default - A new profiling group will be created if `profiling` is set.\n   * @stability stable\n   */\n  readonly profilingGroup?: aws_codeguruprofiler.IProfilingGroup;\n  /**\n   * Enable profiling.\n   * @default - No profiling.\n   * @stability stable\n   */\n  readonly profiling?: boolean;\n  /**\n   * Specify the configuration of Parameters and Secrets Extension.\n   * @default - No Parameters and Secrets Extension\n   * @stability stable\n   */\n  readonly paramsAndSecrets?: aws_lambda.ParamsAndSecretsLayerVersion;\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   * @default 128\n   * @stability stable\n   */\n  readonly memorySize?: number;\n  /**\n   * The IAM role for the Lambda function associated with the custom resource that sets the retention policy.\n   * This is a legacy API and we strongly recommend you migrate to `logGroup` if you can.\n   * `logGroup` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it.\n   * @default - A new role is created.\n   * @stability stable\n   */\n  readonly logRetentionRole?: aws_iam.IRole;\n  /**\n   * When log retention is specified, a custom resource attempts to create the CloudWatch log group.\n   * These options control the retry policy when interacting with CloudWatch APIs.\n   *\n   * This is a legacy API and we strongly recommend you migrate to `logGroup` if you can.\n   * `logGroup` allows you to create a fully customizable log group and instruct the Lambda function to send logs to it.\n   * @default - Default AWS SDK retry options.\n   * @stability stable\n   */\n  readonly logRetentionRetryOptions?: aws_lambda.LogRetentionRetryOptions;\n  /**\n   * The number of days log events are kept in CloudWatch Logs.\n   * When updating\n   * this property, unsetting it doesn't remove the log retention policy. To\n   * remove the retention policy, set the value to `INFINITE`.\n   *\n   * This is a legacy API and we strongly recommend you move away from it if you can.\n   * Instead create a fully customizable log group with `logs.LogGroup` and use the `logGroup` property\n   * to instruct the Lambda function to send logs to it.\n   * Migrating from `logRetention` to `logGroup` will cause the name of the log group to change.\n   * Users and code and referencing the name verbatim will have to adjust.\n   *\n   * In AWS CDK code, you can access the log group name directly from the LogGroup construct:\n   * ```ts\n   * import * as logs from 'aws-cdk-lib/aws-logs';\n   *\n   * declare const myLogGroup: logs.LogGroup;\n   * myLogGroup.logGroupName;\n   * ```\n   * @default logs.RetentionDays.INFINITE\n   * @stability stable\n   */\n  readonly logRetention?: aws_logs.RetentionDays;\n  /**\n   * The log group the function sends logs to.\n   * By default, Lambda functions send logs to an automatically created default log group named /aws/lambda/\\<function name\\>.\n   * However you cannot change the properties of this auto-created log group using the AWS CDK, e.g. you cannot set a different log retention.\n   *\n   * Use the `logGroup` property to create a fully customizable LogGroup ahead of time, and instruct the Lambda function to send logs to it.\n   *\n   * Providing a user-controlled log group was rolled out to commercial regions on 2023-11-16.\n   * If you are deploying to another type of region, please check regional availability first.\n   * @default `/aws/lambda/${this.functionName}` - default log group created by Lambda\n   * @stability stable\n   */\n  readonly logGroup?: aws_logs.ILogGroup;\n  /**\n   * Sets the loggingFormat for the function.\n   * @default LoggingFormat.TEXT\n   * @stability stable\n   */\n  readonly loggingFormat?: aws_lambda.LoggingFormat;\n  /**\n   * Sets the logFormat for the function.\n   * @default \"Text\"\n   * @deprecated Use `loggingFormat` as a property instead.\n   * @stability deprecated\n   */\n  readonly logFormat?: string;\n  /**\n   * A list of layers to add to the function's execution environment.\n   * You can configure your Lambda function to pull in\n   * additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies\n   * that can be used by multiple functions.\n   * @default - No layers.\n   * @stability stable\n   */\n  readonly layers?: Array<aws_lambda.ILayerVersion>;\n  /**\n   * Allows outbound IPv6 traffic on VPC functions that are connected to dual-stack subnets.\n   * Only used if 'vpc' is supplied.\n   * @default false\n   * @stability stable\n   */\n  readonly ipv6AllowedForDualStack?: boolean;\n  /**\n   * Specify the version of CloudWatch Lambda insights to use for monitoring.\n   * @default - No Lambda Insights\n   * @stability stable\n   */\n  readonly insightsVersion?: aws_lambda.LambdaInsightsVersion;\n  /**\n   * Initial policy statements to add to the created Lambda Role.\n   * You can call `addToRolePolicy` to the created lambda to add statements post creation.\n   * @default - No policy statements are added to the created Lambda role.\n   * @stability stable\n   */\n  readonly initialPolicy?: Array<aws_iam.PolicyStatement>;\n  /**\n   * A name for the function.\n   * @default - AWS CloudFormation generates a unique physical ID and uses that\nID for the function's name. For more information, see Name Type.\n   * @stability stable\n   */\n  readonly functionName?: string;\n  /**\n   * The filesystem configuration for the lambda function.\n   * @default - will not mount any filesystem\n   * @stability stable\n   */\n  readonly filesystem?: aws_lambda.FileSystem;\n  /**\n   * Event sources for this function.\n   * You can also add event sources using `addEventSource`.\n   * @default - No event sources.\n   * @stability stable\n   */\n  readonly events?: Array<aws_lambda.IEventSource>;\n  /**\n   * The size of the function’s /tmp directory in MiB.\n   * @default 512 MiB\n   * @stability stable\n   */\n  readonly ephemeralStorageSize?: Size;\n  /**\n   * The AWS KMS key that's used to encrypt your function's environment variables.\n   * @default - AWS Lambda creates and uses an AWS managed customer master key (CMK).\n   * @stability stable\n   */\n  readonly environmentEncryption?: aws_kms.IKey;\n  /**\n   * Key-value pairs that Lambda caches and makes available for your Lambda functions.\n   * Use environment variables to apply configuration changes, such\n   * as test and production environment configurations, without changing your\n   * Lambda function source code.\n   * @default - No environment variables.\n   * @stability stable\n   */\n  readonly environment?: Record<string, string>;\n  /**\n   * A description of the function.\n   * @default - No description.\n   * @stability stable\n   */\n  readonly description?: string;\n  /**\n   * The SNS topic to use as a DLQ.\n   * Note that if `deadLetterQueueEnabled` is set to `true`, an SQS queue will be created\n   * rather than an SNS topic. Using an SNS topic as a DLQ requires this property to be set explicitly.\n   * @default - no SNS topic\n   * @stability stable\n   */\n  readonly deadLetterTopic?: aws_sns.ITopic;\n  /**\n   * Enabled DLQ.\n   * If `deadLetterQueue` is undefined,\n   * an SQS queue with default options will be defined for your Function.\n   * @default - false unless `deadLetterQueue` is set, which implies DLQ is enabled.\n   * @stability stable\n   */\n  readonly deadLetterQueueEnabled?: boolean;\n  /**\n   * The SQS queue to use if DLQ is enabled.\n   * If SNS topic is desired, specify `deadLetterTopic` property instead.\n   * @default - SQS queue with 14 day retention period if `deadLetterQueueEnabled` is `true`\n   * @stability stable\n   */\n  readonly deadLetterQueue?: aws_sqs.IQueue;\n  /**\n   * Options for the `lambda.Version` resource automatically created by the `fn.currentVersion` method.\n   * @default - default options as described in `VersionOptions`\n   * @stability stable\n   */\n  readonly currentVersionOptions?: aws_lambda.VersionOptions;\n  /**\n   * Code signing config associated with this function.\n   * @default - Not Sign the Code\n   * @stability stable\n   */\n  readonly codeSigningConfig?: aws_lambda.ICodeSigningConfig;\n  /**\n   * The system architectures compatible with this lambda function.\n   * @default Architecture.X86_64\n   * @stability stable\n   */\n  readonly architecture?: aws_lambda.Architecture;\n  /**\n   * Sets the application log level for the function.\n   * @default ApplicationLogLevel.INFO\n   * @stability stable\n   */\n  readonly applicationLogLevelV2?: aws_lambda.ApplicationLogLevel;\n  /**\n   * Sets the application log level for the function.\n   * @default \"INFO\"\n   * @deprecated Use `applicationLogLevelV2` as a property instead.\n   * @stability deprecated\n   */\n  readonly applicationLogLevel?: string;\n  /**\n   * Lambda Functions in a public subnet can NOT access the internet.\n   * Use this property to acknowledge this limitation and still place the function in a public subnet.\n   * @default false\n   * @stability stable\n   */\n  readonly allowPublicSubnet?: boolean;\n  /**\n   * Whether to allow the Lambda to send all network traffic (except ipv6).\n   * If set to false, you must individually add traffic rules to allow the\n   * Lambda to connect to network targets.\n   *\n   * Do not specify this property if the `securityGroups` or `securityGroup` property is set.\n   * Instead, configure `allowAllOutbound` directly on the security group.\n   * @default true\n   * @stability stable\n   */\n  readonly allowAllOutbound?: boolean;\n  /**\n   * Whether to allow the Lambda to send all ipv6 network traffic.\n   * If set to true, there will only be a single egress rule which allows all\n   * outbound ipv6 traffic. If set to false, you must individually add traffic rules to allow the\n   * Lambda to connect to network targets using ipv6.\n   *\n   * Do not specify this property if the `securityGroups` or `securityGroup` property is set.\n   * Instead, configure `allowAllIpv6Outbound` directly on the security group.\n   * @default false\n   * @stability stable\n   */\n  readonly allowAllIpv6Outbound?: boolean;\n  /**\n   * Specify the configuration of AWS Distro for OpenTelemetry (ADOT) instrumentation.\n   * @default - No ADOT instrumentation\n   * @stability stable\n   */\n  readonly adotInstrumentation?: aws_lambda.AdotInstrumentationConfig;\n  /**\n   * The maximum number of times to retry when the function returns an error.\n   * Minimum: 0\n   * Maximum: 2\n   * @default 2\n   * @stability stable\n   */\n  readonly retryAttempts?: number;\n  /**\n   * The destination for successful invocations.\n   * @default - no destination\n   * @stability stable\n   */\n  readonly onSuccess?: aws_lambda.IDestination;\n  /**\n   * The destination for failed invocations.\n   * @default - no destination\n   * @stability stable\n   */\n  readonly onFailure?: aws_lambda.IDestination;\n  /**\n   * The maximum age of a request that Lambda sends to a function for processing.\n   * Minimum: 60 seconds\n   * Maximum: 6 hours\n   * @default Duration.hours(6)\n   * @stability stable\n   */\n  readonly maxEventAge?: Duration;\n}\n"]}