konokenj.cdk-api-mcp-server 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

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

@@ -367,40 +367,40 @@ const crossAccountRole = new iam.Role(this, 'CrossAccountRole', {
   roleName: 'MyDelegationRole',
   // The other account
   assumedBy: new iam.AccountPrincipal('12345678901'),
-  // You can scope down this role policy to be least privileged.
-  // If you want the other account to be able to manage specific records,
-  // you can scope down by resource and/or normalized record names
-  inlinePolicies: {
-    crossAccountPolicy: new iam.PolicyDocument({
-      statements: [
-        new iam.PolicyStatement({
-          sid: 'ListHostedZonesByName',
-          effect: iam.Effect.ALLOW,
-          actions: ['route53:ListHostedZonesByName'],
-          resources: ['*'],
-        }),
-        new iam.PolicyStatement({
-          sid: 'GetHostedZoneAndChangeResourceRecordSets',
-          effect: iam.Effect.ALLOW,
-          actions: ['route53:GetHostedZone', 'route53:ChangeResourceRecordSets'],
-          // This example assumes the RecordSet subdomain.somexample.com
-          // is contained in the HostedZone
-          resources: ['arn:aws:route53:::hostedzone/HZID00000000000000000'],
-          conditions: {
-            'ForAllValues:StringLike': {
-              'route53:ChangeResourceRecordSetsNormalizedRecordNames': [
-                'subdomain.someexample.com',
-              ],
-            },
-          },
-        }),
-      ],
-    }),
-  },
 });
 parentZone.grantDelegation(crossAccountRole);
 ```
 
+To restrict the records that can be created with the delegation IAM role, use the optional `delegatedZoneNames` property in the delegation options,
+which enforces the `route53:ChangeResourceRecordSetsNormalizedRecordNames` condition key for record names that match those hosted zone names.
+The `delegatedZoneNames` list may only consist of hosted zones names that are subzones of the parent hosted zone.
+
+If the delegated zone name contains an unresolved token,
+it must resolve to a zone name that satisfies the requirements according to the documentation:
+https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/specifying-conditions-route53.html#route53_rrset_conditionkeys_normalization
+
+> All letters must be lowercase.
+> The DNS name must be without the trailing dot.
+> Characters other than a–z, 0–9, - (hyphen), _ (underscore), and . (period, as a delimiter between labels) must use escape codes in the format \three-digit octal code. For example, \052 is the octal code for character *.
+
+This feature allows you to better follow the minimum permissions privilege principle:
+
+```ts
+const parentZone = new route53.PublicHostedZone(this, 'HostedZone', {
+  zoneName: 'someexample.com',
+});
+
+declare const betaCrossAccountRole: iam.Role;
+parentZone.grantDelegation(betaCrossAccountRole, {
+    delegatedZoneNames: ['beta.someexample.com'],
+});
+
+declare const prodCrossAccountRole: iam.Role;
+parentZone.grantDelegation(prodCrossAccountRole, {
+    delegatedZoneNames: ['prod.someexample.com'],
+});
+```
+
 In the account containing the child zone to be delegated:
 
 ```ts
