terraconstructs 0.0.8

package/lib/aws/notify/targets/util.d.ts

@@ -0,0 +1,71 @@
+import { IConstruct } from "constructs";
+import * as notify from "..";
+import { Duration } from "../../..";
+import * as compute from "../../compute";
+import * as iam from "../../iam";
+/**
+ * The generic properties for an RuleTarget
+ */
+export interface TargetBaseProps {
+    /**
+     * The SQS queue to be used as deadLetterQueue.
+     * Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).
+     *
+     * The events not successfully delivered are automatically retried for a specified period of time,
+     * depending on the retry policy of the target.
+     * If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.
+     *
+     * @default - no dead-letter queue
+     */
+    readonly deadLetterQueue?: notify.IQueue;
+    /**
+     * The maximum age of a request that Lambda sends to a function for
+     * processing.
+     *
+     * Minimum value of 60.
+     * Maximum value of 86400.
+     *
+     * @default Duration.hours(24)
+     */
+    readonly maxEventAge?: Duration;
+    /**
+     * The maximum number of times to retry when the function returns an error.
+     *
+     * Minimum value of 0.
+     * Maximum value of 185.
+     *
+     * @default 185
+     */
+    readonly retryAttempts?: number;
+}
+/**
+ * Bind props to base rule target config.
+ * @internal
+ */
+export declare function bindBaseTargetConfig(props: TargetBaseProps): {
+    deadLetterConfig: {
+        arn: string;
+    } | undefined;
+    retryPolicy: {
+        maximumRetryAttempts: number | undefined;
+        maximumEventAgeInSeconds: number | undefined;
+    } | undefined;
+};
+/**
+ * Obtain the Role for the EventBridge event
+ *
+ * If a role already exists, it will be returned. This ensures that if multiple
+ * events have the same target, they will share a role.
+ * @internal
+ */
+export declare function singletonEventRole(scope: IConstruct): iam.IRole;
+/**
+ * Allows a Lambda function to be called from a rule
+ * @internal
+ */
+export declare function addLambdaPermission(rule: notify.IRule, handler: compute.IFunction): void;
+/**
+ * Allow a rule to send events with failed invocation to an Amazon SQS queue.
+ * @internal
+ */
+export declare function addToDeadLetterQueueResourcePolicy(rule: notify.IRule, queue: notify.IQueue): void;

