@epilot360/icons 0.0.1 → 0.0.2

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

@@ -0,0 +1,249 @@
+# 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),
+  branches: ['master']
+});
+```
+
+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')}`
+    }
+  )
+}));
+```
+
+To define a pattern, use the matcher API, 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'),
+  },
+});
+```
+
+## 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/aws-events-targets` module includes classes that implement the `IRuleTarget`
+interface for various AWS services.
+
+The following targets are supported:
+
+* `targets.CodeBuildProject`: Start an AWS CodeBuild build
+* `targets.CodePipeline`: Start an AWS CodePipeline pipeline execution
+* `targets.EcsTask`: Start a task on an Amazon ECS cluster
+* `targets.LambdaFunction`: Invoke an AWS Lambda function
+* `targets.SnsTopic`: Publish into an SNS topic
+* `targets.SqsQueue`: Send a message to an Amazon SQS Queue
+* `targets.SfnStateMachine`: Trigger an AWS Step Functions state machine
+* `targets.BatchJob`: Queue an AWS Batch Job
+* `targets.AwsApi`: Make an AWS API call
+* `targets.ApiGateway`: Invoke an AWS API Gateway
+* `targets.ApiDestination`: Make an call to an external destination
+
+### 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'
+});
+
+bus.archive('MyArchive', {
+  archiveName: 'MyCustomEventBusArchive',
+  description: 'MyCustomerEventBus Archive',
+  eventPattern: {
+    account: [Stack.of(this).account],
+  },
+  retention: Duration.days(365),
+});
+```
+
+## 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);
+```

package/iac/node_modules/aws-cdk-lib/aws-events-targets/README.md

