agent-claw: automated task changes

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}