package/lib/aws/notify/targets/util.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToDeadLetterQueueResourcePolicy = exports.addLambdaPermission = exports.singletonEventRole = exports.bindBaseTargetConfig = void 0;
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const __1 = require("../..");
+const token_1 = require("../../../token");
+const iam = require("../../iam");
+/**
+ * Bind props to base rule target config.
+ * @internal
+ */
+function bindBaseTargetConfig(props) {
+    let { deadLetterQueue, retryAttempts, maxEventAge } = props;
+    return {
+        deadLetterConfig: deadLetterQueue
+            ? { arn: deadLetterQueue?.queueArn }
+            : undefined,
+        retryPolicy: (retryAttempts !== undefined && retryAttempts >= 0) || maxEventAge
+            ? {
+                maximumRetryAttempts: retryAttempts,
+                maximumEventAgeInSeconds: maxEventAge?.toSeconds({
+                    integral: true,
+                }),
+            }
+            : undefined,
+    };
+}
+exports.bindBaseTargetConfig = bindBaseTargetConfig;
+/**
+ * Obtain the Role for the EventBridge event
+ *
+ * If a role already exists, it will be returned. This ensures that if multiple
+ * events have the same target, they will share a role.
+ * @internal
+ */
+function singletonEventRole(scope) {
+    const id = "EventsRole";
+    const existing = scope.node.tryFindChild(id);
+    if (existing) {
+        return existing;
+    }
+    const role = new iam.Role(scope, id, {
+        assumedBy: new iam.ServicePrincipal("events.amazonaws.com"), // TODO: Should be "events"?
+    });
+    return role;
+}
+exports.singletonEventRole = singletonEventRole;
+/**
+ * Allows a Lambda function to be called from a rule
+ * @internal
+ */
+function addLambdaPermission(rule, handler) {
+    let scope;
+    let node = handler.permissionsNode;
+    let permissionId = `AllowEventRule${__1.AwsStack.uniqueId(rule.node)}`;
+    if (rule instanceof constructs_1.Construct) {
+        // Place the Permission resource in the same stack as Rule rather than the Function
+        // This is to reduce circular dependency when the lambda handler and the rule are across stacks.
+        scope = rule;
+        node = rule.node;
+        permissionId = `AllowEventRule${__1.AwsStack.uniqueId(handler.node)}`;
+    }
+    if (!node.tryFindChild(permissionId)) {
+        handler.addPermission(permissionId, {
+            scope,
+            action: "lambda:InvokeFunction",
+            principal: new iam.ServicePrincipal("events.amazonaws.com"),
+            sourceArn: rule.ruleArn,
+        });
+    }
+}
+exports.addLambdaPermission = addLambdaPermission;
+/**
+ * Allow a rule to send events with failed invocation to an Amazon SQS queue.
+ * @internal
+ */
+function addToDeadLetterQueueResourcePolicy(rule, queue) {
+    if (!sameEnvDimension(rule.env.region, queue.env.region)) {
+        throw new Error(`Cannot assign Dead Letter Queue in region ${queue.env.region} to the rule ${__1.AwsStack.uniqueId(rule.node)} in region ${rule.env.region}. Both the queue and the rule must be in the same region.`);
+    }
+    // Skip Resource Policy creation if the Queue is not in the same account.
+    // There is no way to add a target onto an imported rule, so we can assume we will run the following code only
+    // in the account where the rule is created.
+    if (sameEnvDimension(rule.env.account, queue.env.account)) {
+        const policyStatementId = `AllowEventRule${__1.AwsStack.uniqueId(rule.node)}`;
+        queue.addToResourcePolicy(new iam.PolicyStatement({
+            sid: policyStatementId,
+            principals: [new iam.ServicePrincipal("events.amazonaws.com")],
+            effect: iam.Effect.ALLOW,
+            actions: ["sqs:SendMessage"],
+            resources: [queue.queueArn],
+            condition: [
+                {
+                    test: "ArnEquals",
+                    variable: "aws:SourceArn",
+                    values: [rule.ruleArn],
+                },
+            ],
+        }));
+    }
+    else {
+        // "@aws-cdk/aws-events-targets:manuallyAddDLQResourcePolicy",
+        cdktf_1.Annotations.of(rule).addWarning(`Cannot add a resource policy to your dead letter queue associated with rule ${rule.ruleName} because the queue is in a different account. You must add the resource policy manually to the dead letter queue in account ${queue.env.account}.`);
+    }
+}
+exports.addToDeadLetterQueueResourcePolicy = addToDeadLetterQueueResourcePolicy;
+/**
+ * Whether two string probably contain the same environment dimension (region or account)
+ *
+ * Used to compare either accounts or regions on a best effort basis. If we cannot tell definitively
+ * that the dimensions are in different environments, we will pass.
+ *
+ * For example, returns true if both are unresolved (in which case both are expected to be
+ * "current region" or "current account").
+ *
+ * Also returns true if one is unresolved (in which case we expect the unresolved dimension to match
+ * the resolved dimension, but it is up to the user to ensure this). Returning true here makes sure
+ * that we are not overly aggressive in producing a synth-time error.
+ *
+ * @internal
+ */
+function sameEnvDimension(dim1, dim2) {
+    return [
+        token_1.TokenComparison.SAME,
+        token_1.TokenComparison.ONE_UNRESOLVED,
+        token_1.TokenComparison.BOTH_UNRESOLVED,
+    ].includes((0, token_1.tokenCompareStrings)(dim1, dim2));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/aws/notify/targets/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { Annotations } from \"cdktf\";\nimport { Construct, IConstruct, Node } from \"constructs\";\nimport * as notify from \"..\";\nimport { AwsStack } from \"../..\";\nimport { Duration } from \"../../..\";\nimport { TokenComparison, tokenCompareStrings } from \"../../../token\";\nimport * as compute from \"../../compute\";\nimport * as iam from \"../../iam\";\n\n/**\n * The generic properties for an RuleTarget\n */\nexport interface TargetBaseProps {\n  /**\n   * The SQS queue to be used as deadLetterQueue.\n   * Check out the [considerations for using a dead-letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations).\n   *\n   * The events not successfully delivered are automatically retried for a specified period of time,\n   * depending on the retry policy of the target.\n   * If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue.\n   *\n   * @default - no dead-letter queue\n   */\n  readonly deadLetterQueue?: notify.IQueue;\n  /**\n   * The maximum age of a request that Lambda sends to a function for\n   * processing.\n   *\n   * Minimum value of 60.\n   * Maximum value of 86400.\n   *\n   * @default Duration.hours(24)\n   */\n  readonly maxEventAge?: Duration;\n\n  /**\n   * The maximum number of times to retry when the function returns an error.\n   *\n   * Minimum value of 0.\n   * Maximum value of 185.\n   *\n   * @default 185\n   */\n  readonly retryAttempts?: number;\n}\n\n/**\n * Bind props to base rule target config.\n * @internal\n */\nexport function bindBaseTargetConfig(props: TargetBaseProps) {\n  let { deadLetterQueue, retryAttempts, maxEventAge } = props;\n\n  return {\n    deadLetterConfig: deadLetterQueue\n      ? { arn: deadLetterQueue?.queueArn }\n      : undefined,\n    retryPolicy:\n      (retryAttempts !== undefined && retryAttempts >= 0) || maxEventAge\n        ? {\n            maximumRetryAttempts: retryAttempts,\n            maximumEventAgeInSeconds: maxEventAge?.toSeconds({\n              integral: true,\n            }),\n          }\n        : undefined,\n  };\n}\n\n/**\n * Obtain the Role for the EventBridge event\n *\n * If a role already exists, it will be returned. This ensures that if multiple\n * events have the same target, they will share a role.\n * @internal\n */\nexport function singletonEventRole(scope: IConstruct): iam.IRole {\n  const id = \"EventsRole\";\n  const existing = scope.node.tryFindChild(id) as iam.IRole;\n  if (existing) {\n    return existing;\n  }\n\n  const role = new iam.Role(scope as Construct, id, {\n    assumedBy: new iam.ServicePrincipal(\"events.amazonaws.com\"), // TODO: Should be \"events\"?\n  });\n\n  return role;\n}\n\n/**\n * Allows a Lambda function to be called from a rule\n * @internal\n */\nexport function addLambdaPermission(\n  rule: notify.IRule,\n  handler: compute.IFunction,\n): void {\n  let scope: Construct | undefined;\n  let node: Node = handler.permissionsNode;\n  let permissionId = `AllowEventRule${AwsStack.uniqueId(rule.node)}`;\n  if (rule instanceof Construct) {\n    // Place the Permission resource in the same stack as Rule rather than the Function\n    // This is to reduce circular dependency when the lambda handler and the rule are across stacks.\n    scope = rule;\n    node = rule.node;\n    permissionId = `AllowEventRule${AwsStack.uniqueId(handler.node)}`;\n  }\n  if (!node.tryFindChild(permissionId)) {\n    handler.addPermission(permissionId, {\n      scope,\n      action: \"lambda:InvokeFunction\",\n      principal: new iam.ServicePrincipal(\"events.amazonaws.com\"),\n      sourceArn: rule.ruleArn,\n    });\n  }\n}\n\n/**\n * Allow a rule to send events with failed invocation to an Amazon SQS queue.\n * @internal\n */\nexport function addToDeadLetterQueueResourcePolicy(\n  rule: notify.IRule,\n  queue: notify.IQueue,\n) {\n  if (!sameEnvDimension(rule.env.region, queue.env.region)) {\n    throw new Error(\n      `Cannot assign Dead Letter Queue in region ${queue.env.region} to the rule ${AwsStack.uniqueId(rule.node)} in region ${rule.env.region}. Both the queue and the rule must be in the same region.`,\n    );\n  }\n\n  // Skip Resource Policy creation if the Queue is not in the same account.\n  // There is no way to add a target onto an imported rule, so we can assume we will run the following code only\n  // in the account where the rule is created.\n  if (sameEnvDimension(rule.env.account, queue.env.account)) {\n    const policyStatementId = `AllowEventRule${AwsStack.uniqueId(rule.node)}`;\n\n    queue.addToResourcePolicy(\n      new iam.PolicyStatement({\n        sid: policyStatementId,\n        principals: [new iam.ServicePrincipal(\"events.amazonaws.com\")],\n        effect: iam.Effect.ALLOW,\n        actions: [\"sqs:SendMessage\"],\n        resources: [queue.queueArn],\n        condition: [\n          {\n            test: \"ArnEquals\",\n            variable: \"aws:SourceArn\",\n            values: [rule.ruleArn],\n          },\n        ],\n      }),\n    );\n  } else {\n    // \"@aws-cdk/aws-events-targets:manuallyAddDLQResourcePolicy\",\n    Annotations.of(rule).addWarning(\n      `Cannot add a resource policy to your dead letter queue associated with rule ${rule.ruleName} because the queue is in a different account. You must add the resource policy manually to the dead letter queue in account ${queue.env.account}.`,\n    );\n  }\n}\n\n/**\n * Whether two string probably contain the same environment dimension (region or account)\n *\n * Used to compare either accounts or regions on a best effort basis. If we cannot tell definitively\n * that the dimensions are in different environments, we will pass.\n *\n * For example, returns true if both are unresolved (in which case both are expected to be\n * \"current region\" or \"current account\").\n *\n * Also returns true if one is unresolved (in which case we expect the unresolved dimension to match\n * the resolved dimension, but it is up to the user to ensure this). Returning true here makes sure\n * that we are not overly aggressive in producing a synth-time error.\n *\n * @internal\n */\nfunction sameEnvDimension(dim1: string, dim2: string) {\n  return [\n    TokenComparison.SAME,\n    TokenComparison.ONE_UNRESOLVED,\n    TokenComparison.BOTH_UNRESOLVED,\n  ].includes(tokenCompareStrings(dim1, dim2));\n}\n"]}