@@ -0,0 +1,339 @@
+# Event Targets for Amazon EventBridge
+
+
+This library contains integration classes to send Amazon EventBridge to any
+number of supported AWS Services. Instances of these classes should be passed
+to the `rule.addTarget()` method.
+
+Currently supported are:
+
+* [Start a CodeBuild build](#start-a-codebuild-build)
+* [Start a CodePipeline pipeline](#start-a-codepipeline-pipeline)
+* Run an ECS task
+* [Invoke a Lambda function](#invoke-a-lambda-function)
+* [Invoke a API Gateway REST API](#invoke-an-api-gateway-rest-api)
+* Publish a message to an SNS topic
+* Send a message to an SQS queue
+* [Start a StepFunctions state machine](#start-a-stepfunctions-state-machine)
+* [Queue a Batch job](#queue-a-batch-job)
+* Make an AWS API call
+* Put a record to a Kinesis stream
+* [Log an event into a LogGroup](#log-an-event-into-a-loggroup)
+* Put a record to a Kinesis Data Firehose stream
+* [Put an event on an EventBridge bus](#put-an-event-on-an-eventbridge-bus)
+* [Send an event to EventBridge API Destination](#invoke-an-api-destination)
+
+See the README of the `@aws-cdk/aws-events` library for more information on
+EventBridge.
+
+## Event retry policy and using dead-letter queues
+
+The Codebuild, CodePipeline, Lambda, StepFunctions, LogGroup, SQSQueue, SNSTopic and ECSTask targets support attaching a [dead letter queue and setting retry policies](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html). See the [lambda example](#invoke-a-lambda-function).
+Use [escape hatches](https://docs.aws.amazon.com/cdk/latest/guide/cfn_layer.html) for the other target types.
+
+## Invoke a Lambda function
+
+Use the `LambdaFunction` target to invoke a lambda function.
+
+The code snippet below creates an event rule with a Lambda function as a target
+triggered for every events from `aws.ec2` source. You can optionally attach a
+[dead letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html).
+
+```ts
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+
+const fn = new lambda.Function(this, 'MyFunc', {
+  runtime: lambda.Runtime.NODEJS_14_X,
+  handler: 'index.handler',
+  code: lambda.Code.fromInline(`exports.handler = handler.toString()`),
+});
+
+const rule = new events.Rule(this, 'rule', {
+  eventPattern: {
+    source: ["aws.ec2"],
+  },
+});
+
+const queue = new sqs.Queue(this, 'Queue');
+
+rule.addTarget(new targets.LambdaFunction(fn, {
+  deadLetterQueue: queue, // Optional: add a dead letter queue
+  maxEventAge: cdk.Duration.hours(2), // Optional: set the maxEventAge retry policy
+  retryAttempts: 2, // Optional: set the max number of retry attempts
+}));
+```
+
+## Log an event into a LogGroup
+
+Use the `LogGroup` target to log your events in a CloudWatch LogGroup.
+
+For example, the following code snippet creates an event rule with a CloudWatch LogGroup as a target.
+Every events sent from the `aws.ec2` source will be sent to the CloudWatch LogGroup.
+
+```ts
+import * as logs from 'aws-cdk-lib/aws-logs';
+
+const logGroup = new logs.LogGroup(this, 'MyLogGroup', {
+  logGroupName: 'MyLogGroup',
+});
+
+const rule = new events.Rule(this, 'rule', {
+  eventPattern: {
+    source: ["aws.ec2"],
+  },
+});
+
+rule.addTarget(new targets.CloudWatchLogGroup(logGroup));
+```
+
+A rule target input can also be specified to modify the event that is sent to the log group.
+Unlike other event targets, CloudWatchLogs requires a specific input template format.
+
+```ts
+import * as logs from 'aws-cdk-lib/aws-logs';
+declare const logGroup: logs.LogGroup;
+declare const rule: events.Rule;
+
+rule.addTarget(new targets.CloudWatchLogGroup(logGroup, {
+  logEvent: targets.LogGroupTargetInput({
+    timestamp: events.EventField.from('$.time'),
+    message: events.EventField.from('$.detail-type'),
+  }),
+}));
+```
+
+If you want to use static values to overwrite the `message` make sure that you provide a `string`
+value.
+
+```ts
+import * as logs from 'aws-cdk-lib/aws-logs';
+declare const logGroup: logs.LogGroup;
+declare const rule: events.Rule;
+
+rule.addTarget(new targets.CloudWatchLogGroup(logGroup, {
+  logEvent: targets.LogGroupTargetInput({
+    message: JSON.stringify({
+	  CustomField: 'CustomValue',
+	}),
+  }),
+}));
+```
+
+## Start a CodeBuild build
+
+Use the `CodeBuildProject` target to trigger a CodeBuild project.
+
+The code snippet below creates a CodeCommit repository that triggers a CodeBuild project
+on commit to the master branch. You can optionally attach a
+[dead letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html).
+
+```ts
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import * as codecommit from 'aws-cdk-lib/aws-codecommit';
+
+const repo = new codecommit.Repository(this, 'MyRepo', {
+  repositoryName: 'aws-cdk-codebuild-events',
+});
+
+const project = new codebuild.Project(this, 'MyProject', {
+  source: codebuild.Source.codeCommit({ repository: repo }),
+});
+
+const deadLetterQueue = new sqs.Queue(this, 'DeadLetterQueue');
+
+// trigger a build when a commit is pushed to the repo
+const onCommitRule = repo.onCommit('OnCommit', {
+  target: new targets.CodeBuildProject(project, {
+    deadLetterQueue: deadLetterQueue,
+  }),
+  branches: ['master'],
+});
+```
+
+## Start a CodePipeline pipeline
+
+Use the `CodePipeline` target to trigger a CodePipeline pipeline.
+
+The code snippet below creates a CodePipeline pipeline that is triggered every hour
+
+```ts
+import * as codepipeline from 'aws-cdk-lib/aws-codepipeline';
+
+const pipeline = new codepipeline.Pipeline(this, 'Pipeline');
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.expression('rate(1 hour)'),
+});
+
+rule.addTarget(new targets.CodePipeline(pipeline));
+```
+
+## Start a StepFunctions state machine
+
+Use the `SfnStateMachine` target to trigger a State Machine.
+
+The code snippet below creates a Simple StateMachine that is triggered every minute with a
+dummy object as input.
+You can optionally attach a
+[dead letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html)
+to the target.
+
+```ts
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.rate(cdk.Duration.minutes(1)),
+});
+
+const dlq = new sqs.Queue(this, 'DeadLetterQueue');
+
+const role = new iam.Role(this, 'Role', {
+  assumedBy: new iam.ServicePrincipal('events.amazonaws.com'),
+});
+const stateMachine = new sfn.StateMachine(this, 'SM', {
+  definition: new sfn.Wait(this, 'Hello', { time: sfn.WaitTime.duration(cdk.Duration.seconds(10)) })
+});
+
+rule.addTarget(new targets.SfnStateMachine(stateMachine, {
+  input: events.RuleTargetInput.fromObject({ SomeParam: 'SomeValue' }),
+  deadLetterQueue: dlq,
+  role: role
+}));
+```
+
+## Queue a Batch job
+
+Use the `BatchJob` target to queue a Batch job.
+
+The code snippet below creates a Simple JobQueue that is triggered every hour with a
+dummy object as input.
+You can optionally attach a
+[dead letter queue](https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html)
+to the target.
+
+```ts
+import * as batch from 'aws-cdk-lib/aws-batch';
+import { ContainerImage } from 'aws-cdk-lib/aws-ecs';
+
+const jobQueue = new batch.JobQueue(this, 'MyQueue', {
+  computeEnvironments: [
+    {
+      computeEnvironment: new batch.ComputeEnvironment(this, 'ComputeEnvironment', {
+        managed: false,
+      }),
+      order: 1,
+    },
+  ],
+});
+
+const jobDefinition = new batch.JobDefinition(this, 'MyJob', {
+  container: {
+    image: ContainerImage.fromRegistry('test-repo'),
+  },
+});
+
+const queue = new sqs.Queue(this, 'Queue');
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.rate(cdk.Duration.hours(1)),
+});
+
+rule.addTarget(new targets.BatchJob(
+  jobQueue.jobQueueArn,
+  jobQueue,
+  jobDefinition.jobDefinitionArn,
+  jobDefinition, {
+    deadLetterQueue: queue,
+    event: events.RuleTargetInput.fromObject({ SomeParam: 'SomeValue' }),
+    retryAttempts: 2,
+    maxEventAge: cdk.Duration.hours(2),
+  },
+));
+```
+
+## Invoke an API Gateway REST API
+
+Use the `ApiGateway` target to trigger a REST API.
+
+The code snippet below creates a Api Gateway REST API that is invoked every hour.
+
+```ts
+import * as api from 'aws-cdk-lib/aws-apigateway';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.rate(cdk.Duration.minutes(1)),
+});
+
+const fn = new lambda.Function( this, 'MyFunc', {
+  handler: 'index.handler',
+  runtime: lambda.Runtime.NODEJS_14_X,
+  code: lambda.Code.fromInline( 'exports.handler = e => {}' ),
+} );
+
+const restApi = new api.LambdaRestApi( this, 'MyRestAPI', { handler: fn } );
+
+const dlq = new sqs.Queue(this, 'DeadLetterQueue');
+
+rule.addTarget(
+  new targets.ApiGateway( restApi, {
+    path: '/*/test',
+    method: 'GET',
+    stage:  'prod',
+    pathParameterValues: ['path-value'],
+    headerParameters: {
+      Header1: 'header1',
+    },
+    queryStringParameters: {
+      QueryParam1: 'query-param-1',
+    },
+    deadLetterQueue: dlq
+  } ),
+)
+```
+
+## Invoke an API Destination
+
+Use the `targets.ApiDestination` target to trigger an external API. You need to
+create an `events.Connection` and `events.ApiDestination` as well.
+
+The code snippet below creates an external destination that is invoked every hour.
+
+```ts
+const connection = new events.Connection(this, 'Connection', {
+  authorization: events.Authorization.apiKey('x-api-key', SecretValue.secretsManager('ApiSecretName')),
+  description: 'Connection with API Key x-api-key',
+});
+
+const destination = new events.ApiDestination(this, 'Destination', {
+  connection,
+  endpoint: 'https://example.com',
+  description: 'Calling example.com with API key x-api-key',
+});
+
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.rate(cdk.Duration.minutes(1)),
+  targets: [new targets.ApiDestination(destination)],
+});
+```
+
+## Put an event on an EventBridge bus
+
+Use the `EventBus` target to route event to a different EventBus.
+
+The code snippet below creates the scheduled event rule that route events to an imported event bus.
+
+```ts
+const rule = new events.Rule(this, 'Rule', {
+  schedule: events.Schedule.expression('rate(1 minute)'),
+});
+
+rule.addTarget(new targets.EventBus(
+  events.EventBus.fromEventBusArn(
+    this,
+    'External',
+    `arn:aws:events:eu-west-1:999999999999:event-bus/test-bus`,
+  ),
+));
+```

package/iac/node_modules/aws-cdk-lib/aws-eventschemas/README.md

@@ -0,0 +1,27 @@
+# AWS::EventSchemas Construct Library
+
+
+This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
+
+```ts nofixture
+import * as eventschemas from 'aws-cdk-lib/aws-eventschemas';
+```
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no official hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. Here are some suggestions on how to proceed:
+
+- Search [Construct Hub for EventSchemas construct libraries](https://constructs.dev/search?q=eventschemas)
+- Use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, in the same way you would use [the CloudFormation AWS::EventSchemas resources](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_EventSchemas.html) directly.
+
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. 
+However, you can still use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, and use this service exactly as you would using CloudFormation directly.
+
+For more information on the resources and properties available for this service, see the [CloudFormation documentation for AWS::EventSchemas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_EventSchemas.html).
+
+(Read the [CDK Contributing Guide](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and submit an RFC if you are interested in contributing to this construct library.)
+
+<!--END CFNONLY DISCLAIMER-->

package/iac/node_modules/aws-cdk-lib/aws-evidently/README.md

@@ -0,0 +1,27 @@
+# AWS::Evidently Construct Library
+
+
+This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
+
+```ts nofixture
+import * as evidently from 'aws-cdk-lib/aws-evidently';
+```
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no official hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. Here are some suggestions on how to proceed:
+
+- Search [Construct Hub for Evidently construct libraries](https://constructs.dev/search?q=evidently)
+- Use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, in the same way you would use [the CloudFormation AWS::Evidently resources](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Evidently.html) directly.
+
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. 
+However, you can still use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, and use this service exactly as you would using CloudFormation directly.
+
+For more information on the resources and properties available for this service, see the [CloudFormation documentation for AWS::Evidently](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_Evidently.html).
+
+(Read the [CDK Contributing Guide](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and submit an RFC if you are interested in contributing to this construct library.)
+
+<!--END CFNONLY DISCLAIMER-->

package/iac/node_modules/aws-cdk-lib/aws-finspace/README.md

@@ -0,0 +1,27 @@
+# AWS::FinSpace Construct Library
+
+
+This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
+
+```ts nofixture
+import * as finspace from 'aws-cdk-lib/aws-finspace';
+```
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no official hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. Here are some suggestions on how to proceed:
+
+- Search [Construct Hub for FinSpace construct libraries](https://constructs.dev/search?q=finspace)
+- Use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, in the same way you would use [the CloudFormation AWS::FinSpace resources](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_FinSpace.html) directly.
+
+
+<!--BEGIN CFNONLY DISCLAIMER-->
+
+There are no hand-written ([L2](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_lib)) constructs for this service yet. 
+However, you can still use the automatically generated [L1](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html#constructs_l1_using) constructs, and use this service exactly as you would using CloudFormation directly.
+
+For more information on the resources and properties available for this service, see the [CloudFormation documentation for AWS::FinSpace](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_FinSpace.html).
+
+(Read the [CDK Contributing Guide](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md) and submit an RFC if you are interested in contributing to this construct library.)
+
+<!--END CFNONLY DISCLAIMER-->