agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-events/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.services.events"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.AWS.Events"
+    },
+    "python": {
+      "module": "aws_cdk.aws_events"
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-events/README.md

@@ -0,0 +1,382 @@
+# Amazon EventBridge Construct Library
+
+
+Amazon EventBridge delivers a near real-time stream of system events that
+describe changes in AWS resources. For example, an AWS CodePipeline emits the
+[State
+Change](https://docs.aws.amazon.com/eventbridge/latest/userguide/event-types.html#codepipeline-event-type)
+event when the pipeline changes its state.
+
+* __Events__: An event indicates a change in your AWS environment. AWS resources
+  can generate events when their state changes. For example, Amazon EC2
+  generates an event when the state of an EC2 instance changes from pending to
+  running, and Amazon EC2 Auto Scaling generates events when it launches or
+  terminates instances. AWS CloudTrail publishes events when you make API calls.
+  You can generate custom application-level events and publish them to
+  EventBridge. You can also set up scheduled events that are generated on
+  a periodic basis. For a list of services that generate events, and sample
+  events from each service, see [EventBridge Event Examples From Each
+  Supported
+  Service](https://docs.aws.amazon.com/eventbridge/latest/userguide/event-types.html).
+* __Targets__: A target processes events. Targets can include Amazon EC2
+  instances, AWS Lambda functions, Kinesis streams, Amazon ECS tasks, Step
+  Functions state machines, Amazon SNS topics, Amazon SQS queues, Amazon CloudWatch LogGroups, and built-in
+  targets. A target receives events in JSON format.
+* __Rules__: A rule matches incoming events and routes them to targets for
+  processing. A single rule can route to multiple targets, all of which are
+  processed in parallel. Rules are not processed in a particular order. This
+  enables different parts of an organization to look for and process the events
+  that are of interest to them. A rule can customize the JSON sent to the
+  target, by passing only certain parts or by overwriting it with a constant.
+* __EventBuses__: An event bus can receive events from your own custom applications
+  or it can receive events from applications and services created by AWS SaaS partners.
+  See [Creating an Event Bus](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-event-bus.html).
+
+## Rule
+
+The `Rule` construct defines an EventBridge rule which monitors an
+event based on an [event
+pattern](https://docs.aws.amazon.com/eventbridge/latest/userguide/filtering-examples-structure.html)
+and invoke __event targets__ when the pattern is matched against a triggered
+event. Event targets are objects that implement the `IRuleTarget` interface.
+
+Normally, you will use one of the `source.onXxx(name[, target[, options]]) ->
+Rule` methods on the event source to define an event rule associated with
+the specific activity. You can targets either via props, or add targets using
+`rule.addTarget`.
+
+For example, to define an rule that triggers a CodeBuild project build when a
+commit is pushed to the "master" branch of a CodeCommit repository:
+
+```ts
+declare const repo: codecommit.Repository;
+declare const project: codebuild.Project;
+
+const onCommitRule = repo.onCommit('OnCommit', {
+  target: new targets.CodeBuildProject(project),
+  eventPattern: {
+    detail: {
+      referenceType: ['branch'],
+    }
+  },
+  branches: events.Match.prefix('main')
+});
+```
+
+You can add additional targets, with optional [input
+transformer](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_InputTransformer.html)
+using `eventRule.addTarget(target[, input])`. For example, we can add a SNS
+topic target which formats a human-readable message for the commit.
+
+For example, this adds an SNS topic as a target:
+
+```ts
+declare const onCommitRule: events.Rule;
+declare const topic: sns.Topic;
+
+onCommitRule.addTarget(new targets.SnsTopic(topic, {
+  message: events.RuleTargetInput.fromText(
+    `A commit was pushed to the repository ${codecommit.ReferenceEvent.repositoryName} on branch ${codecommit.ReferenceEvent.referenceName}`
+  )
+}));
+```
+
+Or using an Object:
+
+```ts
+declare const onCommitRule: events.Rule;
+declare const topic: sns.Topic;
+
+onCommitRule.addTarget(new targets.SnsTopic(topic, {
+  message: events.RuleTargetInput.fromObject(
+    {
+      DataType: `custom_${events.EventField.fromPath('$.detail-type')}`
+    }
+  )
+}));
+```
+
+### Role
+You can specify an IAM Role:
+
+```ts
+declare const role: iam.IRole;
+
+new events.Rule(this, 'MyRule', {
+  schedule: events.Schedule.cron({ minute: '0', hour: '4' }),
+  role,
+});
+```
+
+**Note**: If you're setting an event bus in another account as the target and that account granted permission to your account through an organization instead of directly by the account ID, you must specify a RoleArn with proper permissions in the Target structure, instead of here in this parameter.
+
+### Matchers
+
+To define a pattern, use the `Match` class, which provides a number of factory methods to declare
+different logical predicates. For example, to match all S3 events for objects larger than 1024
+bytes, stored using one of the storage classes Glacier, Glacier IR or Deep Archive and coming from
+any region other than the AWS GovCloud ones:
+
+```ts
+const rule = new events.Rule(this, 'rule', {
+  eventPattern: {
+    detail: {
+      object: {
+        // Matchers may appear at any level
+        size: events.Match.greaterThan(1024),
+      },
+
+      // 'OR' condition
+      'source-storage-class': events.Match.anyOf(
+        events.Match.prefix('GLACIER'),
+        events.Match.exactString('DEEP_ARCHIVE'),
+      ),
+    },
+
+    // If you prefer, you can use a low level array of strings, as directly consumed by EventBridge
+    source: ['aws.s3'],
+
+    region: events.Match.anythingButPrefix('us-gov'),
+  },
+});
+```
+
+Matches can also be made case-insensitive, or make use of wildcard matches. For example, to match
+object create events for buckets whose name starts with `raw-`, for objects with key matching
+the pattern `path/to/object/*.txt` and the requester ends with `.AMAZONAWS.COM`:
+
+```ts
+const rule = new events.Rule(this, 'rule', {
+  eventPattern: {
+    detail: {
+      bucket: {
+        name: events.Match.prefixEqualsIgnoreCase('raw-'),
+      },
+
+      object: {
+        key: events.Match.wildcard('path/to/object/*.txt'),
+      },
+
+      requester: events.Match.suffixEqualsIgnoreCase('.AMAZONAWS.COM'),
+    },
+    detailType: events.Match.equalsIgnoreCase('object created'),
+  },
+});
+```
+
+The "anything but" matchers allow you to specify multiple arguments. For example:
+
+```ts
+const rule = new events.Rule(this, 'rule', {
+  eventPattern: {
+    region: events.Match.anythingBut('us-east-1', 'us-east-2', 'us-west-1', 'us-west-2'),
+
+    detail: {
+      bucket: {
+        name: events.Match.anythingButPrefix('foo', 'bar', 'baz'),
+      },
+
+      object: {
+        key: events.Match.anythingButSuffix('.gif', '.png', '.jpg'),
+      },
+
+      requester: events.Match.anythingButWildcard('*.amazonaws.com', '123456789012'),
+    },
+    detailType: events.Match.anythingButEqualsIgnoreCase('object created', 'object deleted'),
+  },
+});
+```
+
+## Scheduling
+
+You can configure a Rule to run on a schedule (cron or rate).
+Rate must be specified in minutes, hours or days.
+
+The following example runs a task every day at 4am:
+
+```ts fixture=basic
+import { Rule, Schedule } from 'aws-cdk-lib/aws-events';
+import { EcsTask } from 'aws-cdk-lib/aws-events-targets';
+import { Cluster, TaskDefinition } from 'aws-cdk-lib/aws-ecs';
+import { Role } from 'aws-cdk-lib/aws-iam';
+
+declare const cluster: Cluster;
+declare const taskDefinition: TaskDefinition;
+declare const role: Role;
+
+const ecsTaskTarget = new EcsTask({ cluster, taskDefinition, role });
+
+new Rule(this, 'ScheduleRule', {
+ schedule: Schedule.cron({ minute: '0', hour: '4' }),
+ targets: [ecsTaskTarget],
+});
+```
+
+If you want to specify Fargate platform version, set `platformVersion` in EcsTask's props like the following example:
+
+```ts
+declare const cluster: ecs.Cluster;
+declare const taskDefinition: ecs.TaskDefinition;
+declare const role: iam.Role;
+
+const platformVersion = ecs.FargatePlatformVersion.VERSION1_4;
+const ecsTaskTarget = new targets.EcsTask({ cluster, taskDefinition, role, platformVersion });
+```
+
+## Event Targets
+
+The `aws-cdk-lib/aws-events-targets` module includes classes that implement the `IRuleTarget`
+interface for various AWS services.
+
+See the README of the [`aws-cdk-lib/aws-events-targets`](https://github.com/aws/aws-cdk/tree/main/packages/aws-cdk-lib/aws-events-targets) module for more information on supported targets.
+
+### Cross-account and cross-region targets
+
+It's possible to have the source of the event and a target in separate AWS accounts and regions:
+
+```ts nofixture
+import { App, Stack } from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import * as codecommit from 'aws-cdk-lib/aws-codecommit';
+import * as targets from 'aws-cdk-lib/aws-events-targets';
+
+const app = new App();
+
+const account1 = '11111111111';
+const account2 = '22222222222';
+
+const stack1 = new Stack(app, 'Stack1', { env: { account: account1, region: 'us-west-1' } });
+const repo = new codecommit.Repository(stack1, 'Repository', {
+  repositoryName: 'myrepository',
+});
+
+const stack2 = new Stack(app, 'Stack2', { env: { account: account2, region: 'us-east-1' } });
+const project = new codebuild.Project(stack2, 'Project', {
+  // ...
+});
+
+repo.onCommit('OnCommit', {
+  target: new targets.CodeBuildProject(project),
+});
+```
+
+In this situation, the CDK will wire the 2 accounts together:
+
+* It will generate a rule in the source stack with the event bus of the target account as the target
+* It will generate a rule in the target stack, with the provided target
+* It will generate a separate stack that gives the source account permissions to publish events
+  to the event bus of the target account in the given region,
+  and make sure its deployed before the source stack
+
+For more information, see the
+[AWS documentation on cross-account events](https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html).
+
+## Archiving
+
+It is possible to archive all or some events sent to an event bus. It is then possible to [replay these events](https://aws.amazon.com/blogs/aws/new-archive-and-replay-events-with-amazon-eventbridge/).
+
+```ts
+const bus = new events.EventBus(this, 'bus', {
+  eventBusName: 'MyCustomEventBus',
+  description: 'MyCustomEventBus',
+});
+
+bus.archive('MyArchive', {
+  archiveName: 'MyCustomEventBusArchive',
+  description: 'MyCustomerEventBus Archive',
+  eventPattern: {
+    account: [Stack.of(this).account],
+  },
+  retention: Duration.days(365),
+});
+```
+
+## Dead-Letter Queue for EventBus
+
+It is possible to configure a [Dead Letter Queue for an EventBus](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rule-event-delivery.html#eb-rule-dlq). This is useful when you want to capture events that could not be delivered to any of the targets.
+
+To configure a Dead Letter Queue for an EventBus, you can use the `deadLetterQueue` property of the `EventBus` construct.
+
+```ts
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+
+const dlq = new sqs.Queue(this, 'DLQ');
+
+const bus = new events.EventBus(this, 'Bus', {
+  deadLetterQueue: dlq,
+});
+```
+
+## Granting PutEvents to an existing EventBus
+
+To import an existing EventBus into your CDK application, use `EventBus.fromEventBusArn`, `EventBus.fromEventBusAttributes`
+or `EventBus.fromEventBusName` factory method.
+
+Then, you can use the `grantPutEventsTo` method to grant `event:PutEvents` to the eventBus.
+
+```ts
+declare const lambdaFunction: lambda.Function;
+
+const eventBus = events.EventBus.fromEventBusArn(this, 'ImportedEventBus', 'arn:aws:events:us-east-1:111111111:event-bus/my-event-bus');
+
+// now you can just call methods on the eventbus
+eventBus.grantPutEventsTo(lambdaFunction);
+```
+
+## Use a customer managed key
+
+To use a customer managed key for events on the event bus, use the `kmsKey` attribute.
+
+```ts
+import * as kms from 'aws-cdk-lib/aws-kms';
+
+declare const kmsKey: kms.IKey;
+
+new events.EventBus(this, 'Bus', {
+  kmsKey,
+});
+```
+
+To use a customer managed key for an archive, use the `kmsKey` attribute. 
+
+Note: When you attach a customer managed key to either an EventBus or an Archive, a policy that allows EventBridge to interact with your resource will be added. 
+
+```ts
+import * as kms from 'aws-cdk-lib/aws-kms';
+import { Archive, EventBus } from 'aws-cdk-lib/aws-events';
+
+const stack = new Stack();
+
+declare const kmsKey: kms.IKey;
+
+const eventBus = new EventBus(stack, 'Bus');
+
+const archive = new Archive(stack, 'Archive', {
+  kmsKey: kmsKey,
+  sourceEventBus: eventBus,
+  eventPattern: {
+    source: ['aws.ec2']
+  },
+});
+```
+
+To enable archives on an event bus, customers have the choice of using either an AWS owned key or a customer managed key.
+Note that schema discovery is not supported for event buses encrypted using a customer managed key. To enable schema discovery on an event bus, choose to use an AWS owned key.
+For more information, see [KMS key options for event bus encryption](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-at-rest-key-options.html) and [Encrypting event buses with customer managed keys](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-event-bus-cmkey.html).
+
+## Configuring logging
+
+To configure logging for an Event Bus, leverage the LogConfig property. It allows different level of logging (NONE, INFO, TRACE, ERROR) and whether to include details or not.
+
+```ts
+import { EventBus, IncludeDetail, Level } from 'aws-cdk-lib/aws-events';
+
+const bus =  new EventBus(this, 'Bus', {
+      logConfig: {
+        includeDetail: IncludeDetail.FULL,
+        level: Level.TRACE,
+      },
+    });
+```
+
+See more [Specifying event bus log level](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-bus-logs.html#eb-event-bus-logs-level)

cdk/node_modules/aws-cdk-lib/aws-events/grants.json

@@ -0,0 +1,13 @@
+{
+  "resources": {
+    "EventBus": {
+      "grants": {
+        "allPutEvents": {
+          "actions": ["events:PutEvents"],
+          "arnFormat": "*",
+          "docSummary": "Permits an IAM Principal to send custom events to EventBridge\nso that they can be matched to rules."
+        }
+      }
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-events/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

cdk/node_modules/aws-cdk-lib/aws-events/lib/api-destination.d.ts

@@ -0,0 +1,130 @@
+import type { Construct } from 'constructs';
+import type { IConnection } from './connection';
+import { HttpMethod } from './connection';
+import type { IConnectionRef } from './events.generated';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+import type { ApiDestinationReference, IApiDestinationRef } from '../../interfaces/generated/aws-events-interfaces.generated';
+/**
+ * The event API Destination properties
+ */
+export interface ApiDestinationProps {
+    /**
+     * The name for the API destination.
+     * @default - A unique name will be generated
+     */
+    readonly apiDestinationName?: string;
+    /**
+     * A description for the API destination.
+     *
+     * @default - none
+     */
+    readonly description?: string;
+    /**
+     * The ARN of the connection to use for the API destination
+     */
+    readonly connection: IConnectionRef;
+    /**
+     * The URL to the HTTP invocation endpoint for the API destination..
+     */
+    readonly endpoint: string;
+    /**
+     * The method to use for the request to the HTTP invocation endpoint.
+     *
+     * @default HttpMethod.POST
+     */
+    readonly httpMethod?: HttpMethod;
+    /**
+     * The maximum number of requests per second to send to the HTTP invocation endpoint.
+     *
+     * @default - Not rate limited
+     */
+    readonly rateLimitPerSecond?: number;
+}
+/**
+ * Interface for API Destinations
+ */
+export interface IApiDestination extends IResource, IApiDestinationRef {
+    /**
+     * The Name of the Api Destination created.
+     * @attribute
+     */
+    readonly apiDestinationName: string;
+    /**
+     * The ARN of the Api Destination created.
+     * @attribute
+     */
+    readonly apiDestinationArn: string;
+    /**
+     * The Amazon Resource Name (ARN) of an API destination in resource format,
+     * so it can be used in the Resource element of IAM permission policy statements.
+     * @see https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoneventbridge.html#amazoneventbridge-resources-for-iam-policies
+     * @attribute
+     */
+    readonly apiDestinationArnForPolicy?: string;
+}
+/**
+ * The properties to import an existing Api Destination
+ */
+export interface ApiDestinationAttributes {
+    /**
+     * The ARN of the Api Destination
+     */
+    readonly apiDestinationArn: string;
+    /**
+     * The Connection to associate with the Api Destination
+     */
+    readonly connection: IConnectionRef;
+    /**
+     * The Amazon Resource Name (ARN) of an API destination in resource format.
+     *
+     * @default undefined - Imported API destination does not have ARN in resource format
+     */
+    readonly apiDestinationArnForPolicy?: string;
+}
+/**
+ * Define an EventBridge Api Destination
+ *
+ * @resource AWS::Events::ApiDestination
+ */
+export declare class ApiDestination extends Resource implements IApiDestination {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Create an Api Destination construct from an existing Api Destination ARN.
+     *
+     * @param scope The scope creating construct (usually `this`).
+     * @param id The construct's id.
+     * @param attrs The Api Destination import attributes.
+     */
+    static fromApiDestinationAttributes(scope: Construct, id: string, attrs: ApiDestinationAttributes): IApiDestination;
+    /**
+     * The Connection to associate with Api Destination
+     */
+    private readonly _connection;
+    /**
+     * The CfnApiDestination resource
+     */
+    private readonly _resource;
+    /**
+     * The Name of the Api Destination created.
+     * @attribute
+     */
+    get apiDestinationName(): string;
+    /**
+     * The ARN of the Api Destination created.
+     * @attribute
+     */
+    get apiDestinationArn(): string;
+    /**
+     * The Amazon Resource Name (ARN) of an API destination in resource format.
+     * @attribute
+     */
+    get apiDestinationArnForPolicy(): string | undefined;
+    /**
+     * The Connection to associate with Api Destination
+     */
+    get connection(): IConnection;
+    get apiDestinationRef(): ApiDestinationReference;
+    constructor(scope: Construct, id: string, props: ApiDestinationProps);
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/archive.d.ts

@@ -0,0 +1,67 @@
+import type { Construct } from 'constructs';
+import type { EventPattern } from './event-pattern';
+import type { IEventBusRef } from './events.generated';
+import type * as kms from '../../aws-kms';
+import type { Duration } from '../../core';
+import { Resource } from '../../core';
+/**
+ * The event archive base properties
+ */
+export interface BaseArchiveProps {
+    /**
+     * The name of the archive.
+     *
+     * @default - Automatically generated
+     */
+    readonly archiveName?: string;
+    /**
+     * A description for the archive.
+     *
+     * @default - none
+     */
+    readonly description?: string;
+    /**
+     * An event pattern to use to filter events sent to the archive.
+     */
+    readonly eventPattern: EventPattern;
+    /**
+     * The number of days to retain events for. Default value is 0. If set to 0, events are retained indefinitely.
+     * @default - Infinite
+     */
+    readonly retention?: Duration;
+    /**
+     * The customer managed key that encrypts this archive
+     *
+     * @default - Use an AWS managed key
+     */
+    readonly kmsKey?: kms.IKey;
+}
+/**
+ * The event archive properties
+ */
+export interface ArchiveProps extends BaseArchiveProps {
+    /**
+     * The event source associated with the archive.
+     */
+    readonly sourceEventBus: IEventBusRef;
+}
+/**
+ * Define an EventBridge Archive
+ *
+ * @resource AWS::Events::Archive
+ */
+export declare class Archive extends Resource {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * The archive name.
+     * @attribute
+     */
+    readonly archiveName: string;
+    /**
+     * The ARN of the archive created.
+     * @attribute
+     */
+    readonly archiveArn: string;
+    constructor(scope: Construct, id: string, props: ArchiveProps);
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/archive.js

@@ -0,0 +1 @@
+"use strict";var __esDecorate=exports&&exports.__esDecorate||function(ctor,descriptorIn,decorators,contextIn,initializers,extraInitializers){function accept(f){if(f!==void 0&&typeof f!="function")throw new TypeError("Function expected");return f}for(var kind=contextIn.kind,key=kind==="getter"?"get":kind==="setter"?"set":"value",target=!descriptorIn&&ctor?contextIn.static?ctor:ctor.prototype:null,descriptor=descriptorIn||(target?Object.getOwnPropertyDescriptor(target,contextIn.name):{}),_,done=!1,i=decorators.length-1;i>=0;i--){var context={};for(var p in contextIn)context[p]=p==="access"?{}:contextIn[p];for(var p in contextIn.access)context.access[p]=contextIn.access[p];context.addInitializer=function(f){if(done)throw new TypeError("Cannot add initializers after decoration has completed");extraInitializers.push(accept(f||null))};var result=(0,decorators[i])(kind==="accessor"?{get:descriptor.get,set:descriptor.set}:descriptor[key],context);if(kind==="accessor"){if(result===void 0)continue;if(result===null||typeof result!="object")throw new TypeError("Object expected");(_=accept(result.get))&&(descriptor.get=_),(_=accept(result.set))&&(descriptor.set=_),(_=accept(result.init))&&initializers.unshift(_)}else(_=accept(result))&&(kind==="field"?initializers.unshift(_):descriptor[key]=_)}target&&Object.defineProperty(target,contextIn.name,descriptor),done=!0},__runInitializers=exports&&exports.__runInitializers||function(thisArg,initializers,value){for(var useValue=arguments.length>2,i=0;i<initializers.length;i++)value=useValue?initializers[i].call(thisArg,value):initializers[i].call(thisArg);return useValue?value:void 0};Object.defineProperty(exports,"__esModule",{value:!0}),exports.Archive=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var events_generated_1=()=>{var tmp=require("./events.generated");return events_generated_1=()=>tmp,tmp},util_1=()=>{var tmp=require("./util");return util_1=()=>tmp,tmp},iam=()=>{var tmp=require("../../aws-iam");return iam=()=>tmp,tmp},core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},metadata_resource_1=()=>{var tmp=require("../../core/lib/metadata-resource");return metadata_resource_1=()=>tmp,tmp},prop_injectable_1=()=>{var tmp=require("../../core/lib/prop-injectable");return prop_injectable_1=()=>tmp,tmp};let Archive=(()=>{let _classDecorators=[prop_injectable_1().propertyInjectable],_classDescriptor,_classExtraInitializers=[],_classThis,_classSuper=core_1().Resource;var Archive2=class extends _classSuper{static{_classThis=this}static{const _metadata=typeof Symbol=="function"&&Symbol.metadata?Object.create(_classSuper[Symbol.metadata]??null):void 0;__esDecorate(null,_classDescriptor={value:_classThis},_classDecorators,{kind:"class",name:_classThis.name,metadata:_metadata},null,_classExtraInitializers),Archive2=_classThis=_classDescriptor.value,_metadata&&Object.defineProperty(_classThis,Symbol.metadata,{enumerable:!0,configurable:!0,writable:!0,value:_metadata})}static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_events.Archive",version:"2.252.0"};static PROPERTY_INJECTION_ID="aws-cdk-lib.aws-events.Archive";archiveName;archiveArn;constructor(scope,id,props){super(scope,id,{physicalName:props.archiveName});try{jsiiDeprecationWarnings().aws_cdk_lib_aws_events_ArchiveProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Archive2),error}(0,metadata_resource_1().addConstructMetadata)(this,props),props?.kmsKey&&(props?.kmsKey.addToResourcePolicy(new(iam()).PolicyStatement({resources:["*"],actions:["kms:Decrypt","kms:GenerateDataKey","kms:ReEncrypt*"],principals:[new(iam()).ServicePrincipal("events.amazonaws.com")],sid:"Allow EventBridge to use kms operations",effect:iam().Effect.ALLOW,conditions:{StringEquals:{"kms:EncryptionContext:aws:events:event-bus:arn":props.sourceEventBus.eventBusRef.eventBusArn}}})),props?.kmsKey.addToResourcePolicy(new(iam()).PolicyStatement({resources:["*"],actions:["kms:DescribeKey"],principals:[new(iam()).ServicePrincipal("events.amazonaws.com")],sid:"Allow EventBridge to call kms:DescribeKey",effect:iam().Effect.ALLOW})));let archive=new(events_generated_1()).CfnArchive(this,"Archive",{sourceArn:props.sourceEventBus.eventBusRef.eventBusArn,description:props.description,eventPattern:(0,util_1().renderEventPattern)(props.eventPattern),retentionDays:props.retention?.toDays({integral:!0})||0,archiveName:this.physicalName,kmsKeyIdentifier:props?.kmsKey?.keyArn||""});this.archiveArn=archive.attrArn,this.archiveName=archive.ref,this.node.defaultChild=archive}static{__runInitializers(_classThis,_classExtraInitializers)}};return Archive2=_classThis})();exports.Archive=Archive;

cdk/node_modules/aws-cdk-lib/aws-events/lib/connection.d.ts

@@ -0,0 +1,260 @@
+import type { Construct } from 'constructs';
+import type { IResource, SecretValue } from '../../core';
+import { Resource } from '../../core';
+import type { ConnectionReference, IConnectionRef } from '../../interfaces/generated/aws-events-interfaces.generated';
+/**
+ * An API Destination Connection
+ *
+ * A connection defines the authorization type and credentials to use for authorization with an API destination HTTP endpoint.
+ */
+export interface ConnectionProps {
+    /**
+     * The name of the connection.
+     *
+     * @default - A name is automatically generated
+     */
+    readonly connectionName?: string;
+    /**
+     * The name of the connection.
+     *
+     * @default - none
+     */
+    readonly description?: string;
+    /**
+     * The authorization type for the connection.
+     */
+    readonly authorization: Authorization;
+    /**
+     * Additional string parameters to add to the invocation bodies
+     *
+     * @default - No additional parameters
+     */
+    readonly bodyParameters?: Record<string, HttpParameter>;
+    /**
+     * Additional string parameters to add to the invocation headers
+     *
+     * @default - No additional parameters
+     */
+    readonly headerParameters?: Record<string, HttpParameter>;
+    /**
+     * Additional string parameters to add to the invocation query strings
+     *
+     * @default - No additional parameters
+     */
+    readonly queryStringParameters?: Record<string, HttpParameter>;
+}
+/**
+ * Authorization type for an API Destination Connection
+ */
+export declare abstract class Authorization {
+    /**
+     * Use API key authorization
+     *
+     * API key authorization has two components: an API key name and an API key value.
+     * What these are depends on the target of your connection.
+     */
+    static apiKey(apiKeyName: string, apiKeyValue: SecretValue): Authorization;
+    /**
+     * Use username and password authorization
+     */
+    static basic(username: string, password: SecretValue): Authorization;
+    /**
+     * Use OAuth authorization
+     */
+    static oauth(props: OAuthAuthorizationProps): Authorization;
+    /**
+     * Bind the authorization to the construct and return the authorization properties
+     *
+     * @internal
+     */
+    abstract _bind(): AuthorizationBindResult;
+}
+/**
+ * Properties for `Authorization.oauth()`
+ */
+export interface OAuthAuthorizationProps {
+    /**
+     * The URL to the authorization endpoint
+     */
+    readonly authorizationEndpoint: string;
+    /**
+     * The method to use for the authorization request.
+     *
+     * (Can only choose POST, GET or PUT).
+     */
+    readonly httpMethod: HttpMethod;
+    /**
+     * The client ID to use for OAuth authorization for the connection.
+     */
+    readonly clientId: string;
+    /**
+     * The client secret associated with the client ID to use for OAuth authorization for the connection.
+     */
+    readonly clientSecret: SecretValue;
+    /**
+     * Additional string parameters to add to the OAuth request body
+     *
+     * @default - No additional parameters
+     */
+    readonly bodyParameters?: Record<string, HttpParameter>;
+    /**
+     * Additional string parameters to add to the OAuth request header
+     *
+     * @default - No additional parameters
+     */
+    readonly headerParameters?: Record<string, HttpParameter>;
+    /**
+     * Additional string parameters to add to the OAuth request query string
+     *
+     * @default - No additional parameters
+     */
+    readonly queryStringParameters?: Record<string, HttpParameter>;
+}
+/**
+ * An additional HTTP parameter to send along with the OAuth request
+ */
+export declare abstract class HttpParameter {
+    /**
+     * Make an OAuthParameter from a string value
+     *
+     * The value is not treated as a secret.
+     */
+    static fromString(value: string): HttpParameter;
+    /**
+     * Make an OAuthParameter from a secret
+     */
+    static fromSecret(value: SecretValue): HttpParameter;
+    /**
+     * Render the parameter value
+     *
+     * @internal
+     */
+    abstract _render(name: string): any;
+}
+/**
+ * Result of the 'bind' operation of the 'Authorization' class
+ *
+ * @internal
+ */
+export interface AuthorizationBindResult {
+    /**
+     * The authorization type
+     */
+    readonly authorizationType: AuthorizationType;
+    /**
+     * The authorization parameters (depends on the type)
+     */
+    readonly authParameters: any;
+}
+/**
+ * Interface for EventBus Connections
+ */
+export interface IConnection extends IResource, IConnectionRef {
+    /**
+     * The Name for the connection.
+     * @attribute
+     */
+    readonly connectionName: string;
+    /**
+     * The ARN of the connection created.
+     * @attribute
+     */
+    readonly connectionArn: string;
+    /**
+     * The ARN for the secret created for the connection.
+     * @attribute
+     */
+    readonly connectionSecretArn: string;
+}
+/**
+ * Interface with properties necessary to import a reusable Connection
+ */
+export interface ConnectionAttributes {
+    /**
+     * The Name for the connection.
+     */
+    readonly connectionName: string;
+    /**
+     * The ARN of the connection created.
+     */
+    readonly connectionArn: string;
+    /**
+     * The ARN for the secret created for the connection.
+     */
+    readonly connectionSecretArn: string;
+}
+/**
+ * Define an EventBridge Connection
+ *
+ * @resource AWS::Events::Connection
+ */
+export declare class Connection extends Resource implements IConnection {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing connection resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param connectionArn ARN of imported connection
+     */
+    static fromEventBusArn(scope: Construct, id: string, connectionArn: string, connectionSecretArn: string): IConnection;
+    /**
+     * Import an existing connection resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param attrs Imported connection properties
+     */
+    static fromConnectionAttributes(scope: Construct, id: string, attrs: ConnectionAttributes): IConnection;
+    /**
+     * The CfnConnection resource
+     */
+    private readonly _resource;
+    /**
+     * The Name for the connection.
+     * @attribute
+     */
+    get connectionName(): string;
+    /**
+     * The ARN of the connection created.
+     * @attribute
+     */
+    get connectionArn(): string;
+    /**
+     * The ARN for the secret created for the connection.
+     * @attribute
+     */
+    get connectionSecretArn(): string;
+    get connectionRef(): ConnectionReference;
+    constructor(scope: Construct, id: string, props: ConnectionProps);
+}
+/**
+ * Supported HTTP operations.
+ */
+export declare enum HttpMethod {
+    /** POST */
+    POST = "POST",
+    /** GET */
+    GET = "GET",
+    /** HEAD */
+    HEAD = "HEAD",
+    /** OPTIONS */
+    OPTIONS = "OPTIONS",
+    /** PUT */
+    PUT = "PUT",
+    /** PATCH */
+    PATCH = "PATCH",
+    /** DELETE */
+    DELETE = "DELETE"
+}
+/**
+ * Supported Authorization Types.
+ */
+declare enum AuthorizationType {
+    /** API_KEY */
+    API_KEY = "API_KEY",
+    /** BASIC */
+    BASIC = "BASIC",
+    /** OAUTH_CLIENT_CREDENTIALS */
+    OAUTH_CLIENT_CREDENTIALS = "OAUTH_CLIENT_CREDENTIALS"
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-events/lib/event-bus.d.ts

@@ -0,0 +1,333 @@
+import type { Construct } from 'constructs';
+import type { BaseArchiveProps } from './archive';
+import { Archive } from './archive';
+import { EventBusGrants } from './events-grants.generated';
+import type { EventBusReference, IEventBusRef } from './events.generated';
+import * as iam from '../../aws-iam';
+import type * as kms from '../../aws-kms';
+import type * as sqs from '../../aws-sqs';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+/**
+ *  Whether EventBridge include detailed event information in the records it generates.
+ *  Detailed data can be useful for troubleshooting and debugging.
+ *  This information includes details of the event itself, as well as target details.
+ */
+export declare enum IncludeDetail {
+    /**
+     * FULL: Include all details related to event itself and the request EventBridge sends to the target.
+     * Detailed data can be useful for troubleshooting and debugging.
+     */
+    FULL = "FULL",
+    /**
+     * NONE: Does not include any details.
+     */
+    NONE = "NONE"
+}
+/**
+ * The level of logging detail to include. This applies to all log destinations for the event bus.
+ */
+export declare enum Level {
+    /**
+     * INFO: EventBridge sends any logs related to errors, as well as major steps performed during event processing
+     */
+    INFO = "INFO",
+    /**
+     * ERROR: EventBridge sends any logs related to errors generated during event processing and target delivery.
+     */
+    ERROR = "ERROR",
+    /**
+     * TRACE: EventBridge sends any logs generated during all steps in the event processing.
+     */
+    TRACE = "TRACE",
+    /**
+     *  OFF: EventBridge does not send any logs. This is the default.
+     */
+    OFF = "OFF"
+}
+/**
+ *  Interface for Logging Configuration of the Event Bus
+ */
+export interface LogConfig {
+    /**
+     * Whether EventBridge include detailed event information in the records it generates.
+     * @default no details
+     */
+    readonly includeDetail?: IncludeDetail;
+    /**
+     * Logging level
+     * @default OFF
+     */
+    readonly level?: Level;
+}
+/**
+ * Interface which all EventBus based classes MUST implement
+ */
+export interface IEventBus extends IResource, IEventBusRef {
+    /**
+     * The physical ID of this event bus resource
+     *
+     * @attribute
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     */
+    readonly eventBusName: string;
+    /**
+     * The ARN of this event bus resource
+     *
+     * @attribute
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt
+     */
+    readonly eventBusArn: string;
+    /**
+     * The JSON policy of this event bus resource
+     *
+     * @attribute
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Policy-fn::getatt
+     */
+    readonly eventBusPolicy: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     */
+    readonly eventSourceName?: string;
+    /**
+     * Create an EventBridge archive to send events to.
+     * When you create an archive, incoming events might not immediately start being sent to the archive.
+     * Allow a short period of time for changes to take effect.
+     *
+     * @param props Properties of the archive
+     */
+    archive(id: string, props: BaseArchiveProps): Archive;
+    /**
+     * Grants an IAM Principal to send custom events to the eventBus
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     * @param sid The Statement ID used if we need to add a trust policy on the event bus.
+     *
+     */
+    grantPutEventsTo(grantee: iam.IGrantable, sid?: string): iam.Grant;
+}
+/**
+ * Properties to define an event bus
+ */
+export interface EventBusProps {
+    /**
+     * The name of the event bus you are creating
+     * Note: If 'eventSourceName' is passed in, you cannot set this
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     * @default - automatically generated name
+     */
+    readonly eventBusName?: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     * Note: If 'eventBusName' is passed in, you cannot set this
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     * @default - no partner event source
+     */
+    readonly eventSourceName?: string;
+    /**
+     * Dead-letter queue for the event bus
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-rule-event-delivery.html#eb-rule-dlq
+     *
+     * @default - no dead-letter queue
+     */
+    readonly deadLetterQueue?: sqs.IQueue;
+    /**
+     * The event bus description.
+     *
+     * The description can be up to 512 characters long.
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-description
+     *
+     * @default - no description
+     */
+    readonly description?: string;
+    /**
+     * The customer managed key that encrypt events on this event bus.
+     *
+     * @default - Use an AWS managed key
+     */
+    readonly kmsKey?: kms.IKey;
+    /**
+     * The Logging Configuration of the Èvent Bus.
+     *  @default - no logging
+     */
+    readonly logConfig?: LogConfig;
+}
+/**
+ * Interface with properties necessary to import a reusable EventBus
+ */
+export interface EventBusAttributes {
+    /**
+     * The physical ID of this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name
+     */
+    readonly eventBusName: string;
+    /**
+     * The ARN of this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt
+     */
+    readonly eventBusArn: string;
+    /**
+     * The JSON policy of this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Policy-fn::getatt
+     */
+    readonly eventBusPolicy: string;
+    /**
+     * The partner event source to associate with this event bus resource
+     *
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename
+     * @default - no partner event source
+     */
+    readonly eventSourceName?: string;
+}
+declare abstract class EventBusBase extends Resource implements IEventBus, iam.IResourceWithPolicy {
+    /**
+     * The physical ID of this event bus resource
+     */
+    abstract readonly eventBusName: string;
+    /**
+     * The ARN of the event bus, such as:
+     * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.
+     */
+    abstract readonly eventBusArn: string;
+    /**
+     * The policy for the event bus in JSON form.
+     */
+    abstract readonly eventBusPolicy: string;
+    /**
+     * The name of the partner event source
+     */
+    abstract readonly eventSourceName?: string;
+    /**
+     * Collection of grant methods for an EventBus
+     */
+    readonly grants: EventBusGrants;
+    get eventBusRef(): EventBusReference;
+    archive(id: string, props: BaseArchiveProps): Archive;
+    /**
+     * [disable-awslint:no-grants]
+     */
+    grantPutEventsTo(grantee: iam.IGrantable, sid?: string): iam.Grant;
+    /**
+     * Adds a statement to the resource policy associated with this event bus.
+     * A resource policy will be automatically created upon the first call to `addToResourcePolicy`.
+     *
+     * Note that this does not work with imported event buss.
+     *
+     * @param statement The policy statement to add
+     */
+    abstract addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+}
+/**
+ * Define an EventBridge EventBus
+ *
+ * @resource AWS::Events::EventBus
+ */
+export declare class EventBus extends EventBusBase {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusArn ARN of imported event bus
+     */
+    static fromEventBusArn(scope: Construct, id: string, eventBusArn: string): IEventBus;
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusName Name of imported event bus
+     */
+    static fromEventBusName(scope: Construct, id: string, eventBusName: string): IEventBus;
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param attrs Imported event bus properties
+     */
+    static fromEventBusAttributes(scope: Construct, id: string, attrs: EventBusAttributes): IEventBus;
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     */
+    static grantAllPutEvents(grantee: iam.IGrantable): iam.Grant;
+    private static eventBusProps;
+    /**
+     * The CfnEventBus resource
+     */
+    private readonly _resource;
+    /**
+     * The physical ID of this event bus resource
+     */
+    get eventBusName(): string;
+    /**
+     * The ARN of the event bus, such as:
+     * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.
+     */
+    get eventBusArn(): string;
+    /**
+     * The policy for the event bus in JSON form.
+     */
+    get eventBusPolicy(): string;
+    /**
+     * The name of the partner event source
+     */
+    get eventSourceName(): string | undefined;
+    constructor(scope: Construct, id: string, props?: EventBusProps);
+    /**
+     * Adds a statement to the IAM resource policy associated with this event bus.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+}
+/**
+ * Properties to associate Event Buses with a policy
+ */
+export interface EventBusPolicyProps {
+    /**
+     * The event bus to which the policy applies
+     */
+    readonly eventBus: IEventBus;
+    /**
+     * An IAM Policy Statement to apply to the Event Bus
+     */
+    readonly statement: iam.PolicyStatement;
+    /**
+     * An identifier string for the external account that
+     * you are granting permissions to.
+     */
+    readonly statementId: string;
+}
+/**
+ * The policy for an Event Bus
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+export declare class EventBusPolicy extends Resource {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    constructor(scope: Construct, id: string, props: EventBusPolicyProps);
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-events/lib/event-pattern.d.ts

@@ -0,0 +1,239 @@
+import type { IResolvable, IResolveContext } from '../../core';
+/**
+ * An event pattern matcher
+ */
+export declare class Match implements IResolvable {
+    private readonly matchers;
+    private readonly options;
+    /**
+     * Matches a null value in the JSON of the event
+     */
+    static nullValue(): string[];
+    /**
+     * Matches when the field is present in the JSON of the event
+     */
+    static exists(): string[];
+    /**
+     * Matches when the field is absent from the JSON of the event
+     */
+    static doesNotExist(): string[];
+    /**
+     * Matches a string, exactly, in the JSON of the event
+     */
+    static exactString(value: string): string[];
+    /**
+     * Matches a string, regardless of case, in the JSON of the event
+     */
+    static equalsIgnoreCase(value: string): string[];
+    /**
+     * Matches strings with the given prefix in the JSON of the event
+     */
+    static prefix(value: string): string[];
+    /**
+     * Matches strings with the given suffix in the JSON of the event
+     */
+    static suffix(value: string): string[];
+    /**
+     * Matches strings with the given prefix in the JSON of the event regardless of the casing
+     */
+    static prefixEqualsIgnoreCase(value: string): string[];
+    /**
+     * Matches strings with the given suffix in the JSON of the event regardless of the casing
+     */
+    static suffixEqualsIgnoreCase(value: string): string[];
+    /**
+     * Matches strings with the given wildcard pattern in the JSON of the event
+     */
+    static wildcard(value: string): string[];
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format
+     */
+    static cidr(range: string): string[];
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format.
+     * Alias of `cidr()`.
+     */
+    static ipAddressRange(range: string): string[];
+    /**
+     * Matches anything except what's provided in the rule. The list of provided values must contain
+     * only strings or only numbers.
+     */
+    static anythingBut(...values: any[]): string[];
+    /**
+     * Matches any string that doesn't start with the given prefix.
+     */
+    static anythingButPrefix(...values: string[]): string[];
+    /**
+     * Matches any string that doesn't end with the given suffix.
+     */
+    static anythingButSuffix(...values: string[]): string[];
+    /**
+     * Matches any string that doesn't match with the given wildcard pattern.
+     */
+    static anythingButWildcard(...values: string[]): string[];
+    /**
+     * Matches any string that doesn't match with the given value regardless of character casing.
+     */
+    static anythingButEqualsIgnoreCase(...values: string[]): string[];
+    /**
+     * Matches numbers greater than the provided value
+     */
+    static greaterThan(value: number): string[];
+    /**
+     * Matches numbers greater than, or equal to, the provided value
+     */
+    static greaterThanOrEqual(value: number): string[];
+    /**
+     * Matches numbers less than the provided value
+     */
+    static lessThan(value: number): string[];
+    /**
+     * Matches numbers less than, or equal to, the provided value
+     */
+    static lessThanOrEqual(value: number): string[];
+    /**
+     * Matches numbers equal to the provided value
+     */
+    static equal(value: number): string[];
+    /**
+     * Matches numbers inside a closed numeric interval. Equivalent to:
+     *
+     *    Match.allOf(Match.greaterThanOrEqual(lower), Match.lessThanOrEqual(upper))
+     *
+     * @param lower Lower bound (inclusive)
+     * @param upper Upper bound (inclusive)
+     */
+    static interval(lower: number, upper: number): string[];
+    /**
+     * Matches an event if any of the provided matchers do. Only numeric matchers are accepted.
+     */
+    static allOf(...matchers: any[]): string[];
+    /**
+     * Matches an event if any of the provided matchers does.
+     */
+    static anyOf(...matchers: any[]): string[];
+    private static anythingButConjunction;
+    private static numeric;
+    private static fromMergedObjects;
+    readonly creationStack: string[];
+    private constructor();
+    resolve(context: IResolveContext): any;
+    private merge;
+    toString(): string;
+    /**
+     * A representation of this matcher as a list of strings
+     */
+    asList(): string[];
+}
+/**
+ * Events in Amazon CloudWatch Events are represented as JSON objects. For more
+ * information about JSON objects, see RFC 7159.
+ *
+ * Rules use event patterns to select events and route them to targets. A
+ * pattern either matches an event or it doesn't. Event patterns are represented
+ * as JSON objects with a structure that is similar to that of events.
+ *
+ * It is important to remember the following about event pattern matching:
+ *
+ * - For a pattern to match an event, the event must contain all the field names
+ *   listed in the pattern. The field names must appear in the event with the
+ *   same nesting structure.
+ *
+ * - Other fields of the event not mentioned in the pattern are ignored;
+ *   effectively, there is a ``"*": "*"`` wildcard for fields not mentioned.
+ *
+ * - The matching is exact (character-by-character), without case-folding or any
+ *   other string normalization.
+ *
+ * - The values being matched follow JSON rules: Strings enclosed in quotes,
+ *   numbers, and the unquoted keywords true, false, and null.
+ *
+ * - Number matching is at the string representation level. For example, 300,
+ *   300.0, and 3.0e2 are not considered equal.
+ *
+ * For custom events, some optional properties are required. For more information, see
+ * [Minimum information needed for a valid custom event](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html#eb-custom-event).
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html
+ */
+export interface EventPattern {
+    /**
+     * By default, this is set to 0 (zero) in all events.
+     *
+     * @default - No filtering on version
+     */
+    readonly version?: string[];
+    /**
+     * A unique value is generated for every event. This can be helpful in
+     * tracing events as they move through rules to targets, and are processed.
+     *
+     * @default - No filtering on id
+     */
+    readonly id?: string[];
+    /**
+     * Identifies, in combination with the source field, the fields and values
+     * that appear in the detail field.
+     *
+     * Represents the "detail-type" event field.
+     *
+     * @default - No filtering on detail type
+     */
+    readonly detailType?: string[];
+    /**
+     * Identifies the service that sourced the event. All events sourced from
+     * within AWS begin with "aws." Customer-generated events can have any value
+     * here, as long as it doesn't begin with "aws." We recommend the use of
+     * Java package-name style reverse domain-name strings.
+     *
+     * To find the correct value for source for an AWS service, see the table in
+     * AWS Service Namespaces. For example, the source value for Amazon
+     * CloudFront is aws.cloudfront.
+     *
+     * @see https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces
+     * @default - No filtering on source
+     */
+    readonly source?: string[];
+    /**
+     * The 12-digit number identifying an AWS account.
+     *
+     * @default - No filtering on account
+     */
+    readonly account?: string[];
+    /**
+     * The event timestamp, which can be specified by the service originating
+     * the event. If the event spans a time interval, the service might choose
+     * to report the start time, so this value can be noticeably before the time
+     * the event is actually received.
+     *
+     * @default - No filtering on time
+     */
+    readonly time?: string[];
+    /**
+     * Identifies the AWS region where the event originated.
+     *
+     * @default - No filtering on region
+     */
+    readonly region?: string[];
+    /**
+     * This JSON array contains ARNs that identify resources that are involved
+     * in the event. Inclusion of these ARNs is at the discretion of the
+     * service.
+     *
+     * For example, Amazon EC2 instance state-changes include Amazon EC2
+     * instance ARNs, Auto Scaling events include ARNs for both instances and
+     * Auto Scaling groups, but API calls with AWS CloudTrail do not include
+     * resource ARNs.
+     *
+     * @default - No filtering on resource
+     */
+    readonly resources?: string[];
+    /**
+     * A JSON object, whose content is at the discretion of the service
+     * originating the event.
+     *
+     * @default - No filtering on detail
+     */
+    readonly detail?: {
+        [key: string]: any;
+    };
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/events-canned-metrics.generated.d.ts

@@ -0,0 +1,43 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class EventsMetrics {
+    static invocationsSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static failedInvocationsSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static deadLetterInvocationsSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static triggeredRulesSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static throttledRulesSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static invocationsFailedToBeSentToDlqSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+    static invocationsSentToDlqSum(this: void, dimensions: {
+        RuleName: string;
+    }): MetricWithDims<{
+        RuleName: string;
+    }>;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/events-canned-metrics.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.EventsMetrics=void 0;class EventsMetrics{static invocationsSum(dimensions){return{namespace:"AWS/Events",metricName:"Invocations",dimensionsMap:dimensions,statistic:"Sum"}}static failedInvocationsSum(dimensions){return{namespace:"AWS/Events",metricName:"FailedInvocations",dimensionsMap:dimensions,statistic:"Sum"}}static deadLetterInvocationsSum(dimensions){return{namespace:"AWS/Events",metricName:"DeadLetterInvocations",dimensionsMap:dimensions,statistic:"Sum"}}static triggeredRulesSum(dimensions){return{namespace:"AWS/Events",metricName:"TriggeredRules",dimensionsMap:dimensions,statistic:"Sum"}}static throttledRulesSum(dimensions){return{namespace:"AWS/Events",metricName:"ThrottledRules",dimensionsMap:dimensions,statistic:"Sum"}}static invocationsFailedToBeSentToDlqSum(dimensions){return{namespace:"AWS/Events",metricName:"InvocationsFailedToBeSentToDlq",dimensionsMap:dimensions,statistic:"Sum"}}static invocationsSentToDlqSum(dimensions){return{namespace:"AWS/Events",metricName:"InvocationsSentToDlq",dimensionsMap:dimensions,statistic:"Sum"}}}exports.EventsMetrics=EventsMetrics;

cdk/node_modules/aws-cdk-lib/aws-events/lib/events-grants.generated.d.ts

@@ -0,0 +1,23 @@
+import * as events from "./events.generated";
+import * as iam from "../../aws-iam";
+import * as cdk from "../../core/lib";
+/**
+ * Collection of grant methods for a IEventBusRef
+ */
+export declare class EventBusGrants {
+    /**
+     * Creates grants for EventBusGrants
+     */
+    static fromEventBus(resource: events.IEventBusRef): EventBusGrants;
+    protected readonly resource: events.IEventBusRef;
+    private constructor();
+    /**
+     * Grant the given identity custom permissions
+     */
+    actions(grantee: iam.IGrantable, actions: Array<string>, options?: cdk.PermissionsOptions): iam.Grant;
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     */
+    allPutEvents(grantee: iam.IGrantable): iam.Grant;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/events-grants.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.EventBusGrants=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var events=()=>{var tmp=require("./events.generated");return events=()=>tmp,tmp},iam=()=>{var tmp=require("../../aws-iam");return iam=()=>tmp,tmp};class EventBusGrants{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_events.EventBusGrants",version:"2.252.0"};static fromEventBus(resource){try{jsiiDeprecationWarnings().aws_cdk_lib_interfaces_aws_events_IEventBusRef(resource)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.fromEventBus),error}return new EventBusGrants({resource})}resource;constructor(props){this.resource=props.resource}actions(grantee,actions,options={}){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_iam_IGrantable(grantee),jsiiDeprecationWarnings().aws_cdk_lib_PermissionsOptions(options)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.actions),error}return iam().Grant.addToPrincipal({actions,grantee,resourceArns:options.resourceArns??[events().CfnEventBus.arnForEventBus(this.resource)]})}allPutEvents(grantee){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_iam_IGrantable(grantee)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.allPutEvents),error}const actions=["events:PutEvents"];return this.actions(grantee,actions,{resourceArns:["*"]})}}exports.EventBusGrants=EventBusGrants;

cdk/node_modules/aws-cdk-lib/aws-events/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './input';
+export * from './rule';
+export * from './rule-ref';
+export * from './target';
+export * from './event-bus';
+export * from './event-pattern';
+export * from './schedule';
+export * from './on-event-options';
+export * from './archive';
+export * from './connection';
+export * from './api-destination';
+export * from './events.generated';
+export * from './events-grants.generated';

cdk/node_modules/aws-cdk-lib/aws-events/lib/input.d.ts

@@ -0,0 +1,181 @@
+import type { IResolvable, IResolveContext } from '../../core';
+import type { IRuleRef } from '../../interfaces/generated/aws-events-interfaces.generated';
+/**
+ * The input to send to the event target
+ */
+export declare abstract class RuleTargetInput {
+    /**
+     * Pass text to the event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     *
+     * The Rule Target input value will be a single string: the string you pass
+     * here.  Do not use this method to pass a complex value like a JSON object to
+     * a Rule Target.  Use `RuleTargetInput.fromObject()` instead.
+     */
+    static fromText(text: string): RuleTargetInput;
+    /**
+     * Pass text to the event target, splitting on newlines.
+     *
+     * This is only useful when passing to a target that does not
+     * take a single argument.
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts
+     * of the matched event.
+     */
+    static fromMultilineText(text: string): RuleTargetInput;
+    /**
+     * Pass a JSON object to the event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     *
+     * @returns RuleTargetInput
+     */
+    static fromObject(obj: any): RuleTargetInput;
+    /**
+     * Take the event target input from a path in the event JSON
+     */
+    static fromEventPath(path: string): RuleTargetInput;
+    protected constructor();
+    /**
+     * Return the input properties for this input object
+     */
+    abstract bind(rule: IRuleRef): RuleTargetInputProperties;
+}
+/**
+ * The input properties for an event target
+ */
+export interface RuleTargetInputProperties {
+    /**
+     * Literal input to the target service (must be valid JSON)
+     *
+     * @default - input for the event target. If the input contains a paths map
+     *   values wil be extracted from event and inserted into the `inputTemplate`.
+     */
+    readonly input?: string;
+    /**
+     * JsonPath to take input from the input event
+     *
+     * @default - None. The entire matched event is passed as input
+     */
+    readonly inputPath?: string;
+    /**
+     * Input template to insert paths map into
+     *
+     * @default - None.
+     */
+    readonly inputTemplate?: string;
+    /**
+     * Paths map to extract values from event and insert into `inputTemplate`
+     *
+     * @default - No values extracted from event.
+     */
+    readonly inputPathsMap?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Input object that can contain field replacements
+ *
+ * Evaluation is done in the bind() method because token resolution
+ * requires access to the construct tree.
+ *
+ * Multiple tokens that use the same path will use the same substitution
+ * key.
+ *
+ * One weird exception: if we're in object context, we MUST skip the quotes
+ * around the placeholder. I assume this is so once a trivial string replace is
+ * done later on by EventBridge, numbers are still numbers.
+ *
+ * So in string context:
+ *
+ *    "this is a string with a <field>"
+ *
+ * But in object context:
+ *
+ *    "{ \"this is the\": <field> }"
+ *
+ * To achieve the latter, we postprocess the JSON string to remove the surrounding
+ * quotes by using a string replace.
+ *
+ * @internal
+ */
+export declare class FieldAwareEventInput extends RuleTargetInput {
+    private readonly input;
+    private readonly inputType;
+    constructor(input: any, inputType: InputType);
+    bind(rule: IRuleRef): RuleTargetInputProperties;
+    /**
+     * Removing surrounding quotes from any object placeholders
+     * when key is the lone value.
+     *
+     * Those have been put there by JSON.stringify(), but we need to
+     * remove them.
+     *
+     * Do not remove quotes when the key is part of a larger string.
+     *
+     * Valid: { "data": "Some string with \"quotes\"<key>" } // key will be string
+     * Valid: { "data": <key> } // Key could be number, bool, obj, or string
+     */
+    private unquoteKeyPlaceholders;
+}
+/**
+ * Represents a field in the event pattern
+ */
+export declare class EventField implements IResolvable {
+    readonly path: string;
+    /**
+     * Extract the event ID from the event
+     */
+    static get eventId(): string;
+    /**
+     * Extract the detail type from the event
+     */
+    static get detailType(): string;
+    /**
+     * Extract the source from the event
+     */
+    static get source(): string;
+    /**
+     * Extract the account from the event
+     */
+    static get account(): string;
+    /**
+     * Extract the time from the event
+     */
+    static get time(): string;
+    /**
+     * Extract the region from the event
+     */
+    static get region(): string;
+    /**
+     * Extract a custom JSON path from the event
+     */
+    static fromPath(path: string): string;
+    /**
+     * Human readable display hint about the event pattern
+     */
+    readonly displayHint: string;
+    readonly creationStack: string[];
+    /**
+     *
+     * @param path the path to a field in the event pattern
+     */
+    private constructor();
+    resolve(_ctx: IResolveContext): any;
+    toString(): string;
+    /**
+     * Convert the path to the field in the event pattern to JSON
+     */
+    toJSON(): string;
+}
+/**
+ * @internal
+ */
+export declare enum InputType {
+    Object = 0,
+    Text = 1,
+    Multiline = 2
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/input.js

@@ -0,0 +1,3 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.InputType=exports.EventField=exports.FieldAwareEventInput=exports.RuleTargetInput=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class RuleTargetInput{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_events.RuleTargetInput",version:"2.252.0"};static fromText(text){return new FieldAwareEventInput(text,InputType.Text)}static fromMultilineText(text){return new FieldAwareEventInput(text,InputType.Multiline)}static fromObject(obj){return new FieldAwareEventInput(obj,InputType.Object)}static fromEventPath(path){return new LiteralEventInput({inputPath:path})}constructor(){}}exports.RuleTargetInput=RuleTargetInput;class LiteralEventInput extends RuleTargetInput{props;constructor(props){super(),this.props=props}bind(_rule){return this.props}}class FieldAwareEventInput extends RuleTargetInput{input;inputType;constructor(input,inputType){super(),this.input=input,this.inputType=inputType}bind(rule){let fieldCounter=0;const pathToKey=new Map,inputPathsMap={};function keyForField(f){const existing=pathToKey.get(f.path);if(existing!==void 0)return existing;fieldCounter+=1;const key=f.displayHint||`f${fieldCounter}`;return pathToKey.set(f.path,key),key}class EventFieldReplacer extends core_1().DefaultTokenResolver{constructor(){super(new(core_1()).StringConcat)}resolveToken(t,_context){if(!isEventField(t))return core_1().Token.asString(t);const key=keyForField(t);if(inputPathsMap[key]&&inputPathsMap[key]!==t.path)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`DuplicateInputPathKey`,`Single key '${key}' is used for two different JSON paths: '${t.path}' and '${inputPathsMap[key]}'`);return inputPathsMap[key]=t.path,`<${key}>`}}const stack=core_1().Stack.of(rule);let resolved;this.inputType===InputType.Multiline?(resolved=core_1().Tokenization.resolve(this.input,{scope:rule,resolver:new EventFieldReplacer}),resolved=resolved.split(`
+`).map(stack.toJsonString).join(`
+`)):resolved=stack.toJsonString(core_1().Tokenization.resolve(this.input,{scope:rule,resolver:new EventFieldReplacer}));const keys=Object.keys(inputPathsMap);return keys.length===0?{input:resolved}:{inputTemplate:this.unquoteKeyPlaceholders(resolved,keys),inputPathsMap}}unquoteKeyPlaceholders(sub,keys){if(this.inputType!==InputType.Object)return sub;return core_1().Lazy.uncachedString({produce:ctx=>core_1().Token.asString(deepUnquote(ctx.resolve(sub)))});function deepUnquote(resolved){if(Array.isArray(resolved))return resolved.map(deepUnquote);if(typeof resolved=="object"&&resolved!==null){for(const[key,value]of Object.entries(resolved))resolved[key]=deepUnquote(value);return resolved}else if(typeof resolved=="string")return keys.reduce((r,key)=>r.replace(new RegExp(`(?<!\\\\)"<${key}>"`,"g"),`<${key}>`),resolved);return resolved}}}exports.FieldAwareEventInput=FieldAwareEventInput;class EventField{path;static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_events.EventField",version:"2.252.0"};static get eventId(){return this.fromPath("$.id")}static get detailType(){return this.fromPath("$.detail-type")}static get source(){return this.fromPath("$.source")}static get account(){return this.fromPath("$.account")}static get time(){return this.fromPath("$.time")}static get region(){return this.fromPath("$.region")}static fromPath(path){return new EventField(path).toString()}displayHint;creationStack=["Token stack traces are no longer captured"];constructor(path){this.path=path,this.displayHint=this.path.replace(/^[^a-zA-Z0-9_-]+/,"").replace(/[^a-zA-Z0-9_-]/g,"-"),Object.defineProperty(this,EVENT_FIELD_SYMBOL,{value:!0})}resolve(_ctx){try{jsiiDeprecationWarnings().aws_cdk_lib_IResolveContext(_ctx)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.resolve),error}return this.path}toString(){return core_1().Token.asString(this,{displayHint:this.displayHint})}toJSON(){return`<path:${this.path}>`}}exports.EventField=EventField;var InputType;(function(InputType2){InputType2[InputType2.Object=0]="Object",InputType2[InputType2.Text=1]="Text",InputType2[InputType2.Multiline=2]="Multiline"})(InputType||(exports.InputType=InputType={}));function isEventField(x){return EVENT_FIELD_SYMBOL in x}const EVENT_FIELD_SYMBOL=Symbol.for("@aws-cdk/aws-events.EventField");

cdk/node_modules/aws-cdk-lib/aws-events/lib/on-event-options.d.ts

@@ -0,0 +1,52 @@
+import type { Construct } from 'constructs';
+import type { EventPattern } from './event-pattern';
+import type { IRuleTarget } from './target';
+/**
+ * Common options for Events.
+ */
+export interface EventCommonOptions {
+    /**
+     * A description of the rule's purpose.
+     *
+     * @default - No description
+     */
+    readonly description?: string;
+    /**
+     * A name for the rule.
+     *
+     * @default AWS CloudFormation generates a unique physical ID.
+     */
+    readonly ruleName?: string;
+    /**
+     * Additional restrictions for the event to route to the specified target
+     *
+     * The method that generates the rule probably imposes some type of event
+     * filtering. The filtering implied by what you pass here is added
+     * on top of that filtering.
+     *
+     * @default - No additional filtering based on an event pattern.
+     *
+     * @see
+     * https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html
+     */
+    readonly eventPattern?: EventPattern;
+    /**
+     * The scope to use if the source of the rule and its target are in different Stacks
+     * (but in the same account & region).
+     * This helps dealing with cycles that often arise in these situations.
+     *
+     * @default - none (the main scope will be used, even for cross-stack Events)
+     */
+    readonly crossStackScope?: Construct;
+}
+/**
+ * Standard set of options for `onXxx` event handlers on construct
+ */
+export interface OnEventOptions extends EventCommonOptions {
+    /**
+     * The target to register for the event
+     *
+     * @default - No target is added to the rule. Use `addTarget()` to add a target.
+     */
+    readonly target?: IRuleTarget;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/on-event-options.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

cdk/node_modules/aws-cdk-lib/aws-events/lib/private/ref-utils.d.ts

@@ -0,0 +1,7 @@
+import type { IConnection } from '../connection';
+import type { IConnectionRef } from '../events.generated';
+/**
+ * Convert an IConnectionRef to IConnection, validating that it implements the full interface
+ * @internal
+ */
+export declare function toIConnection(connection: IConnectionRef): IConnection;

cdk/node_modules/aws-cdk-lib/aws-events/lib/private/ref-utils.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.toIConnection=toIConnection;var core_1=()=>{var tmp=require("../../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};function toIConnection(connection){if(!("connectionArn"in connection)||!("connectionName"in connection))throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`ConnectionInstanceMustImplementIConnection`,`'connection' instance should implement IConnection, but doesn't: ${connection.constructor.name}`);return connection}

cdk/node_modules/aws-cdk-lib/aws-events/lib/rule-ref.d.ts

@@ -0,0 +1,20 @@
+import type { IResource } from '../../core';
+import type { IRuleRef } from '../../interfaces/generated/aws-events-interfaces.generated';
+/**
+ * Represents an EventBridge Rule
+ */
+export interface IRule extends IResource, IRuleRef {
+    /**
+     * The value of the event rule Amazon Resource Name (ARN), such as
+     * arn:aws:events:us-east-2:123456789012:rule/example.
+     *
+     * @attribute
+     */
+    readonly ruleArn: string;
+    /**
+     * The name event rule
+     *
+     * @attribute
+     */
+    readonly ruleName: string;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/rule-ref.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

cdk/node_modules/aws-cdk-lib/aws-events/lib/rule.d.ts

@@ -0,0 +1,167 @@
+import type { Construct } from 'constructs';
+import type { EventPattern } from './event-pattern';
+import type { IEventBusRef, RuleReference } from './events.generated';
+import type { EventCommonOptions } from './on-event-options';
+import type { IRule } from './rule-ref';
+import { Schedule } from './schedule';
+import type { IRuleTarget } from './target';
+import type { IRoleRef } from '../../aws-iam';
+import { Resource } from '../../core';
+/**
+ * Properties for defining an EventBridge Rule
+ */
+export interface RuleProps extends EventCommonOptions {
+    /**
+     * Indicates whether the rule is enabled.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The schedule or rate (frequency) that determines when EventBridge
+     * runs the rule.
+     *
+     * You must specify this property, the `eventPattern` property, or both.
+     *
+     * For more information, see Schedule Expression Syntax for
+     * Rules in the Amazon EventBridge User Guide.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+     *
+     * @default - None.
+     */
+    readonly schedule?: Schedule;
+    /**
+     * Targets to invoke when this rule matches an event.
+     *
+     * Input will be the full matched event. If you wish to specify custom
+     * target input, use `addTarget(target[, inputOptions])`.
+     *
+     * @default - No targets.
+     */
+    readonly targets?: IRuleTarget[];
+    /**
+     * The event bus to associate with this rule.
+     *
+     * @default - The default event bus.
+     */
+    readonly eventBus?: IEventBusRef;
+    /**
+     * The role that is used for target invocation.
+     * Must be assumable by principal `events.amazonaws.com`.
+     *
+     * @default - No role associated
+     */
+    readonly role?: IRoleRef;
+}
+/**
+ * Defines an EventBridge Rule in this stack.
+ *
+ * @resource AWS::Events::Rule
+ */
+export declare class Rule extends Resource implements IRule {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing EventBridge Rule provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).
+     */
+    static fromEventRuleArn(scope: Construct, id: string, eventRuleArn: string): IRule;
+    /**
+     * The CfnRule resource
+     */
+    private readonly _resource;
+    get ruleArn(): string;
+    get ruleName(): string;
+    get ruleRef(): RuleReference;
+    private readonly targets;
+    private readonly eventPattern;
+    private readonly scheduleExpression?;
+    private readonly description?;
+    /** Set to keep track of what target accounts and regions we've already created event buses for */
+    private readonly _xEnvTargetsAdded;
+    constructor(scope: Construct, id: string, props?: RuleProps);
+    /**
+     * Adds a target to the rule. The abstract class RuleTarget can be extended to define new
+     * targets.
+     *
+     * No-op if target is undefined.
+     */
+    addTarget(target?: IRuleTarget): void;
+    /**
+     * Adds an event pattern filter to this rule. If a pattern was already specified,
+     * these values are merged into the existing pattern.
+     *
+     * For example, if the rule already contains the pattern:
+     *
+     *    {
+     *      "resources": [ "r1" ],
+     *      "detail": {
+     *        "hello": [ 1 ]
+     *      }
+     *    }
+     *
+     * And `addEventPattern` is called with the pattern:
+     *
+     *    {
+     *      "resources": [ "r2" ],
+     *      "detail": {
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     * The resulting event pattern will be:
+     *
+     *    {
+     *      "resources": [ "r1", "r2" ],
+     *      "detail": {
+     *        "hello": [ 1 ],
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     */
+    addEventPattern(eventPattern?: EventPattern): void;
+    /**
+     * Not private only to be overrideen in CopyRule.
+     *
+     * @internal
+     */
+    _renderEventPattern(): any;
+    protected validateRule(): string[];
+    private renderTargets;
+    /**
+     * Make sure we add the target environments event bus as a target, and the target has permissions set up to receive our events
+     *
+     * For cross-account rules, uses a support stack to set up a policy on the target event bus.
+     */
+    private ensureXEnvTargetEventBus;
+    /**
+     * Return the scope where the mirror rule should be created for x-env event targets
+     *
+     * This is the target resource's containing stack if it shares the same region (owned
+     * resources), or should be a fresh support stack for imported resources.
+     *
+     * We don't implement the second yet, as I have to think long and hard on whether we
+     * can reuse the existing support stack or not, and I don't have time for that right now.
+     */
+    private obtainMirrorRuleScope;
+    /**
+     * 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
+     */
+    private crossRegionPutEventsRole;
+    /**
+     * Whether two string probably contain the same environment dimension (region or account)
+     *
+     * Used to compare either accounts or regions, and also returns true if one or both
+     * are unresolved (in which case both are expected to be "current region" or "current account").
+     */
+    private sameEnvDimension;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/schedule.d.ts

@@ -0,0 +1,83 @@
+import type { Construct } from 'constructs';
+import type { Duration } from '../../core';
+/**
+ * Schedule for scheduled event rules
+ *
+ * Note that rates cannot be defined in fractions of minutes.
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+ */
+export declare abstract class Schedule {
+    /**
+     * Construct a schedule from a literal schedule expression
+     *
+     * @param expression The expression to use. Must be in a format that EventBridge will recognize
+     */
+    static expression(expression: string): Schedule;
+    /**
+     * Construct a schedule from an interval and a time unit
+     *
+     * Rates may be defined with any unit of time, but when converted into minutes, the duration must be a positive whole number of minutes.
+     */
+    static rate(duration: Duration): Schedule;
+    /**
+     * Create a schedule from a set of cron fields
+     */
+    static cron(options: CronOptions): Schedule;
+    /**
+     * Retrieve the expression for this schedule
+     */
+    abstract readonly expressionString: string;
+    protected constructor();
+    /**
+     *
+     * @internal
+     */
+    abstract _bind(scope: Construct): void;
+}
+/**
+ * Options to configure a cron expression
+ *
+ * All fields are strings so you can use complex expressions. Absence of
+ * a field implies '*' or '?', whichever one is appropriate.
+ *
+ * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html#cron-expressions
+ */
+export interface CronOptions {
+    /**
+     * The minute to run this rule at
+     *
+     * @default - Every minute
+     */
+    readonly minute?: string;
+    /**
+     * The hour to run this rule at
+     *
+     * @default - Every hour
+     */
+    readonly hour?: string;
+    /**
+     * The day of the month to run this rule at
+     *
+     * @default - Every day of the month
+     */
+    readonly day?: string;
+    /**
+     * The month to run this rule at
+     *
+     * @default - Every month
+     */
+    readonly month?: string;
+    /**
+     * The year to run this rule at
+     *
+     * @default - Every year
+     */
+    readonly year?: string;
+    /**
+     * The day of the week to run this rule at
+     *
+     * @default - Any day of the week
+     */
+    readonly weekDay?: string;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/schedule.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Schedule=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class Schedule{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_events.Schedule",version:"2.252.0"};static expression(expression){return new LiteralSchedule(expression)}static rate(duration){try{jsiiDeprecationWarnings().aws_cdk_lib_Duration(duration)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.rate),error}if(duration.isUnresolved()){if(["minute","minutes","hour","hours","day","days"].indexOf(duration.unitLabel())===-1)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`InvalidScheduleUnit`,"Allowed units for scheduling are: 'minute', 'minutes', 'hour', 'hours', 'day', 'days'");return new LiteralSchedule(`rate(${duration.formatTokenToNumber()})`)}if(duration.toMinutes()===0)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`DurationCannotBeZero`,"Duration cannot be 0");let rate=maybeRate(duration.toDays({integral:!1}),"day");return rate===void 0&&(rate=maybeRate(duration.toHours({integral:!1}),"hour")),rate===void 0&&(rate=makeRate(duration.toMinutes({integral:!0}),"minute")),new LiteralSchedule(rate)}static cron(options){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_events_CronOptions(options)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,this.cron),error}if(options.weekDay!==void 0&&options.day!==void 0)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`CannotSupplyBothDayAndWeekDay`,"Cannot supply both 'day' and 'weekDay', use at most one");const minute=fallback(options.minute,"*"),hour=fallback(options.hour,"*"),month=fallback(options.month,"*"),year=fallback(options.year,"*"),day=fallback(options.day,options.weekDay!==void 0?"?":"*"),weekDay=fallback(options.weekDay,"?");return new class extends Schedule{expressionString=`cron(${minute} ${hour} ${day} ${month} ${weekDay} ${year})`;_bind(scope){return options.minute||core_1().Annotations.of(scope).addWarningV2("@aws-cdk/aws-events:scheduleWillRunEveryMinute","cron: If you don't pass 'minute', by default the event runs every minute. Pass 'minute: '*'' if that's what you intend, or 'minute: 0' to run once per hour instead."),new LiteralSchedule(this.expressionString)}}}constructor(){}}exports.Schedule=Schedule;class LiteralSchedule extends Schedule{expressionString;constructor(expressionString){super(),this.expressionString=expressionString}_bind(){}}function fallback(x,def){return x??def}function maybeRate(interval,singular){if(!(interval===0||!Number.isInteger(interval)))return makeRate(interval,singular)}function makeRate(interval,singular){return interval===1?`rate(1 ${singular})`:`rate(${interval} ${singular}s)`}

cdk/node_modules/aws-cdk-lib/aws-events/lib/target.d.ts

@@ -0,0 +1,102 @@
+import type { IConstruct } from 'constructs';
+import type { CfnRule } from './events.generated';
+import type { RuleTargetInput } from './input';
+import type * as iam from '../../aws-iam';
+import type { IRuleRef } from '../../interfaces/generated/aws-events-interfaces.generated';
+/**
+ * An abstract target for EventRules.
+ */
+export interface IRuleTarget {
+    /**
+     * Returns the rule target specification.
+     * NOTE: Do not use the various `inputXxx` options. They can be set in a call to `addTarget`.
+     *
+     * @param rule The EventBridge Rule that would trigger this target.
+     * @param id The id of the target that will be attached to the rule.
+     */
+    bind(rule: IRuleRef, id?: string): RuleTargetConfig;
+}
+/**
+ * Properties for an event rule target
+ */
+export interface RuleTargetConfig {
+    /**
+     * The Amazon Resource Name (ARN) of the target.
+     */
+    readonly arn: string;
+    /**
+     * Role to use to invoke this event target
+     */
+    readonly role?: iam.IRole;
+    /**
+     * Parameters used when the rule invokes Amazon AWS Batch Job/Queue
+     * @default no parameters set
+     */
+    readonly batchParameters?: CfnRule.BatchParametersProperty;
+    /**
+     * Contains information about a dead-letter queue configuration.
+     * @default no dead-letter queue set
+     */
+    readonly deadLetterConfig?: CfnRule.DeadLetterConfigProperty;
+    /**
+     * A RetryPolicy object that includes information about the retry policy settings.
+     * @default EventBridge default retry policy
+     */
+    readonly retryPolicy?: CfnRule.RetryPolicyProperty;
+    /**
+     * Contains the GraphQL operation to be parsed and executed, if the event target is an AWS AppSync API.
+     * @default - None
+     */
+    readonly appSyncParameters?: CfnRule.AppSyncParametersProperty;
+    /**
+     * The Amazon ECS task definition and task count to use, if the event target
+     * is an Amazon ECS task.
+     */
+    readonly ecsParameters?: CfnRule.EcsParametersProperty;
+    /**
+     * Contains the HTTP parameters to use when the target is a API Gateway REST endpoint
+     * or EventBridge API destination.
+     * @default - None
+     */
+    readonly httpParameters?: CfnRule.HttpParametersProperty;
+    /**
+     * Settings that control shard assignment, when the target is a Kinesis
+     * stream. If you don't include this parameter, eventId is used as the
+     * partition key.
+     */
+    readonly kinesisParameters?: CfnRule.KinesisParametersProperty;
+    /**
+     * Parameters used when the rule invokes Amazon EC2 Systems Manager Run
+     * Command.
+     */
+    readonly runCommandParameters?: CfnRule.RunCommandParametersProperty;
+    /**
+     * Parameters used when the FIFO sqs queue is used an event target by the
+     * rule.
+     */
+    readonly sqsParameters?: CfnRule.SqsParametersProperty;
+    /**
+     * Parameters used when the rule invokes Amazon Redshift Queries
+     *
+     * @default - no parameters set
+     */
+    readonly redshiftDataParameters?: CfnRule.RedshiftDataParametersProperty;
+    /**
+     * What input to send to the event target
+     *
+     * @default the entire event
+     */
+    readonly input?: RuleTargetInput;
+    /**
+     * The resource that is backing this target.
+     * This is the resource that will actually have some action performed on it when used as a target
+     * (for example, start a build for a CodeBuild project).
+     * We need it to determine whether the rule belongs to a different account than the target -
+     * if so, we generate a more complex setup,
+     * including an additional stack containing the EventBusPolicy.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-cross-account-event-delivery.html
+     * @default the target is not backed by any resource
+     */
+    readonly targetResource?: IConstruct;
+}

cdk/node_modules/aws-cdk-lib/aws-events/lib/target.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

cdk/node_modules/aws-cdk-lib/aws-events/lib/util.d.ts

@@ -0,0 +1,13 @@
+import type { 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;

cdk/node_modules/aws-cdk-lib/aws-events/lib/util.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.mergeEventPattern=mergeEventPattern,exports.renderEventPattern=renderEventPattern;var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};function mergeEventPattern(dest,src){return dest=dest||{},mergeObject(dest,src),dest;function mergeObject(destObj,srcObj){if(typeof srcObj!="object")throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`InvalidEventPattern`,`Invalid event pattern '${JSON.stringify(srcObj)}', expecting an object or an array`);for(const field of Object.keys(srcObj)){const srcValue=srcObj[field],destValue=destObj[field];if(srcValue!==void 0){if(typeof srcValue!="object")throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`EventPatternFieldsMustBeArrays`,`Invalid event pattern field { ${field}: ${JSON.stringify(srcValue)} }. All fields must be arrays`);if(destObj[field]===void 0){destObj[field]=srcValue;continue}if(Array.isArray(srcValue)!==Array.isArray(destValue))throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`EventPatternTypeMismatch`,`Invalid event pattern field ${field}. Type mismatch between existing pattern ${JSON.stringify(destValue)} and added pattern ${JSON.stringify(srcValue)}`);if(Array.isArray(srcValue)){const result=[...destValue,...srcValue],resultJson=result.map(i=>JSON.stringify(i));destObj[field]=result.filter((value,index)=>resultJson.indexOf(JSON.stringify(value))===index);continue}mergeObject(destObj[field],srcValue)}}}}function renderEventPattern(eventPattern){if(Object.keys(eventPattern).length===0)return;const out={};for(let key of Object.keys(eventPattern)){const value=eventPattern[key];key==="detailType"&&(key="detail-type"),out[key]=value}return out}