package/lib/aws/notify/util.d.ts

@@ -0,0 +1,13 @@
+import { EventPattern } from "./event-pattern";
+/**
+ * Merge the `src` event pattern into the `dest` event pattern by adding all
+ * values from `src` into the fields in `dest`.
+ *
+ * See `rule.addEventPattern` for details.
+ */
+export declare function mergeEventPattern(dest: any, src: any): any;
+/**
+ * Transform an eventPattern object into a valid Event Rule Pattern
+ * by changing detailType into detail-type when present.
+ */
+export declare function renderEventPattern(eventPattern: EventPattern): any;

package/lib/aws/notify/util.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderEventPattern = exports.mergeEventPattern = void 0;
+/**
+ * Merge the `src` event pattern into the `dest` event pattern by adding all
+ * values from `src` into the fields in `dest`.
+ *
+ * See `rule.addEventPattern` for details.
+ */
+function mergeEventPattern(dest, src) {
+    dest = dest || {};
+    mergeObject(dest, src);
+    return dest;
+    function mergeObject(destObj, srcObj) {
+        if (typeof srcObj !== "object") {
+            throw new Error(`Invalid event pattern '${JSON.stringify(srcObj)}', expecting an object or an array`);
+        }
+        for (const field of Object.keys(srcObj)) {
+            const srcValue = srcObj[field];
+            const destValue = destObj[field];
+            if (srcValue === undefined) {
+                continue;
+            }
+            if (typeof srcValue !== "object") {
+                throw new Error(`Invalid event pattern field { ${field}: ${JSON.stringify(srcValue)} }. All fields must be arrays`);
+            }
+            // dest doesn't have this field
+            if (destObj[field] === undefined) {
+                destObj[field] = srcValue;
+                continue;
+            }
+            if (Array.isArray(srcValue) !== Array.isArray(destValue)) {
+                throw new Error(`Invalid event pattern field ${field}. ` +
+                    `Type mismatch between existing pattern ${JSON.stringify(destValue)} and added pattern ${JSON.stringify(srcValue)}`);
+            }
+            // if this is an array, concat and deduplicate the values
+            if (Array.isArray(srcValue)) {
+                const result = [...destValue, ...srcValue];
+                const resultJson = result.map((i) => JSON.stringify(i));
+                destObj[field] = result.filter((value, index) => resultJson.indexOf(JSON.stringify(value)) === index);
+                continue;
+            }
+            // otherwise, it's an object, so recurse
+            mergeObject(destObj[field], srcValue);
+        }
+    }
+}
+exports.mergeEventPattern = mergeEventPattern;
+/**
+ * Transform an eventPattern object into a valid Event Rule Pattern
+ * by changing detailType into detail-type when present.
+ */
+function renderEventPattern(eventPattern) {
+    if (Object.keys(eventPattern).length === 0) {
+        return undefined;
+    }
+    // rename 'detailType' to 'detail-type'
+    const out = {};
+    for (let key of Object.keys(eventPattern)) {
+        const value = eventPattern[key];
+        if (key === "detailType") {
+            key = "detail-type";
+        }
+        out[key] = value;
+    }
+    return out;
+}
+exports.renderEventPattern = renderEventPattern;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/provider-config.generated.d.ts

