konokenj.cdk-api-mcp-server 0.46.0__py3-none-any.whl → 0.48.0__py3-none-any.whl

cdk_api_mcp_server/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Kenji Kono <konoken@amazon.co.jp>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.46.0"
+__version__ = "0.48.0"

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-elasticache-alpha/README.md

@@ -0,0 +1,421 @@
+# ElastiCache CDK Construct Library
+<!--BEGIN STABILITY BANNER-->
+
+---
+
+![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)
+
+> The APIs of higher level constructs in this module are experimental and under active development.
+> They are subject to non-backward compatible changes or removal in any future version. These are
+> not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be
+> announced in the release notes. This means that while you may use them, you may need to update
+> your source code when upgrading to a newer version of this package.
+
+---
+
+<!--END STABILITY BANNER-->
+
+This module has constructs for [Amazon ElastiCache](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/WhatIs.html).
+
+* The `ServerlessCache` construct facilitates the creation and management of serverless cache.
+* The `User` and `UserGroup` constructs facilitate the creation and management of users for the cache.
+
+## Serverless Cache
+
+Amazon ElastiCache Serverless is a serverless option that automatically scales cache capacity based on application traffic patterns. You can create a serverless cache using the `ServerlessCache` construct:
+
+```ts
+const vpc = new ec2.Vpc(this, 'VPC');
+ 
+const cache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  vpc,
+});
+```
+
+### Connecting to serverless cache
+
+To control who can access the serverless cache by the security groups, use the `.connections` attribute.
+
+The serverless cache has a default port `6379`.
+
+This example allows an EC2 instance to connect to the serverless cache:
+
+```ts
+declare const serverlessCache: elasticache.ServerlessCache;
+declare const instance: ec2.Instance;
+ 
+// allow the EC2 instance to connect to serverless cache on default port 6379
+serverlessCache.connections.allowDefaultPortFrom(instance);
+```
+
+### Cache usage limits
+
+You can configure usage limits on both cache data storage and ECPU/second for your cache to control costs and ensure predictable performance.
+
+**Configuration options:**
+
+* **Maximum limits**: Ensure your cache usage never exceeds the configured maximum
+* **Minimum limits**: Reserve a baseline level of resources for consistent performance
+* **Both**: Define a range where your cache usage will operate
+
+For more infomation, see [Setting scaling limits to manage costs](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Scaling.html#Pre-Scaling).
+
+```ts
+declare const vpc: ec2.Vpc;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  engine: elasticache.CacheEngine.VALKEY_LATEST,
+  vpc,
+  cacheUsageLimits: {
+    // cache data storage limits (GB)
+    dataStorageMinimumSize: Size.gibibytes(2), // minimum: 1GB
+    dataStorageMaximumSize: Size.gibibytes(3), // maximum: 5000GB
+    // rate limits (ECPU/second)
+    requestRateLimitMinimum: 1000, // minimum: 1000
+    requestRateLimitMaximum: 10000, // maximum: 15000000
+  },
+});
+```
+
+### Backups and restore
+
+You can enable automatic backups for serverless cache.
+When automatic backups are enabled, ElastiCache creates a backup of the cache on a daily basis.
+
+Also you can set the backup window for any time when it's most convenient.
+If you don't specify a backup window, ElastiCache assigns one automatically.
+
+For more information, see [Scheduling automatic backups](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/backups-automatic.html).
+
+To enable automatic backups, set the `backupRetentionLimit` property. You can also specify the snapshot creation time by setting `backupTime` property:
+
+```ts
+declare const vpc: ec2.Vpc;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  backup: {
+    // enable automatic backups and set the retention period to 6 days
+    backupRetentionLimit: 6,
+    // set the backup window to 9:00 AM UTC
+    backupTime: events.Schedule.cron({
+      hour: '9',
+      minute: '0',
+    }),
+  },
+  vpc,
+});
+```
+
+You can create a final backup by setting `backupNameBeforeDeletion` property.
+
+```ts 
+declare const vpc: ec2.Vpc;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  engine: elasticache.CacheEngine.VALKEY_LATEST,
+  backup: {
+    // set a backup name before deleting a cache
+    backupNameBeforeDeletion: "my-final-backup-name",
+  },
+  vpc,
+});
+```
+
+You can restore from backups by setting snapshot ARNs to `backupArnsToRestore` property:
+
+```ts
+declare const vpc: ec2.Vpc;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  engine: elasticache.CacheEngine.VALKEY_LATEST,
+  backup: {
+    // set the backup(s) to restore
+    backupArnsToRestore: ['arn:aws:elasticache:us-east-1:123456789012:serverlesscachesnapshot:my-final-backup-name'],
+  },
+  vpc,
+});
+```
+
+### Encryption at rest
+
+At-rest encryption is always enabled for Serverless Cache. There are two encryption options:
+
+* **Default**: When no `kmsKey` is specified (left as `undefined`), AWS owned KMS keys are used automatically
+* **Customer Managed Key**: Create a KMS key first, then pass it to the cache via the `kmsKey` property
+
+### Customer Managed Key for encryption at rest
+
+ElastiCache supports symmetric Customer Managed key (CMK) for encryption at rest.
+
+For more information, see [Using customer managed keys from AWS KMS](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/at-rest-encryption.html#using-customer-managed-keys-for-elasticache-security).
+
+To use CMK, set your CMK to the `kmsKey` property:
+
+```ts
+import { Key } from 'aws-cdk-lib/aws-kms';
+ 
+declare const kmsKey: Key;
+declare const vpc: ec2.Vpc;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  engine: elasticache.CacheEngine.VALKEY_LATEST,
+  serverlessCacheName: 'my-serverless-cache',
+  vpc,
+  // set Customer Managed Key
+  kmsKey,
+});
+```
+
+### Metrics and monitoring
+
+You can monitor your serverless cache using CloudWatch Metrics via the `metric` method.
+
+For more information about serverless cache metrics, see [Serverless metrics and events for Valkey and Redis OSS](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/serverless-metrics-events-redis.html) and [Serverless metrics and events for Memcached](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/serverless-metrics-events.memcached.html).
+
+```ts
+declare const serverlessCache: elasticache.ServerlessCache;
+ 
+// The 5 minutes average of the total number of successful read-only key lookups in the cache.
+const cacheHits = serverlessCache.metricCacheHitCount();
+ 
+// The 5 minutes average of the total number of bytes used by the data stored in the cache.
+const bytesUsedForCache = serverlessCache.metricDataStored();
+ 
+// The 5 minutes average of the total number of ElastiCacheProcessingUnits (ECPUs) consumed by the requests executed on the cache.
+const elastiCacheProcessingUnits = serverlessCache.metricProcessingUnitsConsumed();
+ 
+// Create an alarm for ECPUs.
+elastiCacheProcessingUnits.createAlarm(this, 'ElastiCacheProcessingUnitsAlarm', {
+  threshold: 50,
+  evaluationPeriods: 1,
+});
+```
+
+### Import an existing serverless cache
+
+To import an existing ServerlessCache, use the `ServerlessCache.fromServerlessCacheAttributes` method:
+
+```ts
+declare const securityGroup: ec2.SecurityGroup;
+ 
+const importedServerlessCache = elasticache.ServerlessCache.fromServerlessCacheAttributes(this, 'ImportedServerlessCache', {
+  serverlessCacheName: 'my-serverless-cache',
+  securityGroups: [securityGroup],
+});
+```
+
+## User and User Group
+
+Setup required properties and create:
+
+```ts
+const newDefaultUser = new elasticache.NoPasswordUser(this, 'NoPasswordUser', {
+  userId: 'default',
+  accessControl: elasticache.AccessControl.fromAccessString("on ~* +@all"),
+})
+ 
+const userGroup = new elasticache.UserGroup(this, 'UserGroup', {
+  users: [newDefaultUser],
+});
+```
+
+### RBAC
+
+In Valkey 7.2 and onward and Redis OSS 6.0 onward you can use a feature called Role-Based Access Control (RBAC). RBAC is also the only way to control access to serverless caches.
+
+RBAC enables you to control cache access through user groups. These user groups are designed as a way to organize access to caches.
+
+For more information, see [Role-Based Access Control (RBAC)](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Clusters.RBAC.html).
+
+To enable RBAC for ElastiCache with Valkey or Redis OSS, you take the following steps:
+
+* Create users.
+* Create a user group and add users to the user group.
+* Assign the user group to a cache.
+
+### Create users
+
+First, you need to create users by using `IamUser`, `PasswordUser` or `NoPasswordUser` construct.
+
+With RBAC, you create users and assign them specific permissions by using `accessString` property.
+
+For more information, see [Specifying Permissions Using an Access String](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Clusters.RBAC.html#Access-string).
+
+You can create an IAM-enabled user by using `IamUser` construct:
+
+```ts
+const user = new elasticache.IamUser(this, 'User', {
+  // set user engine
+  engine: elasticache.UserEngine.REDIS,
+    
+  // set user id
+  userId: 'my-user',
+ 
+  // set username
+  userName: 'my-user',
+ 
+  // set access string
+  accessControl: elasticache.AccessControl.fromAccessString("on ~* +@all"),
+});
+```
+
+> NOTE: IAM-enabled users must have matching user id and username. For more information, see [Limitations](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/auth-iam.html). The construct can set automatically the username to be the same as the user id.
+
+If you want to create a password authenticated user, use `PasswordUser` construct:
+
+```ts
+const user = new elasticache.PasswordUser(this, 'User', {
+  // set user engine
+  engine: elasticache.UserEngine.VALKEY,
+  
+  // set user id
+  userId: 'my-user-id',  
+    
+  // set access string
+  accessControl: elasticache.AccessControl.fromAccessString("on ~* +@all"),
+ 
+  // set username
+  userName: 'my-user-name',
+ 
+  // set up to two passwords
+  passwords: [
+    // "SecretIdForPassword" is the secret id for the password
+    SecretValue.secretsManager('SecretIdForPassword'),
+    // "AnotherSecretIdForPassword" is the secret id for the password
+    SecretValue.secretsManager('AnotherSecretIdForPassword'),
+  ],
+});
+```
+
+You can also create a no password required user by using `NoPasswordUser` construct:
+
+```ts
+const user = new elasticache.NoPasswordUser(this, 'User', {
+  // set user engine  
+  engine: elasticache.UserEngine.REDIS, 
+    
+  // set user id
+  userId: 'my-user-id',
+ 
+  // set access string
+  accessControl: elasticache.AccessControl.fromAccessString("on ~* +@all"),
+ 
+  // set username
+  userName: 'my-user-name',
+});
+```
+
+### Default user
+
+ElastiCache automatically creates a default user with both a user ID and username set to `default`. This default user cannot be modified or deleted. The user is created as a no password authentication user.
+
+This user is intended for compatibility with the default behavior of previous Redis OSS versions and has an access string that permits it to call all commands and access all keys.
+
+To use this automatically created default user in CDK, you can import it using `NoPasswordUser.fromUserAttributes` method. For more information on import methods, see the [Import an existing user and user group](#import-an-existing-user-and-user-group) section.
+
+To add proper access control to a cache, replace the default user with a new one that is either disabled by setting the `accessString` to `off -@all` or secured with a strong password.
+
+To change the default user, create a new default user with the username set to `default`. You can then swap it with the original default user.
+
+For more information, see [Applying RBAC to a Cache for ElastiCache with Valkey or Redis OSS](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/Clusters.RBAC.html#rbac-using).
+
+If you want to create a new default user, `userName` must be `default` and `userId` must not be `default` by using `NoPasswordUser` or `PasswordUser`:
+
+```ts
+// use the original `default` user by using import method
+const defaultUser = elasticache.NoPasswordUser.fromUserAttributes(this, 'DefaultUser', {
+  // userId and userName must be 'default'
+  userId: 'default',
+});
+ 
+// create a new default user
+const newDefaultUser = new elasticache.NoPasswordUser(this, 'NewDefaultUser', {
+  // new default user id must not be 'default'
+  userId: 'new-default',
+  // new default username must be 'default'
+  userName: 'default',
+  // set access string
+  accessControl: elasticache.AccessControl.fromAccessString("on ~* +@all"),
+});
+```
+
+> NOTE: You can't create a new default user using `IamUser` because an IAM-enabled user's username and user ID cannot be different.
+
+### Add users to the user group
+
+Next, use the `UserGroup` construct to create a user group and add users to it.
+Ensure that you include either the original default user or a new default user:
+
+```ts
+declare const newDefaultUser: elasticache.IUser;
+declare const user: elasticache.IUser;
+declare const anotherUser: elasticache.IUser;
+ 
+const userGroup = new elasticache.UserGroup(this, 'UserGroup', {
+  // add users including default user
+  users: [newDefaultUser, user],
+});
+ 
+// you can also add a user by using addUser method
+userGroup.addUser(anotherUser);
+```
+
+### Assign user group
+
+Finally, assign a user group to cache:
+
+```ts
+declare const vpc: ec2.Vpc;
+declare const userGroup: elasticache.UserGroup;
+ 
+const serverlessCache = new elasticache.ServerlessCache(this, 'ServerlessCache', {
+  engine: elasticache.CacheEngine.VALKEY_LATEST,
+  serverlessCacheName: 'my-serverless-cache',
+  vpc,
+  // assign User Group
+  userGroup,
+});
+ 
+```
+
+### Grant permissions to IAM-enabled users
+
+If you create IAM-enabled users, `"elasticache:Connect"` action must be allowed for the users and cache.
+
+> NOTE: You don't need grant permissions to no password required users or password authentication users.
+
+For more information, see [Authenticating with IAM](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/auth-iam.html).
+
+To grant permissions, you can use the `grantConnect` method in `IamUser` and `ServerlessCache` constructs:
+
+```ts
+declare const user: elasticache.IamUser;
+declare const serverlessCache: elasticache.ServerlessCache;
+declare const role: iam.Role;
+ 
+// grant "elasticache:Connect" action permissions to role
+user.grantConnect(role);
+serverlessCache.grantConnect(role);
+```
+
+### Import an existing user and user group
+
+You can import an existing user and user group by using import methods:
+
+```ts
+const stack = new Stack();
+ 
+const importedIamUser = elasticache.IamUser.fromUserId(this, 'ImportedIamUser', 'my-iam-user-id');
+ 
+const importedPasswordUser = elasticache.PasswordUser.fromUserAttributes(stack, 'ImportedPasswordUser', {
+  userId: 'my-password-user-id',
+});
+ 
+const importedNoPasswordUser = elasticache.NoPasswordUser.fromUserAttributes(stack, 'ImportedNoPasswordUser', {
+  userId: 'my-no-password-user-id',
+});
+ 
+const importedUserGroup = elasticache.UserGroup.fromUserGroupAttributes(this, 'ImportedUserGroup', {
+  userGroupName: 'my-user-group-name'
+});
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md

@@ -1059,7 +1059,7 @@ The properties passed to the level 2 constructs `AutoScalingGroup` and `Instance
 `aws-ec2` module abstract what is passed into the `CfnOption` properties `resourceSignal` and
 `autoScalingCreationPolicy`, but when using level 1 constructs you can specify these yourself.
 
-The CfnWaitCondition resource from the `aws-cloudformation` module suppports the `resourceSignal`.
+The CfnWaitCondition resource from the `aws-cloudformation` module supports the `resourceSignal`.
 The format of the timeout is `PT#H#M#S`. In the example below AWS Cloudformation will wait for
 3 success signals to occur within 15 minutes before the status of the resource will be set to
 `CREATE_COMPLETE`.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/README.md

@@ -597,6 +597,20 @@ new cloudfront.Distribution(this, 'myDist', {
 });
 ```
 
+You can specify the IP address type for connecting to the origin:
+
+```ts
+const origin = new origins.HttpOrigin('www.example.com', {
+  ipAddressType: cloudfront.OriginIpAddressType.IPV6, // IPv4, IPv6, or DUALSTACK
+});
+
+new cloudfront.Distribution(this, 'Distribution', {
+  defaultBehavior: { origin },
+});
+```
+
+The `ipAddressType` property allows you to specify whether CloudFront should use IPv4, IPv6, or both (dual-stack) when connecting to your origin.
+
 The origin can be customized with timeout settings to handle different response scenarios:
 
 ```ts

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.http-origin.ts

@@ -1,13 +1,16 @@
 import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
 import * as cdk from 'aws-cdk-lib';
 import * as origins from 'aws-cdk-lib/aws-cloudfront-origins';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
 
 const app = new cdk.App();
 
 const stack = new cdk.Stack(app, 'cloudfront-http-origin');
 
 new cloudfront.Distribution(stack, 'Distribution', {
-  defaultBehavior: { origin: new origins.HttpOrigin('www.example.com') },
+  defaultBehavior: { origin: new origins.HttpOrigin('www.example.com', { ipAddressType: cloudfront.OriginIpAddressType.DUALSTACK }) },
 });
 
-app.synth();
+new IntegTest(app, 'http-origin-test-integ', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/README.md

@@ -577,6 +577,82 @@ const fleet = new codebuild.Fleet(this, 'MyFleet', {
 });
 ```
 
+### Custom instance types
+You can use [specific EC2 instance
+types](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.instance-types)
+for your fleet by setting the `computeType` to `CUSTOM_INSTANCE_TYPE`.  This
+allows you to specify the `instanceType` in `computeConfiguration`. Only certain
+EC2 instance types are supported; see the linked documentation for details.
+
+```ts
+import { Size } from 'aws-cdk-lib';
+
+const fleet = new codebuild.Fleet(this, 'MyFleet', {
+  baseCapacity: 1,
+  computeType: codebuild.FleetComputeType.CUSTOM_INSTANCE_TYPE,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  computeConfiguration: {
+    instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    // By default, 64 GiB of disk space is included. Any value optionally
+    // specified here is _incremental_ on top of the included disk space.
+    disk: Size.gibibytes(10),
+  },
+});
+```
+
+### Fleet overflow behavior
+
+When your builds exceed the capacity of your fleet, you can specify how CodeBuild should handle the overflow builds by setting the `overflowBehavior` property:
+
+```ts
+const fleet = new codebuild.Fleet(this, 'Fleet', {
+  computeType: codebuild.FleetComputeType.MEDIUM,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  baseCapacity: 1,
+  overflowBehavior: codebuild.FleetOverflowBehavior.ON_DEMAND,
+});
+```
+
+The available overflow behaviors are:
+
+- `QUEUE` (default): Overflow builds wait for existing fleet instances to become available
+- `ON_DEMAND`: Overflow builds run on CodeBuild on-demand instances
+
+Note: If you set overflow behavior to `ON_DEMAND` for a VPC-connected fleet, ensure your VPC settings allow access to public AWS services.
+
+### VPCs
+The same considerations that apply to [Project
+VPCs](#definition-of-vpc-configuration-in-codebuild-project) also apply to Fleet
+VPCs.  When using a Fleet in a CodeBuild Project, it is an error to configure a
+VPC on the Project. Configure a VPC on the fleet instead.
+
+```ts
+declare const loadBalancer: elbv2.ApplicationLoadBalancer;
+
+const vpc = new ec2.Vpc(this, 'MyVPC');
+const fleet = new codebuild.Fleet(this, 'MyProject', {
+  computeType: codebuild.FleetComputeType.MEDIUM,
+  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+  baseCapacity: 1,
+  vpc,
+});
+
+fleet.connections.allowTo(loadBalancer, ec2.Port.tcp(443));
+
+const project = new codebuild.Project(this, 'MyProject', {
+  environment: {
+    fleet,
+  },
+  buildSpec: codebuild.BuildSpec.fromObject({
+    // ...
+  }),
+  // Trying to configure a project-level VPC is an error, because this project
+  // runs on the Fleet created above.
+  // vpc,
+});
+```
+>>>>>>> 39ec36ec6a (feat(codebuild): add custom instance type and VPC to Fleets)
+
 ## Logs
 
 CodeBuild lets you specify an S3 Bucket, CloudWatch Log Group or both to receive logs from your projects.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts

@@ -1,17 +1,55 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
 import * as cdk from 'aws-cdk-lib';
 import * as integ from '@aws-cdk/integ-tests-alpha';
 import * as codebuild from 'aws-cdk-lib/aws-codebuild';
 import { Construct } from 'constructs';
 
-const configurations: codebuild.ComputeConfiguration[] = [
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+  },
   {
-    machineType: codebuild.MachineType.GENERAL,
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+      vCpu: 2,
+      memory: cdk.Size.gibibytes(4),
+      disk: cdk.Size.gibibytes(10),
+    },
   },
   {
-    machineType: codebuild.MachineType.GENERAL,
-    vCpu: 2,
-    memory: cdk.Size.gibibytes(4),
-    disk: cdk.Size.gibibytes(10),
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      machineType: codebuild.MachineType.GENERAL,
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
   },
 ];
 
@@ -19,14 +57,27 @@ class FleetStack extends cdk.Stack {
   public readonly fleet: codebuild.Fleet;
   public readonly project: codebuild.Project;
 
-  constructor(scope: Construct, id: string, computeConfiguration: codebuild.ComputeConfiguration) {
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
     super(scope, id);
 
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
     this.fleet = new codebuild.Fleet(this, 'MyFleet', {
       baseCapacity: 1,
       computeType: codebuild.FleetComputeType.ATTRIBUTE_BASED,
       computeConfiguration,
       environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
     });
 
     this.project = new codebuild.Project(this, 'MyProject', {
@@ -38,6 +89,7 @@ class FleetStack extends cdk.Stack {
       }),
       environment: {
         buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
       },
     });
   }

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-custom-instance-type.ts

@@ -0,0 +1,130 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as cdk from 'aws-cdk-lib';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+type StackConfiguration = {
+  computeConfiguration: codebuild.ComputeConfiguration;
+  vpcProps?: ec2.VpcProps;
+  subnetSelection?: ec2.SubnetSelection;
+  securityGroupProps?: Array<Omit<ec2.SecurityGroupProps, 'vpc'>>;
+}
+const configurations: Array<StackConfiguration> = [
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+      disk: cdk.Size.gibibytes(10),
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      restrictDefaultSecurityGroup: false,
+    },
+  },
+  {
+    computeConfiguration: {
+      instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
+    },
+    vpcProps: {
+      maxAzs: 1,
+      // Incredibly, if you pass a SubnetSelection that produces more than 1
+      // subnet, you currently get this error:
+      // > Resource handler returned message: "Invalid vpc config: the maximum number of subnets is 1
+      // This seems like a terrible limitation from the CodeBuild team.
+      // maxAzs: 2,
+    },
+    subnetSelection: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+    securityGroupProps: [
+      { allowAllOutbound: true },
+      { allowAllIpv6Outbound: true },
+    ],
+  },
+];
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string, { computeConfiguration, vpcProps, subnetSelection, securityGroupProps }: StackConfiguration) {
+    super(scope, id);
+
+    let vpc: ec2.Vpc | undefined;
+    let securityGroups: Array<ec2.SecurityGroup> | undefined;
+    if (vpcProps) {
+      vpc = new ec2.Vpc(this, 'Vpc', vpcProps);
+      const refinedVpc = vpc;
+      securityGroups = securityGroupProps?.map((props, i) =>
+        new ec2.SecurityGroup(this, `SecurityGroup${i}`, { ...props, vpc: refinedVpc }),
+      );
+    }
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.CUSTOM_INSTANCE_TYPE,
+      computeConfiguration,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      vpc,
+      securityGroups,
+      subnetSelection,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+        fleet: this.fleet,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stacks = configurations.map(
+  (config, index) => new FleetStack(
+    app,
+    `CustomInstanceTypeComputeFleetIntegStack${index}`,
+    config,
+  ),
+);
+
+const test = new integ.IntegTest(app, 'CustomInstanceTypeComputeFleetIntegTest', {
+  testCases: stacks,
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+for (const { fleet, project } of stacks) {
+  listFleets.expect(integ.ExpectedResult.objectLike({
+    fleets: integ.Match.arrayWith([fleet.fleetArn]),
+  }));
+
+  const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: project.projectName });
+
+  // Describe the build and wait for the status to be successful
+  test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+    ids: [startBuild.getAttString('build.id')],
+  }).assertAtPath(
+    'builds.0.buildStatus',
+    integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+  ).waitForAssertions({
+    // After a custom instance type fleet is created, there can still be high
+    // latency on creating actual instances. Needs a long timeout, builds are
+    // pending until instances are initialized.
+    totalTimeout: cdk.Duration.minutes(10),
+    interval: cdk.Duration.seconds(30),
+  });
+}

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-overflow-behavior.ts

@@ -0,0 +1,61 @@
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as codebuild from 'aws-cdk-lib/aws-codebuild';
+import { Construct } from 'constructs';
+
+class FleetStack extends cdk.Stack {
+  public readonly fleet: codebuild.Fleet;
+  public readonly project: codebuild.Project;
+
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    this.fleet = new codebuild.Fleet(this, 'MyFleet', {
+      baseCapacity: 1,
+      computeType: codebuild.FleetComputeType.SMALL,
+      environmentType: codebuild.EnvironmentType.LINUX_CONTAINER,
+      overflowBehavior: codebuild.FleetOverflowBehavior.ON_DEMAND,
+    });
+
+    this.project = new codebuild.Project(this, 'MyProject', {
+      buildSpec: codebuild.BuildSpec.fromObject({
+        version: '0.2',
+        phases: {
+          build: { commands: ['echo "Nothing to do!"'] },
+        },
+      }),
+      environment: {
+        fleet: this.fleet,
+        buildImage: codebuild.LinuxBuildImage.STANDARD_7_0,
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+const stack= new FleetStack(
+  app,
+  'OverflowBehaviorFleetStack',
+);
+
+const test = new integ.IntegTest(app, 'OverflowBehaviorFleetInteg', {
+  testCases: [stack],
+});
+
+const listFleets = test.assertions.awsApiCall('Codebuild', 'listFleets');
+listFleets.expect(integ.ExpectedResult.objectLike({
+  fleets: integ.Match.arrayWith([stack.fleet.fleetArn]),
+}));
+
+const startBuild = test.assertions.awsApiCall('Codebuild', 'startBuild', { projectName: stack.project.projectName });
+
+// Describe the build and wait for the status to be successful
+test.assertions.awsApiCall('CodeBuild', 'batchGetBuilds', {
+  ids: [startBuild.getAttString('build.id')],
+}).assertAtPath(
+  'builds.0.buildStatus',
+  integ.ExpectedResult.stringLikeRegexp('SUCCEEDED'),
+).waitForAssertions({
+  totalTimeout: cdk.Duration.minutes(5),
+  interval: cdk.Duration.seconds(30),
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/README.md

@@ -28,6 +28,28 @@ By default, the master password will be generated and stored in AWS Secrets Mana
 
 Your cluster will be empty by default.
 
+## Serverless Clusters
+
+DocumentDB supports serverless clusters that automatically scale capacity based on your application's needs.
+To create a serverless cluster, specify the `serverlessV2ScalingConfiguration` instead of `instanceType`:
+
+```ts
+declare const vpc: ec2.Vpc;
+const cluster = new docdb.DatabaseCluster(this, 'Database', {
+  masterUser: {
+    username: 'myuser',
+  },
+  vpc,
+  serverlessV2ScalingConfiguration: {
+    minCapacity: 0.5,
+    maxCapacity: 2,
+  },
+  engineVersion: '5.0.0', // Serverless requires engine version 5.0.0 or higher
+});
+```
+
+**Note**: DocumentDB serverless requires engine version 5.0.0 or higher and is not compatible with all features. See the [AWS documentation](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-serverless-limitations.html) for limitations.
+
 ## Connecting
 
 To control who can access the cluster, use the `.connections` attribute. DocumentDB databases have a default port, so
@@ -278,3 +300,5 @@ const cluster = new docdb.DatabaseCluster(this, 'Database', {
 ```
 
 **Note**: `StorageType.IOPT1` is supported starting with engine version 5.0.0.
+
+**Note**: For serverless clusters, storage type is managed automatically and cannot be specified.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-serverless.ts

@@ -0,0 +1,34 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as cdk from 'aws-cdk-lib';
+import * as constructs from 'constructs';
+import { DatabaseCluster } from 'aws-cdk-lib/aws-docdb';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: constructs.Construct, id: string, props?: cdk.StackProps) {
+    super(scope, id, props);
+
+    const vpc = new ec2.Vpc(this, 'VPC', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+
+    new DatabaseCluster(this, 'Database', {
+      masterUser: {
+        username: 'docdb',
+      },
+      vpc,
+      serverlessV2ScalingConfiguration: {
+        minCapacity: 0.5,
+        maxCapacity: 2,
+      },
+      engineVersion: '5.0.0',
+      removalPolicy: cdk.RemovalPolicy.DESTROY,
+    });
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new TestStack(app, 'aws-cdk-docdb-cluster-serverless');
+
+new IntegTest(app, 'aws-cdk-docdb-cluster-serverless-integ', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/README.md

@@ -1659,6 +1659,107 @@ new ecs.Ec2Service(this, 'EC2Service', {
 });
 ```
 
+### Managed Instances Capacity Providers
+
+Managed Instances Capacity Providers allow you to use AWS-managed EC2 instances for your ECS tasks while providing more control over instance selection than standard Fargate. AWS handles the instance lifecycle, patching, and maintenance while you can specify detailed instance requirements.
+
+To create a Managed Instances Capacity Provider, you need to specify the required EC2 instance profile, and networking configuration. You can also define detailed instance requirements to control which types of instances are used for your workloads.
+
+```ts
+declare const vpc: ec2.Vpc;
+declare const infrastructureRole: iam.Role;
+declare const instanceProfile: iam.InstanceProfile;
+
+const cluster = new ecs.Cluster(this, 'Cluster', { vpc });
+
+// Create a Managed Instances Capacity Provider
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
+  infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  securityGroups: [new ec2.SecurityGroup(this, 'MISecurityGroup', { vpc })],
+  instanceRequirements: {
+    vCpuCountMin: 1,
+    memoryMin: Size.gibibytes(2),
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+  },
+  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
+});
+
+// Add the capacity provider to the cluster
+cluster.addManagedInstancesCapacityProvider(miCapacityProvider);
+
+const taskDefinition = new ecs.Ec2TaskDefinition(this, 'TaskDef');
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+  memoryReservationMiB: 256,
+});
+
+new ecs.Ec2Service(this, 'EC2Service', {
+  cluster,
+  taskDefinition,
+  minHealthyPercent: 100,
+  capacityProviderStrategies: [
+    {
+      capacityProvider: miCapacityProvider.capacityProviderName,
+      weight: 1,
+    },
+  ],
+});
+```
+
+You can specify detailed instance requirements to control which types of instances are used:
+
+```ts
+declare const infrastructureRole: iam.Role;
+declare const instanceProfile: iam.InstanceProfile;
+declare const vpc: ec2.Vpc;
+
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
+  infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  instanceRequirements: {
+    // Required: CPU and memory constraints
+    vCpuCountMin: 2,
+    vCpuCountMax: 8,
+    memoryMin: Size.gibibytes(4),
+    memoryMax: Size.gibibytes(32),
+    
+    // CPU preferences
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL, ec2.CpuManufacturer.AMD],
+    instanceGenerations: [ec2.InstanceGeneration.CURRENT],
+    
+    // Instance type filtering
+    allowedInstanceTypes: ['m5.*', 'c5.*'],
+    
+    // Performance characteristics
+    burstablePerformance: ec2.BurstablePerformance.EXCLUDED,
+    bareMetal: ec2.BareMetal.EXCLUDED,
+    
+    // Accelerator requirements (for ML/AI workloads)
+    acceleratorTypes: [ec2.AcceleratorType.GPU],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+    acceleratorNames: [ec2.AcceleratorName.T4, ec2.AcceleratorName.V100],
+    acceleratorCountMin: 1,
+    
+    // Storage requirements
+    localStorage: ec2.LocalStorage.REQUIRED,
+    localStorageTypes: [ec2.LocalStorageType.SSD],
+    totalLocalStorageGBMin: 100,
+    
+    // Network requirements
+    networkInterfaceCountMin: 2,
+    networkBandwidthGbpsMin: 10,
+    
+    // Cost optimization
+    onDemandMaxPricePercentageOverLowestPrice: 10,
+  },
+});
+```
+
 ### Cluster Default Provider Strategy
 
 A capacity provider strategy determines whether ECS tasks are launched on EC2 instances or Fargate/Fargate Spot. It can be specified at the cluster, service, or task level, and consists of one or more capacity providers. You can specify an optional base and weight value for finer control of how tasks are launched. The `base` specifies a minimum number of tasks on one capacity provider, and the `weight`s of each capacity provider determine how tasks are distributed after `base` is satisfied.

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.managedinstances-capacity-provider.ts

@@ -0,0 +1,112 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+const app = new cdk.App({
+  postCliContext: {
+    '@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm': true,
+    '@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature': false,
+    '@aws-cdk/aws-ecs:disableEcsImdsBlocking': false,
+  },
+});
+const stack = new cdk.Stack(app, 'integ-managedinstances-capacity-provider');
+
+const vpc = new ec2.Vpc(stack, 'Vpc', { maxAzs: 2, restrictDefaultSecurityGroup: false });
+const cluster = new ecs.Cluster(stack, 'ManagedInstancesCluster', {
+  vpc,
+  enableFargateCapacityProviders: true,
+});
+
+// Create IAM roles required for FMI following Omakase specifications
+const infrastructureRole = new iam.Role(stack, 'InfrastructureRole', {
+  roleName: 'AmazonECSInfrastructureRoleForOmakase',
+  assumedBy: new iam.ServicePrincipal('ecs.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AdministratorAccess'),
+  ],
+});
+
+const instanceRole = new iam.Role(stack, 'InstanceRole', {
+  roleName: 'AmazonECSInstanceRoleForOmakase',
+  assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+  managedPolicies: [
+    iam.ManagedPolicy.fromAwsManagedPolicyName('AdministratorAccess'),
+  ],
+});
+
+const instanceProfile = new iam.InstanceProfile(stack, 'InstanceProfile', {
+  instanceProfileName: 'AmazonECSInstanceRoleForOmakase',
+  role: instanceRole,
+});
+
+// Create a security group for FMI instances
+const fmiSecurityGroup = new ec2.SecurityGroup(stack, 'ManagedInstancesSecurityGroup', {
+  vpc,
+  description: 'Security group for ManagedInstances capacity provider instances',
+  allowAllOutbound: true,
+});
+
+// Create MI Capacity Provider
+const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(stack, 'ManagedInstancesCapacityProvider', {
+  infrastructureRole: infrastructureRole,
+  ec2InstanceProfile: instanceProfile,
+  subnets: vpc.privateSubnets,
+  securityGroups: [fmiSecurityGroup],
+  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
+  instanceRequirements: {
+    vCpuCountMin: 1,
+    memoryMin: cdk.Size.gibibytes(2),
+    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
+    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
+  },
+});
+
+// Add FMI capacity provider to cluster
+cluster.addManagedInstancesCapacityProvider(miCapacityProvider);
+cluster.addDefaultCapacityProviderStrategy([
+  {
+    capacityProvider: miCapacityProvider.capacityProviderName,
+    weight: 1,
+  },
+]);
+
+// Create a task definition compatible with Managed Instances and Fargate
+const taskDefinition = new ecs.TaskDefinition(stack, 'TaskDef', {
+  compatibility: ecs.Compatibility.FARGATE_AND_MANAGED_INSTANCES,
+  cpu: '256',
+  memoryMiB: '512',
+  networkMode: ecs.NetworkMode.AWS_VPC,
+});
+
+taskDefinition.addContainer('web', {
+  image: ecs.ContainerImage.fromRegistry('public.ecr.aws/docker/library/httpd:2.4'),
+  memoryLimitMiB: 512,
+  portMappings: [
+    {
+      containerPort: 80,
+      protocol: ecs.Protocol.TCP,
+    },
+  ],
+});
+
+// Create a service using the MI capacity provider
+new ecs.FargateService(stack, 'ManagedInstancesService', {
+  cluster,
+  taskDefinition,
+  capacityProviderStrategies: [
+    {
+      capacityProvider: miCapacityProvider.capacityProviderName,
+      weight: 1,
+    },
+  ],
+  desiredCount: 1,
+});
+
+new integ.IntegTest(app, 'ManagedInstancesCapacityProviders', {
+  testCases: [stack],
+  regions: ['us-west-2'],
+});
+
+app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/README.md

@@ -739,6 +739,10 @@ new pipelines.CodeBuildStep('Synth', {
   buildEnvironment: {
     computeType: codebuild.ComputeType.LARGE,
     privileged: true,
+    dockerServer: {
+      computeType: codebuild.DockerServerComputeType.SMALL,
+      securityGroups: [mySecurityGroup],
+    },
   },
   timeout: Duration.minutes(90),
   fileSystemLocations: [

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-reduce-stagerole-scope.ts

@@ -53,8 +53,11 @@ class PipelineStack extends Stack {
       dockerEnabledForSynth: true,
       codeBuildDefaults: {
         buildEnvironment: {
-          buildImage: codebuild.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,
+          buildImage: codebuild.LinuxBuildImage.AMAZON_LINUX_2023_5,
           computeType: codebuild.ComputeType.SMALL,
+          dockerServer: {
+            computeType: codebuild.DockerServerComputeType.SMALL,
+          },
         },
         cache: codebuild.Cache.local(codebuild.LocalCacheMode.DOCKER_LAYER),
       },

{konokenj_cdk_api_mcp_server-0.46.0.dist-info → konokenj_cdk_api_mcp_server-0.48.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.46.0
+Version: 0.48.0
 Summary: An MCP server provides AWS CDK API Reference
 Project-URL: Documentation, https://github.com/konokenj/cdk-api-mcp-server#readme
 Project-URL: Issues, https://github.com/konokenj/cdk-api-mcp-server/issues
@@ -26,7 +26,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/konokenj.cdk-api-mcp-server.svg)](https://pypi.org/project/konokenj.cdk-api-mcp-server)
 
 <!-- DEP-VERSIONS-START -->
-[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.216.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
+[![aws-cdk](https://img.shields.io/badge/aws%20cdk-v2.218.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---

{konokenj_cdk_api_mcp_server-0.46.0.dist-info → konokenj_cdk_api_mcp_server-0.48.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cdk_api_mcp_server/__about__.py,sha256=7X5Q3f5BVA_UqKDTb4LYcIvNCYfpvE09llaieR8Xq6U,129
+cdk_api_mcp_server/__about__.py,sha256=srzMbr0otzQq5BX_rtov_llD8WR7FdcIlipzD5IkGlQ,129
 cdk_api_mcp_server/__init__.py,sha256=yJA6yIEhJviC-qNlB-nC6UR1JblQci_d84i-viHZkc0,187
 cdk_api_mcp_server/models.py,sha256=cMS1Hi29M41YjuBxqqrzNrNvyG3MgnUBb1SqYpMCJ30,692
 cdk_api_mcp_server/resources.py,sha256=R7LVwn29I4BJzU5XAwKbX8j6uy-3ZxcB1b0HzZ_Z2PI,6689
@@ -16,6 +16,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-custom-resource-sdk
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-ec2-alpha/README.md,sha256=ZySzpPJ4eUj3ZJ_jWF6YFOX4J9a7F-GU3o6QT_zJggQ,36094
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-eks-v2-alpha/MANUAL_TEST.md,sha256=uObwqDllAUYBGkoNEAQGioL6JuKqh5ScVbq9KC3x89Q,1862
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-eks-v2-alpha/README.md,sha256=PZR9EHmUdly15E0ZRfLjUZR_NyvlvV_3Jip6FSqyBR8,41992
+cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-elasticache-alpha/README.md,sha256=5rwHuZ0rekBgrFzF1ig9rAxqufypWy8XN8-7y3De0dA,15152
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-gamelift-alpha/README.md,sha256=pZqlGXpIekT05CmRYo99QPI-7S1iGtKoNESGryLQFxQ,28324
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-glue-alpha/README.md,sha256=BCr7YEJ6Ht3oYR21NMCH3t1N738QjQ9Sh_dL_DUhECQ,32235
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-iot-actions-alpha/README.md,sha256=R6vkGxu-JjfB1IfGVquiD6Gcn4RQQpgbGo36njBdJe4,11947
@@ -43,7 +44,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/cfnspec/README.md,sha25
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/custom-resource-handlers/README.md,sha256=QctOoyGt6AqVWeFhRwpkCSxHZ1XFWj_nCKlkJHDFock,965
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/example-construct-library/README.md,sha256=vnVXyvtN9ICph68sw2y6gkdD_gmas0PiUa9TkwNckWQ,4501
 cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/integ-tests-alpha/README.md,sha256=VifKLrR404_yLVT0E3ai8f3R5K0h22VNwQplpSUSZqc,17489
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md,sha256=5tNXSQdAoxRB2CXlKDpTlt-07OG3yIFqEEMnofQTGxE,76232
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/README.md/README.md,sha256=3UAoxAPV0YhySOFVSCnsNgur2YHYqBqJL4LGiWBQ7Tw,76231
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/MIGRATING.md,sha256=SYGX8QNB1Pm_rVYDBp4QRWkqwnxOb3CHzeFglUy_53k,3347
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assertions/README.md,sha256=3yo3D05n5explTIgnuF-vkk01MTYeAYe7_3rcsD2baE,18299
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/assets/README.md,sha256=kL56RlfxBa5LwV0cRseybeKIRKHhEXPjUo0HWPZqdO8,53
@@ -270,12 +271,12 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront/integ
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront/integ.key-value-store-frominline.ts,sha256=H2nulQGsjNN2e9WFL4s0s_f7WwWhglrhifbbOCoSQ2o,646
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront/integ.key-value-store.ts,sha256=d_364YWDm0IXXVZhSOgpqDJdIH85GpykvsQ-pqQI6zM,561
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront/integ.realtime-log-config.ts,sha256=ZhR1zUbouvf7RmYiYUCk-79AuTGwzDE6d8EcPWVzAPo,896
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/README.md,sha256=wJ8PuIAcpzeTLPXpUyxoMvtjt2C4O75wuR-mGcUbT_I,34919
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/README.md,sha256=yLcxLT8CAH_vWnYjQY65d_wGUeXTKiKsu6QLKmM9ol8,35377
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.function-url-origin-oac-alias.ts,sha256=3-edAxGbTMdiXKl2eLO92R1CkKVyHV8aJDHTIooU2I4,3331
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.function-url-origin-oac-custom.ts,sha256=Iv3QloWAIGk3tnCoeVVac7SgOVeXe_TI2YxAoY3Ixck,3618
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.function-url-origin-oac.ts,sha256=adecJ-YpyzA2uW3bt9OPL8uhXoY2GmhLg5W_q2UxyQU,3104
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.function-url-origin.ts,sha256=V6G-mt2FWdS_FssMxoTPCtFeBewUV9scyvRaddxSg-g,923
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.http-origin.ts,sha256=XOUD4AdemstukXCE1JT0HFd0GClB_qeoNi5dXdbsMCQ,392
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.http-origin.ts,sha256=JR5-JoCwGub7EzwPxE4HVl785gk5Q4ImrKmtH6pFwKM,569
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.load-balancer-origin.ts,sha256=F2TP5zO5FqEL-1Uw-qZTzfpqJzyPyUfsysZ4i6kHWrw,706
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.origin-group-selection-criteria.ts,sha256=V1kKE5ulDzBQ31liqUI0kr7nZ6lAEu4s6n5SSchx04g,1154
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudfront-origins/integ.origin-group.ts,sha256=rEZTwiMBsk6dzizh6d2AwqwIhCuidmBJvTqxHVeIVAA,738
@@ -324,7 +325,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actio
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.lambda-alarm-action.ts,sha256=onNZET1IofzJ-_LmnlREFQ3O7MkISTW2OrLrCkJ2qBA,4614
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.lambda-alarm-multiple-stepscalingpolicy.ts,sha256=gPLnWcaoTAAlmDYKyHsZz_55lpEDjG92xTNdjEc3IPk,2722
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-cloudwatch-actions/integ.ssm-incident-alarm-action.ts,sha256=X5iWnwQcAbLQnDkrxd5_rKL-jfw4s60kEQMVFLnCTRk,1895
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/README.md,sha256=pKI0s8e1zzvjz4LvKZga20AJxS6kpUEpsysTAP3N9ls,34404
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/README.md,sha256=D5zH4G72KjcgUBoxvyeMv5IiibETqfsjFqbsTu5N2ao,37188
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.asset-build-spec.ts,sha256=APwn0Tzph1El4XowRux9zXXlZO3eXJMFbp3bbovs-AM,1850
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.aws-deep-learning-container-build-image.ts,sha256=hSyb2cy-zu1rEkNiPybncQaV-Gh63REI95WBpuXeL-Y,488
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.breakpoint.ts,sha256=ezkSR2Ne1erXri4XV_kMwS4-DUhR5m3EMG1nxzbKZs4,838
@@ -343,7 +344,9 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-buildspec-artifacts.ts,sha256=3Fx_jwCa5HW0Dsat2B5hMXrZw_CVldbITSTZRbSGRjo,693
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-docker-server.ts,sha256=n-TtyWQmaxiI-dWyWe6nZgCDtdn_gvqZAigIT_ugFPI,1301
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-file-system-location.ts,sha256=t1I6uabPbfoaQ7lzP2EJIbvB3_5vkTrr_oQRh69_HQk,1060
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts,sha256=ttHvMAKsoo0zEF4f82x6cSyI_2QA0se6zrXoN64A2WY,2303
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-attribute-based-compute.ts,sha256=dAC9hW95FKgQl9sc_I4YK7UzIYcEZUrDblmlqd-bVJo,3930
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-custom-instance-type.ts,sha256=tobSWcbc6bd9De3brfmqAqV5_muT3FlOJPee378ff5g,4248
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet-overflow-behavior.ts,sha256=XqE1fRey0AoXWUOIKSlBo_9uumqzL_hUayqXo21uU0c,1895
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-fleet.ts,sha256=kCXeV4i_mq2JFzvTDox6rv10no6LOZ-bb_Gk6aSa7A4,1913
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-linux-arm-lambda-image.lit.ts,sha256=f8fQCveGRs6yCEF0Shkww6BxGs1_iOb8QGl5nZg-138,1282
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codebuild/integ.project-linux-arm.ts,sha256=cB-WiW6Vy4hK5vNbozAHUTX2UduHf2L2Yghm-bNF4uM,1318
@@ -461,11 +464,12 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-config/integ.cus
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-config/integ.rule-evaluation-mode.ts,sha256=EMkgQ6799C9j6DLTbsNV2e6XI6YnJ9BS5f-YBkA6Itg,1888
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-config/integ.rule.ts,sha256=1pv5tnR-mA3CAspXEr5_EtoinfPy0e17YzOjCdKFQL8,2003
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-config/integ.scoped-rule.ts,sha256=tezmTuoD9VJ8mHS2I7NKdaPgu1Ve9SuEpVQArLGECBE,911
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/README.md,sha256=pCcUSJjhWhSKJsnk5yC3HokE2yRVjJw60Wuxz-RDf70,8996
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/README.md,sha256=bOXAzpc_UFlrzAhU2ih-fiphNWW2DkpGmABay48ATnE,9912
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-copy-tags-to-snapshot.ts,sha256=jk6FB_5y0x3E7q6h9-3OT6htE7y0_L2W9o8fCo2rmzg,1007
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-instance-ca-certificate.ts,sha256=lf0OILYv2Ez8-p0d-CQGT3dUH8lPcxDY2WVvZgf42Hg,1013
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-removal-policy-snapshot.ts,sha256=EiA7liJZmGqA8wKU0hrrgSsw71MxztUTh9LwoK1rZ1Y,1868
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-rotation.lit.ts,sha256=i4vSXs0eQ7-1sLtL0GEXIW0FYdVyKpVX8Nvz_N85I9M,1022
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-serverless.ts,sha256=fVUwucggIFd_bkV6cMKFoO6UE8l_yImtyGyMupGc_Qw,971
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster-storage-type.ts,sha256=lY6eDVhKPOLF06uUT_jl-ao-mwllhXiJalS1GRqGEHY,888
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-docdb/integ.cluster.ts,sha256=9CI-3GXkVKVedg642mBMv5fBrqeSXRLfsvoftA1OM7s,1683
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-dynamodb/README.md,sha256=RegSheolCw5G878J1icibTPPfrDig67gXrYAZbGNouY,39383
@@ -581,7 +585,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ.assets-tarball.ts,sha256=pSbNMWSorKT7lUTXxnzkxpcRumKPYWUmcbqRSwwWOgI,937
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecr-assets/integ.nested-stacks-docker.ts,sha256=4hDobse34oIG2r0mjbYXzsEXXLEqv077jUh3pjoYmcc,981
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/CONTRIBUTING.md,sha256=TlNwpeYemLdYq4jdo24v7nwDIj3RmZ7u2j_LCQiQR74,2634
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/README.md,sha256=3x7qZzMSZhlUITrPhNTscpSQbBQV34cDMADTqmOA7uc,75808
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/README.md,sha256=g4z6674_NsRjkJoBj0eGXlWp03nQyapkjdJkiJ0GUUw,79348
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.add-docker-label.ts,sha256=avHktilCBVPuVelquVaY2ylRkSLraWn7vUIIIFPsbyI,1375
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.add-environment-variable.ts,sha256=sIdwJl7LYh5wlv_EDLPSGCavC2OF6W8IBwZ_hMOnCfw,1143
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.app-mesh-proxy-config.ts,sha256=vWr45An7W7lgW9Ws_yPFhapf9DXyJP-D0fhTNg5fZC0,1717
@@ -623,6 +627,7 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.gravit
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.graviton.ts,sha256=SfImqll0RwSnvXxB_UIb8pQbdN_OxFfUVsq69lI4k2o,840
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-awsvpc-nw.ts,sha256=Rwqi34a5qRjNqLnbh6bNgb46CVDnGD7WGWGWm321w24,1623
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.lb-bridge-nw.ts,sha256=sxV4f9fRvG2aTwDI0rUfipuE8yQFZy0CWUTd3H0OdUc,1632
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.managedinstances-capacity-provider.ts,sha256=oGNex2Yj_aHaaRp9rUfWerjJv7O91Ls4ChkJXqmjgpE,3561
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.nlb-awsvpc-nw.ts,sha256=vXdMwV8Ythm3Qa4cHX_mg0WjRESCMYe0GgA3tX_uqTk,1474
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.placement-constraint-default-empty.ts,sha256=mMQZyejxLzLlENEuiDk7GKa1syiPkpb6xb6DEtYH62s,1490
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-ecs/integ.placement-strategies.ts,sha256=W797uZbgznmaIVRYBaguJ3cM9OxXi70utWvE3g-nPiM,1424
@@ -1390,9 +1395,9 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/lambda-layer-kubectl
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/lambda-layer-node-proxy-agent/README.md,sha256=eWYOUl_BRExsSMY1mzF5V1oGsCuxVR-6MSIuapbOS4Y,632
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/lambda-layer-node-proxy-agent/integ.node-proxy-agent.ts,sha256=YSEuo5dS-TMKovqWBuW9uWeJj0NOJd1UgOTt-2wZVMc,1545
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/ORIGINAL_API.md,sha256=JUo88_SWhqnKC3ObhkMwGTNOma-BniqBMhoBnxpifE4,26756
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/README.md,sha256=uHIk5psamSGELoHrrSMPBO5Tr0E6dMCPCrOHKT82dIk,71460
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/README.md,sha256=UEyWH7ey2xFDUNla-gNh7-zm081fRRJhkTw9pnK6Ozc,71588
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.cross-account-pipeline-action.ts,sha256=A18UXJLsi5tyYfCp4Dw6SxI1Vk5JikNX1F0NbfEnICw,4804
-cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-reduce-stagerole-scope.ts,sha256=IqBDpjPHyU8Uk91YISZm-1I_ERD8fbQObiMd6ekOyKQ,2543
+cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-reduce-stagerole-scope.ts,sha256=YTTB_Vo8WqHM9Q12ARHyeLQfIyrvE8qGJ-c8Ac8Rx2c,2637
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-single-publisher.ts,sha256=QzRNUoZ2n7_vq4HLxkvDHt7y5ce71KjQHVFVIEDxiC4,1705
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-with-codebuild-logging.ts,sha256=7SuokmiayilFwdHU68_X5ZinfDt_Kj75quML_yHcdYQ,2557
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.newpipeline-with-codestar-connection.ts,sha256=x9DCirWauwW9hD7iCzMEoKcsVnKP1XJxJoq2Gfvxvvc,1772
@@ -1412,8 +1417,8 @@ cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/pipelines/integ.pipe
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/region-info/README.md,sha256=vewWkV3ds9o9iyyYaJBNTkaKJ2XA6K2yF17tAxUnujg,2718
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/README.md,sha256=hYIx7DbG_7p4LYLUfxDwgIQjw9UNdz1GLrqDe8_Dbko,4132
 cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/triggers/integ.triggers.ts,sha256=4OHplMoBOgHGkktAzoU-TuNmJQS5wGAUvBfj5bGSe_Y,2807
-konokenj_cdk_api_mcp_server-0.46.0.dist-info/METADATA,sha256=G0mnhyrr9OiZZacbusRKWGnxUmw1PEUB0bptSBHBIVQ,2646
-konokenj_cdk_api_mcp_server-0.46.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-konokenj_cdk_api_mcp_server-0.46.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
-konokenj_cdk_api_mcp_server-0.46.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
-konokenj_cdk_api_mcp_server-0.46.0.dist-info/RECORD,,
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/METADATA,sha256=DlxK8jwG-lfIznfwyArD_Rgn_I07ZrlH_ftIRTLM1y8,2646
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/entry_points.txt,sha256=bVDhMdyCC1WNMPOMbmB82jvWII2CIrwTZDygdCf0cYQ,79
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/licenses/LICENSE.txt,sha256=5OIAASeg1HM22mVZ1enz9bgZ7TlsGfWXnj02P9OgFyk,1098
+konokenj_cdk_api_mcp_server-0.48.0.dist-info/RECORD,,