@@ -540,7 +540,8 @@ const zone = route53.HostedZone.fromHostedZoneAttributes(this, 'MyZone', {
 ```
 
 Alternatively, use the `HostedZone.fromHostedZoneId` to import hosted zones if
-you know the ID and the retrieval for the `zoneName` is undesirable.
+you know the ID and the retrieval for the `zoneName` is undesirable. 
+Note that any records created with a hosted zone obtained this way must have their name be fully qualified
 
 ```ts
 const zone = route53.HostedZone.fromHostedZoneId(this, 'MyZone', 'ZOJJZC49E0EPZ');

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-route53/integ.zone-delegation-iam-stack.ts

@@ -0,0 +1,66 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+import * as route53 from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+
+class ZoneDelegationIamStack extends cdk.Stack {
+  constructor(scope: Construct, id: string) {
+    super(scope, id);
+
+    const parentZone = new route53.PublicHostedZone(this, 'ParentZone', {
+      zoneName: 'uniqueexample.com',
+    });
+
+    const trusteeRoleArns = this.formatArn({
+      service: 'iam',
+      region: '',
+      resource: 'role',
+      resourceName: 'ZoneDelegationStack-*',
+    });
+
+    const delegationRole = new iam.Role(this, 'ZoneDelegationRole', {
+      roleName: 'ExampleDelegationRole',
+      assumedBy: new iam.AccountRootPrincipal().withConditions({
+        ArnLike: {
+          'aws:PrincipalArn': trusteeRoleArns,
+        },
+      }),
+    });
+
+    const delegationGrant = parentZone.grantDelegation(delegationRole, {
+      delegatedZoneNames: [
+        'sub1.uniqueexample.com',
+        'sub2_*$.uniqueexample.com', // should result in octal codes in iam condition
+      ],
+    });
+
+    const subZone = new route53.PublicHostedZone(this, 'SubZone', {
+      zoneName: 'sub1.uniqueexample.com',
+    });
+
+    new route53.CrossAccountZoneDelegationRecord(subZone, 'ZoneDelegation', {
+      delegatedZone: subZone,
+      parentHostedZoneName: parentZone.zoneName,
+      delegationRole: delegationRole,
+    }).node.addDependency(delegationGrant);
+
+    const subZoneWithSpecialChars = new route53.PublicHostedZone(this, 'SubZoneSpecialChars', {
+      zoneName: 'sub2_*$.uniqueexample.com',
+    });
+
+    new route53.CrossAccountZoneDelegationRecord(subZoneWithSpecialChars, 'ZoneDelegation', {
+      delegatedZone: subZoneWithSpecialChars,
+      parentHostedZoneName: parentZone.zoneName,
+      delegationRole: delegationRole,
+    }).node.addDependency(delegationGrant);
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new ZoneDelegationIamStack(app, 'ZoneDelegationStack');
+
+new IntegTest(app, 'ZoneDelegationIam', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-deployment/integ.bucket-deployment-big-response.ts

@@ -31,6 +31,10 @@ class TestBucketDeployment extends cdk.Stack {
     const sources = [];
     for (let i = 0; i < numFiles; i++) {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tmpcdk'));
+      process.on('exit', () => {
+        fs.rmSync(tempDir, { force: true, recursive: true });
+      });
+
       fs.mkdirSync(tempDir, { recursive: true });
       const fileName = `${i+1}.txt`;
       const filePath = path.join(tempDir, fileName);

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-deployment/integ.bucket-deployment-data.ts

@@ -64,6 +64,9 @@ class TestBucketDeploymentData extends Stack {
     // Test empty string handling
     const file8 = Source.data('file8.txt', '');
 
+    // Test null JSON data value
+    const file9 = Source.jsonData('my-json/config-with-null.json', { hello: 'there', goodbye: null });
+
     const deployment = new BucketDeployment(this, 'DeployWithDataSources', {
       destinationBucket: this.bucket,
       sources: [file1, file2],
@@ -77,6 +80,7 @@ class TestBucketDeploymentData extends Stack {
     deployment.addSource(file6);
     deployment.addSource(file7);
     deployment.addSource(file8);
+    deployment.addSource(file9);
 
     new CfnOutput(this, 'BucketName', { value: this.bucket.bucketName });
   }
@@ -105,6 +109,17 @@ assertionProvider.expect(ExpectedResult.objectLike({
   Body: '{"secret_value":"test\\"with\\"quotes"}',
 }));
 
+// Assert that JSON data with a null value is represented properly
+const jsonNullAssertionProvider = integTest.assertions.awsApiCall('S3', 'getObject', {
+  Bucket: testCase.bucket.bucketName,
+  Key: path.join('deploy/here', 'my-json/config-with-null.json'),
+});
+
+// Verify the content is valid JSON and both null and non-null fields are present
+jsonNullAssertionProvider.expect(ExpectedResult.objectLike({
+  Body: '{"hello":"there","goodbye":null}',
+}));
+
 // Add assertions to verify the YAML file
 const yamlAssertionProvider = integTest.assertions.awsApiCall('S3', 'getObject', {
   Bucket: testCase.bucket.bucketName,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-s3-deployment/integ.bucket-deployment-large-file.ts

@@ -30,6 +30,9 @@ const bucket = new Bucket(stack, 'Bucket', {
 
 // Create a temporary directory for our large files
 const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-large-files-'));
+process.on('exit', () => {
+  fs.rmSync(tempDir, { force: true, recursive: true });
+});
 
 // Generate a large JSON file (10MB) programmatically
 const largeJsonFilePath = path.join(tempDir, 'large-file.json');

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-secretsmanager/integ.secret.dynamic-reference-key.ts

@@ -0,0 +1,38 @@
+import * as cdk from 'aws-cdk-lib';
+import { SecretValue } from 'aws-cdk-lib';
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+
+class TestStack extends cdk.Stack {
+  constructor(scope: cdk.App, id: string) {
+    super(scope, id);
+
+    // Create a default secret
+    const secret = new secretsmanager.Secret(this, 'Secret');
+
+    // Create a JSON secret containing cfnDynamicReferenceKey values extracted from the default secret
+    new secretsmanager.Secret(this, 'JSONSecret', {
+      secretObjectValue: {
+        cfnDynamicReferenceKeyWithDefaults: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey()),
+        cfnDynamicReferenceKeyWithJsonFieldAndVersionStage: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey({
+          jsonField: 'json-key',
+          versionStage: 'version-stage',
+        })),
+        cfnDynamicReferenceKeyWithJsonFieldAndVersionId: SecretValue.unsafePlainText(secret.cfnDynamicReferenceKey({
+          jsonField: 'json-key',
+          versionId: 'version-id',
+        })),
+      },
+    });
+  }
+}
+
+const app = new cdk.App();
+
+const stack = new TestStack(app, 'cdk-integ-secrets-dynamic-reference-key');
+
+new integ.IntegTest(app, 'cdk-integ-secrets-dynamic-reference-key-test', {
+  testCases: [stack],
+});
+
+app.synth();

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

@@ -141,6 +141,17 @@ The `EvaluateExpression` supports a `runtime` prop to specify the Lambda
 runtime to use to evaluate the expression. Currently, only runtimes
 of the Node.js family are supported.
 
+The `EvaluateExpression` also supports an `architecture` prop to specify the Lambda
+architecture. This can be useful when migrating to ARM64 or when running integration
+tests on ARM64 systems.
+
+```ts
+const convertToSecondsArm64 = new tasks.EvaluateExpression(this, 'Convert to seconds', {
+  expression: '$.waitMilliseconds / 1000',
+  architecture: lambda.Architecture.ARM_64,
+});
+```
+
 ## API Gateway
 
 Step Functions supports [API Gateway](https://docs.aws.amazon.com/step-functions/latest/dg/connect-api-gateway.html) through the service integration pattern.
@@ -1374,12 +1385,12 @@ The following code snippet includes a Task state that uses eks:call to list the
 
 ```ts
 import * as eks from 'aws-cdk-lib/aws-eks';
-import { KubectlV33Layer } from '@aws-cdk/lambda-layer-kubectl-v33';
+import { KubectlV34Layer } from '@aws-cdk/lambda-layer-kubectl-v34';
 
 const myEksCluster = new eks.Cluster(this, 'my sample cluster', {
-  version: eks.KubernetesVersion.V1_32,
+  version: eks.KubernetesVersion.V1_34,
   clusterName: 'myEksCluster',
-  kubectlLayer: new KubectlV33Layer(this, 'kubectl'),
+  kubectlLayer: new KubectlV34Layer(this, 'kubectl'),
 });
 
 new tasks.EksCall(this, 'Call a EKS Endpoint', {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-arm64.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-arm64-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionArm64Test', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-default.ts

@@ -0,0 +1,25 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-default-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionDefaultTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-mixed-arch.ts

@@ -0,0 +1,35 @@
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as cdk from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-cdk-sfn-evaluate-expression-mixed-arch-integ');
+
+const evalTaskArm = new tasks.EvaluateExpression(stack, 'EvalExpressionArm', {
+  expression: '$.a + $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.ARM_64,
+});
+
+const evalTaskX86 = new tasks.EvaluateExpression(stack, 'EvalExpressionX86', {
+  expression: '$.a * $.b',
+  runtime: lambda.Runtime.NODEJS_20_X,
+  architecture: lambda.Architecture.X86_64,
+});
+
+const definition = new sfn.Pass(stack, 'Start', {
+  result: sfn.Result.fromObject({ a: 3, b: 4 }),
+}).next(new sfn.Parallel(stack, 'ParallelEval')
+  .branch(evalTaskArm)
+  .branch(evalTaskX86),
+);
+
+new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(definition),
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionMixedArchTest', {
+  testCases: [stack],
+});

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-stepfunctions-tasks/integ.evaluate-expression-x86.ts

@@ -0,0 +1,27 @@
+import { App, Stack } from 'aws-cdk-lib';
+import * as integ from '@aws-cdk/integ-tests-alpha';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as cdk from 'aws-cdk-lib';
+import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
+
+const app = new App();
+const stack = new Stack(app, 'aws-cdk-sfn-evaluate-expression-x86-integ');
+
+const evaluateExpression = new tasks.EvaluateExpression(stack, 'EvaluateExpression', {
+  expression: '$.a + $.b',
+  architecture: lambda.Architecture.X86_64,
+});
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definitionBody: sfn.DefinitionBody.fromChainable(evaluateExpression),
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+new integ.IntegTest(app, 'EvaluateExpressionX86Test', {
+  testCases: [stack],
+});

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

@@ -831,6 +831,62 @@ new cr.AwsCustomResource(this, 'CrossAccount', {
 });
 ```
 
+#### Using External IDs for Enhanced Security
+
+When assuming cross-account roles, you can specify an external ID to prevent the "confused deputy" problem. The external ID is a unique identifier provided by the third-party service that helps ensure the service is acting on behalf of the correct customer:
+
+```ts
+const crossAccountRoleArn = 'arn:aws:iam::OTHERACCOUNT:role/CrossAccountRoleName';
+const serviceExternalId = 'unique-secret-value-12345'; // External ID provided by the third party service. This value should be unique among the third-party service's customers.
+
+
+new cr.AwsCustomResource(this, 'SecureCrossAccount', {
+  onCreate: {
+    assumedRoleArn: crossAccountRoleArn,
+    externalId: serviceExternalId, // Prevents confused deputy attacks
+    service: 'sts',
+    action: 'GetCallerIdentity',
+    physicalResourceId: cr.PhysicalResourceId.of('id'),
+  },
+  policy: cr.AwsCustomResourcePolicy.fromStatements([iam.PolicyStatement.fromJson({
+    Effect: "Allow",
+    Action: "sts:AssumeRole",
+    Resource: crossAccountRoleArn,
+  })]),
+});
+```
+
+The external ID can also be different for each lifecycle operation:
+
+```ts
+declare const createRoleArn: string;
+declare const updateRoleArn: string;
+
+new cr.AwsCustomResource(this, 'MultiRoleSecure', {
+  onCreate: {
+    assumedRoleArn: createRoleArn,
+    externalId: 'create-secret-123',
+    service: 'ec2',
+    action: 'DescribeInstances',
+    physicalResourceId: cr.PhysicalResourceId.of('id'),
+  },
+  onUpdate: {
+    assumedRoleArn: updateRoleArn,
+    externalId: 'update-secret-456',
+    service: 'ec2',
+    action: 'DescribeInstances',
+  },
+  policy: cr.AwsCustomResourcePolicy.fromStatements([
+    new iam.PolicyStatement({
+      actions: ['sts:AssumeRole'],
+      resources: [createRoleArn, updateRoleArn],
+    }),
+  ]),
+});
+```
+
+For more information on external IDs and preventing confused deputy attacks, see the [AWS IAM User Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html).
+
 #### Custom Resource Config
 
 **This feature is currently experimental**

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/custom-resources/integ.external-id.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import * as iam from 'aws-cdk-lib/aws-iam';
+import * as cdk from 'aws-cdk-lib';
+import { IntegTest } from '@aws-cdk/integ-tests-alpha';
+import { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from 'aws-cdk-lib/custom-resources';
+
+/**
+ * Integration test for AwsCustomResource External ID support.
+ *
+ * This test demonstrates the use of external IDs when assuming roles
+ * in cross-account scenarios to prevent "confused deputy" attacks.
+ *
+ * Note: This test may introduce destructive changes to CDK metadata
+ * and Lambda function assets due to CDK version updates. These changes
+ * are expected and safe for integration testing purposes.
+ */
+
+const app = new cdk.App({
+  postCliContext: {
+    // Disable CDK managed log groups to prevent Lambda changes
+    '@aws-cdk/aws-lambda:useCdkManagedLogGroup': false,
+    // Disable version reporting to prevent CDK metadata changes
+    '@aws-cdk/core:disableVersionReporting': true,
+    // Disable new style synthesis to maintain compatibility
+    '@aws-cdk/core:newStyleStackSynthesis': false,
+    // Use legacy asset bundling to prevent asset hash changes
+    '@aws-cdk/core:enableLegacyV2AssetKeys': true,
+    // Disable stack name validation to prevent naming conflicts
+    '@aws-cdk/core:stackRelativeExports': false,
+  },
+});
+
+const stack = new cdk.Stack(app, 'aws-custom-resource-external-id-test');
+
+// Create a role that requires an external ID
+const externalId = 'test-external-id-12345';
+const roleWithExternalId = new iam.Role(stack, 'RoleWithExternalId', {
+  // Use a principal that can be used in integration tests
+  assumedBy: new iam.AccountPrincipal(cdk.Stack.of(stack).account),
+  externalIds: [externalId],
+});
+
+// Add the necessary permissions as managed policies to reduce template variability
+roleWithExternalId.addToPolicy(
+  new iam.PolicyStatement({
+    actions: ['sts:GetCallerIdentity'],
+    resources: ['*'],
+  }),
+);
+
+// Test basic external ID usage
+new AwsCustomResource(stack, 'ExternalIdTest', {
+  installLatestAwsSdk: false,
+  onCreate: {
+    assumedRoleArn: roleWithExternalId.roleArn,
+    externalId: externalId,
+    service: 'STS',
+    action: 'GetCallerIdentity',
+    physicalResourceId: PhysicalResourceId.of('external-id-test'),
+  },
+  policy: AwsCustomResourcePolicy.fromSdkCalls({ resources: [] }),
+});
+
+new IntegTest(app, 'AwsCustomResourceTest', {
+  testCases: [stack],
+  diffAssets: true,
+  allowDestroy: ['AWS::CDK::Metadata'],
+  cdkCommandOptions: {
+    deploy: {
+      args: {
+        rollback: false,
+      },
+    },
+    destroy: {
+      args: {
+        force: true,
+      },
+    },
+  },
+});

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

@@ -0,0 +1,33 @@
+CDK Resource Interfaces
+=======================
+
+This module contains resource interfaces for all AWS service resources.
+
+These are interfaces that look like this:
+
+```
+/**
+ * Indicates that this resource can be referenced as a Bucket.
+ */
+interface IBucketRef {
+  /**
+   * A reference to a Bucket resource.
+   */
+  readonly bucketRef: BucketReference;
+}
+
+interface BucketReference {
+  /**
+   * The BucketName of the Bucket resource.
+   */
+  readonly bucketName: string;
+
+  /**
+   * The ARN of the Bucket resource.
+   */
+  readonly bucketArn: string;
+}
+```
+
+These are in a separate submodule so that they can be referenced from all other
+service submodules without introducing cyclic dependencies between them.

{konokenj_cdk_api_mcp_server-0.53.0.dist-info → konokenj_cdk_api_mcp_server-0.55.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: konokenj.cdk-api-mcp-server
-Version: 0.53.0
+Version: 0.55.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.222.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.224.0-blue.svg)](https://github.com/konokenj/cdk-api-mcp-server/blob/main/current-versions/aws-cdk.txt)
 <!-- DEP-VERSIONS-END -->
 
 ---