@@ -0,0 +1,220 @@
+import type { IResolvable } from 'cdktf';
+import type { provider } from '@cdktf/provider-aws';
+/**
+ * Config for the AWS Provider
+ */
+export interface AwsProviderConfig {
+    /**
+     * Resolve an endpoint with FIPS capability.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#use_fips_endpoint AwsProvider#use_fips_endpoint}
+     * @stability stable
+     */
+    readonly useFipsEndpoint?: boolean | IResolvable;
+    /**
+     * Resolve an endpoint with DualStack capability.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#use_dualstack_endpoint AwsProvider#use_dualstack_endpoint}
+     * @stability stable
+     */
+    readonly useDualstackEndpoint?: boolean | IResolvable;
+    /**
+     * The capacity of the AWS SDK's token bucket rate limiter.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#token_bucket_rate_limiter_capacity AwsProvider#token_bucket_rate_limiter_capacity}
+     * @stability stable
+     */
+    readonly tokenBucketRateLimiterCapacity?: number;
+    /**
+     * session token. A session token is only required if you are using temporary security credentials.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#token AwsProvider#token}
+     * @stability stable
+     */
+    readonly token?: string;
+    /**
+     * The region where AWS STS operations will take place. Examples are us-east-1 and us-west-2.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#sts_region AwsProvider#sts_region}
+     * @stability stable
+     */
+    readonly stsRegion?: string;
+    /**
+     * Skip requesting the account ID. Used for AWS API implementations that do not have IAM/STS API and/or metadata API.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_requesting_account_id AwsProvider#skip_requesting_account_id}
+     * @stability stable
+     */
+    readonly skipRequestingAccountId?: boolean | IResolvable;
+    /**
+     * Skip static validation of region name.
+     * Used by users of alternative AWS-like APIs or users w/ access to regions that are not public (yet).
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_region_validation AwsProvider#skip_region_validation}
+     * @stability stable
+     */
+    readonly skipRegionValidation?: boolean | IResolvable;
+    /**
+     * Skip the AWS Metadata API check. Used for AWS API implementations that do not have a metadata api endpoint.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_metadata_api_check AwsProvider#skip_metadata_api_check}
+     * @stability stable
+     */
+    readonly skipMetadataApiCheck?: string;
+    /**
+     * Skip the credentials validation via STS API. Used for AWS API implementations that do not have STS available/implemented.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_credentials_validation AwsProvider#skip_credentials_validation}
+     * @stability stable
+     */
+    readonly skipCredentialsValidation?: boolean | IResolvable;
+    /**
+     * List of paths to shared credentials files. If not set, defaults to [~/.aws/credentials].
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#shared_credentials_files AwsProvider#shared_credentials_files}
+     * @stability stable
+     */
+    readonly sharedCredentialsFiles?: Array<string>;
+    /**
+     * List of paths to shared config files. If not set, defaults to [~/.aws/config].
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#shared_config_files AwsProvider#shared_config_files}
+     * @stability stable
+     */
+    readonly sharedConfigFiles?: Array<string>;
+    /**
+     * The secret key for API operations. You can retrieve this from the 'Security & Credentials' section of the AWS console.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#secret_key AwsProvider#secret_key}
+     * @stability stable
+     */
+    readonly secretKey?: string;
+    /**
+     * Set this to true to enable the request to use path-style addressing, i.e., https://s3.amazonaws.com/BUCKET/KEY. By default, the S3 client will use virtual hosted bucket addressing when possible (https://BUCKET.s3.amazonaws.com/KEY). Specific to the Amazon S3 service.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#s3_use_path_style AwsProvider#s3_use_path_style}
+     * @stability stable
+     */
+    readonly s3UsePathStyle?: boolean | IResolvable;
+    /**
+     * Specifies whether S3 API calls in the `us-east-1` region use the legacy global endpoint or a regional endpoint.
+     * Valid values are `legacy` or `regional`. Can also be configured using the `AWS_S3_US_EAST_1_REGIONAL_ENDPOINT` environment variable or the `s3_us_east_1_regional_endpoint` shared config file parameter
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#s3_us_east_1_regional_endpoint AwsProvider#s3_us_east_1_regional_endpoint}
+     * @stability stable
+     */
+    readonly s3UsEast1RegionalEndpoint?: string;
+    /**
+     * Specifies how retries are attempted.
+     * Valid values are `standard` and `adaptive`. Can also be configured using the `AWS_RETRY_MODE` environment variable.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#retry_mode AwsProvider#retry_mode}
+     * @stability stable
+     */
+    readonly retryMode?: string;
+    /**
+     * The region where AWS operations will take place. Examples are us-east-1, us-west-2, etc.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#region AwsProvider#region}
+     * @stability stable
+     */
+    readonly region?: string;
+    /**
+     * The profile for API operations. If not set, the default profile created with `aws configure` will be used.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#profile AwsProvider#profile}
+     * @stability stable
+     */
+    readonly profile?: string;
+    /**
+     * Comma-separated list of hosts that should not use HTTP or HTTPS proxies.
+     * Can also be set using the `NO_PROXY` or `no_proxy` environment variables.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#no_proxy AwsProvider#no_proxy}
+     * @stability stable
+     */
+    readonly noProxy?: string;
+    /**
+     * The maximum number of times an AWS API request is being executed.
+     * If the API request still fails, an error is
+     * thrown.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#max_retries AwsProvider#max_retries}
+     * @stability stable
+     */
+    readonly maxRetries?: number;
+    /**
+     * Explicitly allow the provider to perform "insecure" SSL requests. If omitted, default value is `false`.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#insecure AwsProvider#insecure}
+     * @stability stable
+     */
+    readonly insecure?: boolean | IResolvable;
+    /**
+     * ignore_tags block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ignore_tags AwsProvider#ignore_tags}
+     * @stability stable
+     */
+    readonly ignoreTags?: IResolvable | Array<provider.AwsProviderIgnoreTags>;
+    /**
+     * URL of a proxy to use for HTTPS requests when accessing the AWS API.
+     * Can also be set using the `HTTPS_PROXY` or `https_proxy` environment variables.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#https_proxy AwsProvider#https_proxy}
+     * @stability stable
+     */
+    readonly httpsProxy?: string;
+    /**
+     * URL of a proxy to use for HTTP requests when accessing the AWS API.
+     * Can also be set using the `HTTP_PROXY` or `http_proxy` environment variables.
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#http_proxy AwsProvider#http_proxy}
+     * @stability stable
+     */
+    readonly httpProxy?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#forbidden_account_ids AwsProvider#forbidden_account_ids}.
+     * @stability stable
+     */
+    readonly forbiddenAccountIds?: Array<string>;
+    /**
+     * endpoints block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#endpoints AwsProvider#endpoints}
+     * @stability stable
+     */
+    readonly endpoints?: IResolvable | Array<provider.AwsProviderEndpoints>;
+    /**
+     * Protocol to use with EC2 metadata service endpoint.Valid values are `IPv4` and `IPv6`. Can also be configured using the `AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE` environment variable.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ec2_metadata_service_endpoint_mode AwsProvider#ec2_metadata_service_endpoint_mode}
+     * @stability stable
+     */
+    readonly ec2MetadataServiceEndpointMode?: string;
+    /**
+     * Address of the EC2 metadata service endpoint to use. Can also be configured using the `AWS_EC2_METADATA_SERVICE_ENDPOINT` environment variable.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ec2_metadata_service_endpoint AwsProvider#ec2_metadata_service_endpoint}
+     * @stability stable
+     */
+    readonly ec2MetadataServiceEndpoint?: string;
+    /**
+     * default_tags block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#default_tags AwsProvider#default_tags}
+     * @stability stable
+     */
+    readonly defaultTags?: IResolvable | Array<provider.AwsProviderDefaultTags>;
+    /**
+     * File containing custom root and intermediate certificates.
+     * Can also be configured using the `AWS_CA_BUNDLE` environment variable. (Setting `ca_bundle` in the shared config file is not supported.)
+     *
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#custom_ca_bundle AwsProvider#custom_ca_bundle}
+     * @stability stable
+     */
+    readonly customCaBundle?: string;
+    /**
+     * assume_role_with_web_identity block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#assume_role_with_web_identity AwsProvider#assume_role_with_web_identity}
+     * @stability stable
+     */
+    readonly assumeRoleWithWebIdentity?: IResolvable | Array<provider.AwsProviderAssumeRoleWithWebIdentity>;
+    /**
+     * assume_role block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#assume_role AwsProvider#assume_role}
+     * @stability stable
+     */
+    readonly assumeRole?: IResolvable | Array<provider.AwsProviderAssumeRole>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#allowed_account_ids AwsProvider#allowed_account_ids}.
+     * @stability stable
+     */
+    readonly allowedAccountIds?: Array<string>;
+    /**
+     * The access key for API operations. You can retrieve this from the 'Security & Credentials' section of the AWS console.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#access_key AwsProvider#access_key}
+     * @stability stable
+     */
+    readonly accessKey?: string;
+}

package/lib/aws/provider-config.generated.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-config.generated.js","sourceRoot":"","sources":["../../src/aws/provider-config.generated.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\".\nimport type { IResolvable } from 'cdktf';\nimport type { provider } from '@cdktf/provider-aws';\n\n/**\n * Config for the AWS Provider\n */\nexport interface AwsProviderConfig {\n  /**\n   * Resolve an endpoint with FIPS capability.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#use_fips_endpoint AwsProvider#use_fips_endpoint}\n   * @stability stable\n   */\n  readonly useFipsEndpoint?: boolean | IResolvable;\n  /**\n   * Resolve an endpoint with DualStack capability.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#use_dualstack_endpoint AwsProvider#use_dualstack_endpoint}\n   * @stability stable\n   */\n  readonly useDualstackEndpoint?: boolean | IResolvable;\n  /**\n   * The capacity of the AWS SDK's token bucket rate limiter.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#token_bucket_rate_limiter_capacity AwsProvider#token_bucket_rate_limiter_capacity}\n   * @stability stable\n   */\n  readonly tokenBucketRateLimiterCapacity?: number;\n  /**\n   * session token. A session token is only required if you are using temporary security credentials.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#token AwsProvider#token}\n   * @stability stable\n   */\n  readonly token?: string;\n  /**\n   * The region where AWS STS operations will take place. Examples are us-east-1 and us-west-2.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#sts_region AwsProvider#sts_region}\n   * @stability stable\n   */\n  readonly stsRegion?: string;\n  /**\n   * Skip requesting the account ID. Used for AWS API implementations that do not have IAM/STS API and/or metadata API.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_requesting_account_id AwsProvider#skip_requesting_account_id}\n   * @stability stable\n   */\n  readonly skipRequestingAccountId?: boolean | IResolvable;\n  /**\n   * Skip static validation of region name.\n   * Used by users of alternative AWS-like APIs or users w/ access to regions that are not public (yet).\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_region_validation AwsProvider#skip_region_validation}\n   * @stability stable\n   */\n  readonly skipRegionValidation?: boolean | IResolvable;\n  /**\n   * Skip the AWS Metadata API check. Used for AWS API implementations that do not have a metadata api endpoint.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_metadata_api_check AwsProvider#skip_metadata_api_check}\n   * @stability stable\n   */\n  readonly skipMetadataApiCheck?: string;\n  /**\n   * Skip the credentials validation via STS API. Used for AWS API implementations that do not have STS available/implemented.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#skip_credentials_validation AwsProvider#skip_credentials_validation}\n   * @stability stable\n   */\n  readonly skipCredentialsValidation?: boolean | IResolvable;\n  /**\n   * List of paths to shared credentials files. If not set, defaults to [~/.aws/credentials].\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#shared_credentials_files AwsProvider#shared_credentials_files}\n   * @stability stable\n   */\n  readonly sharedCredentialsFiles?: Array<string>;\n  /**\n   * List of paths to shared config files. If not set, defaults to [~/.aws/config].\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#shared_config_files AwsProvider#shared_config_files}\n   * @stability stable\n   */\n  readonly sharedConfigFiles?: Array<string>;\n  /**\n   * The secret key for API operations. You can retrieve this from the 'Security & Credentials' section of the AWS console.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#secret_key AwsProvider#secret_key}\n   * @stability stable\n   */\n  readonly secretKey?: string;\n  /**\n   * Set this to true to enable the request to use path-style addressing, i.e., https://s3.amazonaws.com/BUCKET/KEY. By default, the S3 client will use virtual hosted bucket addressing when possible (https://BUCKET.s3.amazonaws.com/KEY). Specific to the Amazon S3 service.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#s3_use_path_style AwsProvider#s3_use_path_style}\n   * @stability stable\n   */\n  readonly s3UsePathStyle?: boolean | IResolvable;\n  /**\n   * Specifies whether S3 API calls in the `us-east-1` region use the legacy global endpoint or a regional endpoint.\n   * Valid values are `legacy` or `regional`. Can also be configured using the `AWS_S3_US_EAST_1_REGIONAL_ENDPOINT` environment variable or the `s3_us_east_1_regional_endpoint` shared config file parameter\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#s3_us_east_1_regional_endpoint AwsProvider#s3_us_east_1_regional_endpoint}\n   * @stability stable\n   */\n  readonly s3UsEast1RegionalEndpoint?: string;\n  /**\n   * Specifies how retries are attempted.\n   * Valid values are `standard` and `adaptive`. Can also be configured using the `AWS_RETRY_MODE` environment variable.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#retry_mode AwsProvider#retry_mode}\n   * @stability stable\n   */\n  readonly retryMode?: string;\n  /**\n   * The region where AWS operations will take place. Examples are us-east-1, us-west-2, etc.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#region AwsProvider#region}\n   * @stability stable\n   */\n  readonly region?: string;\n  /**\n   * The profile for API operations. If not set, the default profile created with `aws configure` will be used.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#profile AwsProvider#profile}\n   * @stability stable\n   */\n  readonly profile?: string;\n  /**\n   * Comma-separated list of hosts that should not use HTTP or HTTPS proxies.\n   * Can also be set using the `NO_PROXY` or `no_proxy` environment variables.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#no_proxy AwsProvider#no_proxy}\n   * @stability stable\n   */\n  readonly noProxy?: string;\n  /**\n   * The maximum number of times an AWS API request is being executed.\n   * If the API request still fails, an error is\n   * thrown.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#max_retries AwsProvider#max_retries}\n   * @stability stable\n   */\n  readonly maxRetries?: number;\n  /**\n   * Explicitly allow the provider to perform \"insecure\" SSL requests. If omitted, default value is `false`.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#insecure AwsProvider#insecure}\n   * @stability stable\n   */\n  readonly insecure?: boolean | IResolvable;\n  /**\n   * ignore_tags block.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ignore_tags AwsProvider#ignore_tags}\n   * @stability stable\n   */\n  readonly ignoreTags?: IResolvable | Array<provider.AwsProviderIgnoreTags>;\n  /**\n   * URL of a proxy to use for HTTPS requests when accessing the AWS API.\n   * Can also be set using the `HTTPS_PROXY` or `https_proxy` environment variables.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#https_proxy AwsProvider#https_proxy}\n   * @stability stable\n   */\n  readonly httpsProxy?: string;\n  /**\n   * URL of a proxy to use for HTTP requests when accessing the AWS API.\n   * Can also be set using the `HTTP_PROXY` or `http_proxy` environment variables.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#http_proxy AwsProvider#http_proxy}\n   * @stability stable\n   */\n  readonly httpProxy?: string;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#forbidden_account_ids AwsProvider#forbidden_account_ids}.\n   * @stability stable\n   */\n  readonly forbiddenAccountIds?: Array<string>;\n  /**\n   * endpoints block.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#endpoints AwsProvider#endpoints}\n   * @stability stable\n   */\n  readonly endpoints?: IResolvable | Array<provider.AwsProviderEndpoints>;\n  /**\n   * Protocol to use with EC2 metadata service endpoint.Valid values are `IPv4` and `IPv6`. Can also be configured using the `AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE` environment variable.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ec2_metadata_service_endpoint_mode AwsProvider#ec2_metadata_service_endpoint_mode}\n   * @stability stable\n   */\n  readonly ec2MetadataServiceEndpointMode?: string;\n  /**\n   * Address of the EC2 metadata service endpoint to use. Can also be configured using the `AWS_EC2_METADATA_SERVICE_ENDPOINT` environment variable.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#ec2_metadata_service_endpoint AwsProvider#ec2_metadata_service_endpoint}\n   * @stability stable\n   */\n  readonly ec2MetadataServiceEndpoint?: string;\n  /**\n   * default_tags block.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#default_tags AwsProvider#default_tags}\n   * @stability stable\n   */\n  readonly defaultTags?: IResolvable | Array<provider.AwsProviderDefaultTags>;\n  /**\n   * File containing custom root and intermediate certificates.\n   * Can also be configured using the `AWS_CA_BUNDLE` environment variable. (Setting `ca_bundle` in the shared config file is not supported.)\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#custom_ca_bundle AwsProvider#custom_ca_bundle}\n   * @stability stable\n   */\n  readonly customCaBundle?: string;\n  /**\n   * assume_role_with_web_identity block.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#assume_role_with_web_identity AwsProvider#assume_role_with_web_identity}\n   * @stability stable\n   */\n  readonly assumeRoleWithWebIdentity?: IResolvable | Array<provider.AwsProviderAssumeRoleWithWebIdentity>;\n  /**\n   * assume_role block.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#assume_role AwsProvider#assume_role}\n   * @stability stable\n   */\n  readonly assumeRole?: IResolvable | Array<provider.AwsProviderAssumeRole>;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#allowed_account_ids AwsProvider#allowed_account_ids}.\n   * @stability stable\n   */\n  readonly allowedAccountIds?: Array<string>;\n  /**\n   * The access key for API operations. You can retrieve this from the 'Security & Credentials' section of the AWS console.\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs#access_key AwsProvider#access_key}\n   * @stability stable\n   */\n  readonly accessKey?: string;\n}\n"]}

package/lib/aws/storage/bucket-destination.d.ts

@@ -0,0 +1,41 @@
+import { Construct, IDependable } from "constructs";
+import { IBucket } from "./bucket";
+/**
+ * Implemented by constructs that can be used as bucket notification destinations.
+ */
+export interface IBucketNotificationDestination {
+    /**
+     * Registers this resource to receive notifications for the specified
+     * bucket. This method will only be called once for each destination/bucket
+     * pair and the result will be cached, so there is no need to implement
+     * idempotency in each destination.
+     * @param bucket The bucket object to bind to
+     */
+    bind(scope: Construct, bucket: IBucket): BucketNotificationDestinationConfig;
+}
+/**
+ * Represents the properties of a notification destination.
+ */
+export interface BucketNotificationDestinationConfig {
+    /**
+     * The notification type.
+     */
+    readonly type: BucketNotificationDestinationType;
+    /**
+     * The ARN of the destination (i.e. Lambda, SNS, SQS).
+     */
+    readonly arn: string;
+    /**
+     * Any additional dependencies that should be resolved before the bucket notification
+     * can be configured (for example, the SNS Topic Policy resource).
+     */
+    readonly dependencies?: IDependable[];
+}
+/**
+ * Supported types of notification destinations.
+ */
+export declare enum BucketNotificationDestinationType {
+    LAMBDA = 0,
+    QUEUE = 1,
+    TOPIC = 2
+}

package/lib/aws/storage/bucket-destination.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketNotificationDestinationType = void 0;
+/**
+ * Supported types of notification destinations.
+ */
+var BucketNotificationDestinationType;
+(function (BucketNotificationDestinationType) {
+    BucketNotificationDestinationType[BucketNotificationDestinationType["LAMBDA"] = 0] = "LAMBDA";
+    BucketNotificationDestinationType[BucketNotificationDestinationType["QUEUE"] = 1] = "QUEUE";
+    BucketNotificationDestinationType[BucketNotificationDestinationType["TOPIC"] = 2] = "TOPIC";
+})(BucketNotificationDestinationType || (exports.BucketNotificationDestinationType = BucketNotificationDestinationType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVja2V0LWRlc3RpbmF0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9zdG9yYWdlL2J1Y2tldC1kZXN0aW5hdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFzQ0E7O0dBRUc7QUFDSCxJQUFZLGlDQUlYO0FBSkQsV0FBWSxpQ0FBaUM7SUFDM0MsNkZBQU0sQ0FBQTtJQUNOLDJGQUFLLENBQUE7SUFDTCwyRkFBSyxDQUFBO0FBQ1AsQ0FBQyxFQUpXLGlDQUFpQyxpREFBakMsaUNBQWlDLFFBSTVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0LCBJRGVwZW5kYWJsZSB9IGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5pbXBvcnQgeyBJQnVja2V0IH0gZnJvbSBcIi4vYnVja2V0XCI7XG5cbi8qKlxuICogSW1wbGVtZW50ZWQgYnkgY29uc3RydWN0cyB0aGF0IGNhbiBiZSB1c2VkIGFzIGJ1Y2tldCBub3RpZmljYXRpb24gZGVzdGluYXRpb25zLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIElCdWNrZXROb3RpZmljYXRpb25EZXN0aW5hdGlvbiB7XG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgdGhpcyByZXNvdXJjZSB0byByZWNlaXZlIG5vdGlmaWNhdGlvbnMgZm9yIHRoZSBzcGVjaWZpZWRcbiAgICogYnVja2V0LiBUaGlzIG1ldGhvZCB3aWxsIG9ubHkgYmUgY2FsbGVkIG9uY2UgZm9yIGVhY2ggZGVzdGluYXRpb24vYnVja2V0XG4gICAqIHBhaXIgYW5kIHRoZSByZXN1bHQgd2lsbCBiZSBjYWNoZWQsIHNvIHRoZXJlIGlzIG5vIG5lZWQgdG8gaW1wbGVtZW50XG4gICAqIGlkZW1wb3RlbmN5IGluIGVhY2ggZGVzdGluYXRpb24uXG4gICAqIEBwYXJhbSBidWNrZXQgVGhlIGJ1Y2tldCBvYmplY3QgdG8gYmluZCB0b1xuICAgKi9cbiAgYmluZChzY29wZTogQ29uc3RydWN0LCBidWNrZXQ6IElCdWNrZXQpOiBCdWNrZXROb3RpZmljYXRpb25EZXN0aW5hdGlvbkNvbmZpZztcbn1cblxuLyoqXG4gKiBSZXByZXNlbnRzIHRoZSBwcm9wZXJ0aWVzIG9mIGEgbm90aWZpY2F0aW9uIGRlc3RpbmF0aW9uLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEJ1Y2tldE5vdGlmaWNhdGlvbkRlc3RpbmF0aW9uQ29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSBub3RpZmljYXRpb24gdHlwZS5cbiAgICovXG4gIHJlYWRvbmx5IHR5cGU6IEJ1Y2tldE5vdGlmaWNhdGlvbkRlc3RpbmF0aW9uVHlwZTtcblxuICAvKipcbiAgICogVGhlIEFSTiBvZiB0aGUgZGVzdGluYXRpb24gKGkuZS4gTGFtYmRhLCBTTlMsIFNRUykuXG4gICAqL1xuICByZWFkb25seSBhcm46IHN0cmluZztcblxuICAvKipcbiAgICogQW55IGFkZGl0aW9uYWwgZGVwZW5kZW5jaWVzIHRoYXQgc2hvdWxkIGJlIHJlc29sdmVkIGJlZm9yZSB0aGUgYnVja2V0IG5vdGlmaWNhdGlvblxuICAgKiBjYW4gYmUgY29uZmlndXJlZCAoZm9yIGV4YW1wbGUsIHRoZSBTTlMgVG9waWMgUG9saWN5IHJlc291cmNlKS5cbiAgICovXG4gIHJlYWRvbmx5IGRlcGVuZGVuY2llcz86IElEZXBlbmRhYmxlW107XG59XG5cbi8qKlxuICogU3VwcG9ydGVkIHR5cGVzIG9mIG5vdGlmaWNhdGlvbiBkZXN0aW5hdGlvbnMuXG4gKi9cbmV4cG9ydCBlbnVtIEJ1Y2tldE5vdGlmaWNhdGlvbkRlc3RpbmF0aW9uVHlwZSB7XG4gIExBTUJEQSxcbiAgUVVFVUUsXG4gIFRPUElDLFxufVxuIl19