@cdklabs/cdk-appmod-catalog-blueprints 1.0.0

package/lib/document-processing/tests/agentic-document-processing.test.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const agentic_document_processing_1 = require("../agentic-document-processing");
+describe('AgenticDocumentProcessing', () => {
+    let basicStack;
+    let crossRegionStack;
+    let defaultModelStack;
+    let basicTemplate;
+    let crossRegionTemplate;
+    let defaultModelTemplate;
+    beforeAll(() => {
+        // Create all stacks and constructs first
+        basicStack = new aws_cdk_lib_1.Stack();
+        new agentic_document_processing_1.AgenticDocumentProcessing(basicStack, 'BasicTest', {
+            processingPrompt: 'Custom processing prompt',
+            processingAgentParameters: {
+                agentSystemPrompt: 'Test system prompt',
+                toolsLocation: ['tool1', 'tool2'],
+            },
+        });
+        crossRegionStack = new aws_cdk_lib_1.Stack();
+        new agentic_document_processing_1.AgenticDocumentProcessing(crossRegionStack, 'CrossRegionTest', {
+            useCrossRegionInference: true,
+        });
+        defaultModelStack = new aws_cdk_lib_1.Stack();
+        new agentic_document_processing_1.AgenticDocumentProcessing(defaultModelStack, 'DefaultModelTest', {
+            useCrossRegionInference: false,
+        });
+        // Generate templates once after all constructs are created
+        basicTemplate = assertions_1.Template.fromStack(basicStack);
+        crossRegionTemplate = assertions_1.Template.fromStack(crossRegionStack);
+        defaultModelTemplate = assertions_1.Template.fromStack(defaultModelStack);
+    });
+    test('creates basic infrastructure', () => {
+        basicTemplate.hasResourceProperties('AWS::S3::Bucket', {});
+        basicTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Runtime: 'python3.13',
+        });
+        basicTemplate.resourceCountIs('AWS::Lambda::Function', 5);
+    });
+    test('configures all agent parameters', () => {
+        basicTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    SYSTEM_PROMPT: 'Test system prompt',
+                    TOOLS_CONFIG: '["tool1","tool2"]',
+                    PROMPT: 'Custom processing prompt',
+                },
+            },
+        });
+    });
+    test('inherits bedrock document processing functionality', () => {
+        basicTemplate.hasResourceProperties('AWS::S3::Bucket', {});
+        basicTemplate.hasResourceProperties('AWS::DynamoDB::Table', {});
+        basicTemplate.hasResourceProperties('AWS::SQS::Queue', {});
+        basicTemplate.hasResourceProperties('AWS::StepFunctions::StateMachine', {});
+    });
+    test('creates IAM role with correct permissions', () => {
+        basicTemplate.hasResourceProperties('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [{
+                        Action: 'sts:AssumeRole',
+                        Effect: 'Allow',
+                        Principal: {
+                            Service: 'lambda.amazonaws.com',
+                        },
+                    }],
+            },
+        });
+        basicTemplate.hasResourceProperties('AWS::IAM::Role', {
+            Policies: [{
+                    PolicyDocument: {
+                        Statement: [
+                            {
+                                Effect: 'Allow',
+                                Action: 's3:GetObject',
+                                Resource: {
+                                    'Fn::Join': [
+                                        '',
+                                        [
+                                            { 'Fn::GetAtt': [assertions_1.Match.anyValue(), 'Arn'] },
+                                            '/*',
+                                        ],
+                                    ],
+                                },
+                            },
+                            {
+                                Effect: 'Allow',
+                                Action: ['bedrock:InvokeModel', 'bedrock:InvokeModelWithResponseStream'],
+                                Resource: assertions_1.Match.anyValue(),
+                            },
+                        ],
+                    },
+                    PolicyName: 'BedrockInvokePolicy',
+                }],
+        });
+    });
+    test('configures timeout and memory for processing function', () => {
+        basicTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Timeout: 300,
+            MemorySize: 1024,
+        });
+    });
+    test('uses cross-region inference when enabled', () => {
+        crossRegionTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    MODEL_ID: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+                },
+            },
+        });
+    });
+    test('uses default model when cross-region inference is disabled', () => {
+        defaultModelTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    MODEL_ID: 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+                },
+            },
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agentic-document-processing.test.js","sourceRoot":"","sources":["../../../use-cases/document-processing/tests/agentic-document-processing.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stack } from 'aws-cdk-lib';\nimport { Template, Match } from 'aws-cdk-lib/assertions';\nimport { AgenticDocumentProcessing } from '../agentic-document-processing';\n\ndescribe('AgenticDocumentProcessing', () => {\n  let basicStack: Stack;\n  let crossRegionStack: Stack;\n  let defaultModelStack: Stack;\n  let basicTemplate: Template;\n  let crossRegionTemplate: Template;\n  let defaultModelTemplate: Template;\n\n  beforeAll(() => {\n    // Create all stacks and constructs first\n    basicStack = new Stack();\n    new AgenticDocumentProcessing(basicStack, 'BasicTest', {\n      processingPrompt: 'Custom processing prompt',\n      processingAgentParameters: {\n        agentSystemPrompt: 'Test system prompt',\n        toolsLocation: ['tool1', 'tool2'],\n      },\n    });\n\n    crossRegionStack = new Stack();\n    new AgenticDocumentProcessing(crossRegionStack, 'CrossRegionTest', {\n      useCrossRegionInference: true,\n    });\n\n    defaultModelStack = new Stack();\n    new AgenticDocumentProcessing(defaultModelStack, 'DefaultModelTest', {\n      useCrossRegionInference: false,\n    });\n\n    // Generate templates once after all constructs are created\n    basicTemplate = Template.fromStack(basicStack);\n    crossRegionTemplate = Template.fromStack(crossRegionStack);\n    defaultModelTemplate = Template.fromStack(defaultModelStack);\n  });\n\n  test('creates basic infrastructure', () => {\n    basicTemplate.hasResourceProperties('AWS::S3::Bucket', {});\n    basicTemplate.hasResourceProperties('AWS::Lambda::Function', {\n      Runtime: 'python3.13',\n    });\n    basicTemplate.resourceCountIs('AWS::Lambda::Function', 5);\n  });\n\n  test('configures all agent parameters', () => {\n    basicTemplate.hasResourceProperties('AWS::Lambda::Function', {\n      Environment: {\n        Variables: {\n          SYSTEM_PROMPT: 'Test system prompt',\n          TOOLS_CONFIG: '[\"tool1\",\"tool2\"]',\n          PROMPT: 'Custom processing prompt',\n        },\n      },\n    });\n  });\n\n  test('inherits bedrock document processing functionality', () => {\n    basicTemplate.hasResourceProperties('AWS::S3::Bucket', {});\n    basicTemplate.hasResourceProperties('AWS::DynamoDB::Table', {});\n    basicTemplate.hasResourceProperties('AWS::SQS::Queue', {});\n    basicTemplate.hasResourceProperties('AWS::StepFunctions::StateMachine', {});\n  });\n\n  test('creates IAM role with correct permissions', () => {\n    basicTemplate.hasResourceProperties('AWS::IAM::Role', {\n      AssumeRolePolicyDocument: {\n        Statement: [{\n          Action: 'sts:AssumeRole',\n          Effect: 'Allow',\n          Principal: {\n            Service: 'lambda.amazonaws.com',\n          },\n        }],\n      },\n    });\n\n    basicTemplate.hasResourceProperties('AWS::IAM::Role', {\n      Policies: [{\n        PolicyDocument: {\n          Statement: [\n            {\n              Effect: 'Allow',\n              Action: 's3:GetObject',\n              Resource: {\n                'Fn::Join': [\n                  '',\n                  [\n                    { 'Fn::GetAtt': [Match.anyValue(), 'Arn'] },\n                    '/*',\n                  ],\n                ],\n              },\n            },\n            {\n              Effect: 'Allow',\n              Action: ['bedrock:InvokeModel', 'bedrock:InvokeModelWithResponseStream'],\n              Resource: Match.anyValue(),\n            },\n          ],\n        },\n        PolicyName: 'BedrockInvokePolicy',\n      }],\n    });\n  });\n\n  test('configures timeout and memory for processing function', () => {\n    basicTemplate.hasResourceProperties('AWS::Lambda::Function', {\n      Timeout: 300,\n      MemorySize: 1024,\n    });\n  });\n\n  test('uses cross-region inference when enabled', () => {\n    crossRegionTemplate.hasResourceProperties('AWS::Lambda::Function', {\n      Environment: {\n        Variables: {\n          MODEL_ID: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',\n        },\n      },\n    });\n  });\n\n  test('uses default model when cross-region inference is disabled', () => {\n    defaultModelTemplate.hasResourceProperties('AWS::Lambda::Function', {\n      Environment: {\n        Variables: {\n          MODEL_ID: 'anthropic.claude-3-7-sonnet-20250219-v1:0',\n        },\n      },\n    });\n  });\n});\n"]}

package/lib/document-processing/tests/bedrock-document-processing-nag.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/document-processing/tests/bedrock-document-processing-nag.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const aws_s3_1 = require("aws-cdk-lib/aws-s3");
+const cdk_nag_1 = require("cdk-nag");
+const framework_1 = require("../../framework");
+const eventbridge_broker_1 = require("../../framework/foundation/eventbridge-broker");
+const bedrock_document_processing_1 = require("../bedrock-document-processing");
+// Create app and stack
+const app = new aws_cdk_lib_1.App();
+const stack = new aws_cdk_lib_1.Stack(app, 'TestStack', {
+    env: {
+        account: '123456789012',
+        region: 'us-east-1',
+    },
+});
+// Create EventBridge broker
+const broker = new eventbridge_broker_1.EventbridgeBroker(stack, 'IDPBroker', {
+    name: 'idp-broker',
+    eventSource: 'intelligent-document-processing',
+});
+const accessLog = new framework_1.AccessLog(stack, 'AccessLog');
+// Create S3 bucket for agentic tools
+const bucket = new aws_s3_1.Bucket(stack, 'BedrockDocumentProcessingBucket', {
+    serverAccessLogsBucket: accessLog.bucket,
+    serverAccessLogsPrefix: accessLog.bucketPrefix,
+    enforceSSL: true,
+});
+// Create the main BedrockDocumentProcessing construct
+new bedrock_document_processing_1.BedrockDocumentProcessing(stack, 'BedrockDocumentProcessing', {
+    bucket,
+    useCrossRegionInference: true,
+    eventbridgeBroker: broker,
+    enableObservability: true,
+});
+// Suppress CDK-managed BucketNotificationsHandler AWS managed policy
+cdk_nag_1.NagSuppressions.addResourceSuppressionsByPath(stack, '/TestStack/BucketNotificationsHandler050a0587b7544547bf325f094a3db834/Role', [
+    {
+        id: 'AwsSolutions-IAM4',
+        reason: 'CDK-managed BucketNotificationsHandler requires AWSLambdaBasicExecutionRole for S3 event processing',
+        appliesTo: ['Policy::arn:<AWS::Partition>:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'],
+    },
+]);
+// Suppress S3 bucket wildcard permissions for Lambda roles
+cdk_nag_1.NagSuppressions.addResourceSuppressions(stack, [
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Lambda functions require wildcard access to S3 bucket objects for document processing',
+        appliesTo: ['Resource::<BedrockDocumentProcessingBucketA06CA1E2.Arn>/*'],
+    },
+], true);
+// Suppress Bedrock foundation model wildcard permissions
+cdk_nag_1.NagSuppressions.addResourceSuppressions(stack, [
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Cross-region inference requires wildcard region access to Bedrock foundation models',
+        appliesTo: ['Resource::arn:aws:bedrock:*::foundation-model/anthropic.claude-3-7-sonnet-20250219-v1:0'],
+    },
+], true);
+// Suppress SQSConsumerRole wildcard permissions for Lambda log streams
+cdk_nag_1.NagSuppressions.addResourceSuppressions(stack, [
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Lambda log stream ARN is only known at runtime, wildcard required for CloudWatch Logs access',
+    },
+], true);
+// Suppress StateMachineRole wildcard permissions for Lambda invocation
+cdk_nag_1.NagSuppressions.addResourceSuppressionsByPath(stack, '/TestStack/BedrockDocumentProcessing/StateMachineRole/DefaultPolicy', [
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Step Functions requires wildcard permissions to invoke Lambda functions with version-specific ARNs',
+    },
+]);
+// Suppress Lambda log group wildcard permissions
+cdk_nag_1.NagSuppressions.addResourceSuppressions(stack, [
+    {
+        id: 'AwsSolutions-IAM5',
+        reason: 'Lambda log stream names are generated at runtime, wildcard required for CloudWatch Logs access',
+    },
+], true);
+// Apply CDK Nag checks
+aws_cdk_lib_1.Aspects.of(app).add(new cdk_nag_1.AwsSolutionsChecks({ verbose: true }));
+// Synthesize the stack and check for unsuppressed warnings and errors
+const warnings = assertions_1.Annotations.fromStack(stack).findWarning('*', assertions_1.Match.stringLikeRegexp('AwsSolutions-.*'));
+const errors = assertions_1.Annotations.fromStack(stack).findError('*', assertions_1.Match.stringLikeRegexp('AwsSolutions-.*'));
+// Test: No unsuppressed warnings
+test('No unsuppressed warnings', () => {
+    if (warnings.length > 0) {
+        console.log('CDK Nag Warnings:', JSON.stringify(warnings, null, 2));
+    }
+    expect(warnings).toHaveLength(0);
+});
+// Test: No unsuppressed errors
+test('No unsuppressed errors', () => {
+    if (errors.length > 0) {
+        console.log('CDK Nag Errors:', JSON.stringify(errors, null, 2));
+    }
+    expect(errors).toHaveLength(0);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bedrock-document-processing-nag.test.js","sourceRoot":"","sources":["../../../use-cases/document-processing/tests/bedrock-document-processing-nag.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { App, Stack, Aspects } from 'aws-cdk-lib';\nimport { Annotations, Match } from 'aws-cdk-lib/assertions';\nimport { Bucket } from 'aws-cdk-lib/aws-s3';\nimport { AwsSolutionsChecks, NagSuppressions } from 'cdk-nag';\nimport { AccessLog } from '../../framework';\nimport { EventbridgeBroker } from '../../framework/foundation/eventbridge-broker';\nimport { BedrockDocumentProcessing } from '../bedrock-document-processing';\n\n// Create app and stack\nconst app = new App();\nconst stack = new Stack(app, 'TestStack', {\n  env: {\n    account: '123456789012',\n    region: 'us-east-1',\n  },\n});\n\n// Create EventBridge broker\nconst broker = new EventbridgeBroker(stack, 'IDPBroker', {\n  name: 'idp-broker',\n  eventSource: 'intelligent-document-processing',\n});\n\nconst accessLog = new AccessLog(stack, 'AccessLog');\n\n// Create S3 bucket for agentic tools\nconst bucket = new Bucket(stack, 'BedrockDocumentProcessingBucket', {\n  serverAccessLogsBucket: accessLog.bucket,\n  serverAccessLogsPrefix: accessLog.bucketPrefix,\n  enforceSSL: true,\n});\n\n// Create the main BedrockDocumentProcessing construct\nnew BedrockDocumentProcessing(stack, 'BedrockDocumentProcessing', {\n  bucket,\n  useCrossRegionInference: true,\n  eventbridgeBroker: broker,\n  enableObservability: true,\n});\n\n// Suppress CDK-managed BucketNotificationsHandler AWS managed policy\nNagSuppressions.addResourceSuppressionsByPath(\n  stack,\n  '/TestStack/BucketNotificationsHandler050a0587b7544547bf325f094a3db834/Role',\n  [\n    {\n      id: 'AwsSolutions-IAM4',\n      reason: 'CDK-managed BucketNotificationsHandler requires AWSLambdaBasicExecutionRole for S3 event processing',\n      appliesTo: ['Policy::arn:<AWS::Partition>:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'],\n    },\n  ],\n);\n\n// Suppress S3 bucket wildcard permissions for Lambda roles\nNagSuppressions.addResourceSuppressions(\n  stack,\n  [\n    {\n      id: 'AwsSolutions-IAM5',\n      reason: 'Lambda functions require wildcard access to S3 bucket objects for document processing',\n      appliesTo: ['Resource::<BedrockDocumentProcessingBucketA06CA1E2.Arn>/*'],\n    },\n  ],\n  true,\n);\n\n// Suppress Bedrock foundation model wildcard permissions\nNagSuppressions.addResourceSuppressions(\n  stack,\n  [\n    {\n      id: 'AwsSolutions-IAM5',\n      reason: 'Cross-region inference requires wildcard region access to Bedrock foundation models',\n      appliesTo: ['Resource::arn:aws:bedrock:*::foundation-model/anthropic.claude-3-7-sonnet-20250219-v1:0'],\n    },\n  ],\n  true,\n);\n\n// Suppress SQSConsumerRole wildcard permissions for Lambda log streams\nNagSuppressions.addResourceSuppressions(\n  stack,\n  [\n    {\n      id: 'AwsSolutions-IAM5',\n      reason: 'Lambda log stream ARN is only known at runtime, wildcard required for CloudWatch Logs access',\n    },\n  ],\n  true,\n);\n\n// Suppress StateMachineRole wildcard permissions for Lambda invocation\nNagSuppressions.addResourceSuppressionsByPath(\n  stack,\n  '/TestStack/BedrockDocumentProcessing/StateMachineRole/DefaultPolicy',\n  [\n    {\n      id: 'AwsSolutions-IAM5',\n      reason: 'Step Functions requires wildcard permissions to invoke Lambda functions with version-specific ARNs',\n    },\n  ],\n);\n\n// Suppress Lambda log group wildcard permissions\nNagSuppressions.addResourceSuppressions(\n  stack,\n  [\n    {\n      id: 'AwsSolutions-IAM5',\n      reason: 'Lambda log stream names are generated at runtime, wildcard required for CloudWatch Logs access',\n    },\n  ],\n  true,\n);\n\n// Apply CDK Nag checks\nAspects.of(app).add(new AwsSolutionsChecks({ verbose: true }));\n\n// Synthesize the stack and check for unsuppressed warnings and errors\nconst warnings = Annotations.fromStack(stack).findWarning('*', Match.stringLikeRegexp('AwsSolutions-.*'));\nconst errors = Annotations.fromStack(stack).findError('*', Match.stringLikeRegexp('AwsSolutions-.*'));\n\n// Test: No unsuppressed warnings\ntest('No unsuppressed warnings', () => {\n  if (warnings.length > 0) {\n    console.log('CDK Nag Warnings:', JSON.stringify(warnings, null, 2));\n  }\n  expect(warnings).toHaveLength(0);\n});\n\n// Test: No unsuppressed errors\ntest('No unsuppressed errors', () => {\n  if (errors.length > 0) {\n    console.log('CDK Nag Errors:', JSON.stringify(errors, null, 2));\n  }\n  expect(errors).toHaveLength(0);\n});\n"]}

package/lib/document-processing/tests/bedrock-document-processing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/document-processing/tests/bedrock-document-processing.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const assertions_1 = require("aws-cdk-lib/assertions");
+const aws_bedrock_1 = require("aws-cdk-lib/aws-bedrock");
+const bedrock_document_processing_1 = require("../bedrock-document-processing");
+describe('BedrockDocumentProcessing', () => {
+    let defaultStack;
+    let customStack;
+    let crossRegionStack;
+    let defaultTemplate;
+    let customTemplate;
+    let crossRegionTemplate;
+    beforeAll(() => {
+        // Create all stacks and constructs first
+        defaultStack = new aws_cdk_lib_1.Stack();
+        new bedrock_document_processing_1.BedrockDocumentProcessing(defaultStack, 'DefaultTest', {});
+        customStack = new aws_cdk_lib_1.Stack();
+        new bedrock_document_processing_1.BedrockDocumentProcessing(customStack, 'CustomTest', {
+            classificationModelId: aws_bedrock_1.FoundationModelIdentifier.ANTHROPIC_CLAUDE_3_HAIKU_20240307_V1_0,
+            useCrossRegionInference: false,
+        });
+        crossRegionStack = new aws_cdk_lib_1.Stack();
+        new bedrock_document_processing_1.BedrockDocumentProcessing(crossRegionStack, 'CrossRegionTest', {
+            useCrossRegionInference: true,
+            crossRegionInferencePrefix: bedrock_document_processing_1.BedrockCrossRegionInferencePrefix.EU,
+        });
+        // Generate templates once after all constructs are created
+        defaultTemplate = assertions_1.Template.fromStack(defaultStack);
+        customTemplate = assertions_1.Template.fromStack(customStack);
+        crossRegionTemplate = assertions_1.Template.fromStack(crossRegionStack);
+    });
+    test('creates basic infrastructure', () => {
+        defaultTemplate.hasResourceProperties('AWS::S3::Bucket', {});
+        defaultTemplate.hasResourceProperties('AWS::SQS::Queue', {});
+        defaultTemplate.hasResourceProperties('AWS::DynamoDB::Table', { BillingMode: 'PAY_PER_REQUEST' });
+        defaultTemplate.hasResourceProperties('AWS::StepFunctions::StateMachine', {});
+        defaultTemplate.resourceCountIs('AWS::Lambda::Function', 5);
+    });
+    test('uses default model with cross-region prefix disabled', () => {
+        defaultTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    MODEL_ID: 'anthropic.claude-3-7-sonnet-20250219-v1:0',
+                },
+            },
+        });
+    });
+    test('uses custom model without cross-region prefix', () => {
+        customTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    MODEL_ID: 'anthropic.claude-3-haiku-20240307-v1:0',
+                },
+            },
+        });
+    });
+    test('configures custom cross-region prefix', () => {
+        crossRegionTemplate.hasResourceProperties('AWS::Lambda::Function', {
+            Environment: {
+                Variables: {
+                    MODEL_ID: 'eu.anthropic.claude-3-7-sonnet-20250219-v1:0',
+                },
+            },
+        });
+    });
+    test('creates bedrock permissions', () => {
+        defaultTemplate.hasResourceProperties('AWS::IAM::Role', {
+            AssumeRolePolicyDocument: {
+                Statement: [{
+                        Action: 'sts:AssumeRole',
+                        Effect: 'Allow',
+                        Principal: { Service: 'lambda.amazonaws.com' },
+                    }],
+            },
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVkcm9jay1kb2N1bWVudC1wcm9jZXNzaW5nLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi91c2UtY2FzZXMvZG9jdW1lbnQtcHJvY2Vzc2luZy90ZXN0cy9iZWRyb2NrLWRvY3VtZW50LXByb2Nlc3NpbmcudGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLDZDQUFvQztBQUNwQyx1REFBa0Q7QUFDbEQseURBQW9FO0FBQ3BFLGdGQUE4RztBQUU5RyxRQUFRLENBQUMsMkJBQTJCLEVBQUUsR0FBRyxFQUFFO0lBQ3pDLElBQUksWUFBbUIsQ0FBQztJQUN4QixJQUFJLFdBQWtCLENBQUM7SUFDdkIsSUFBSSxnQkFBdUIsQ0FBQztJQUM1QixJQUFJLGVBQXlCLENBQUM7SUFDOUIsSUFBSSxjQUF3QixDQUFDO0lBQzdCLElBQUksbUJBQTZCLENBQUM7SUFFbEMsU0FBUyxDQUFDLEdBQUcsRUFBRTtRQUNiLHlDQUF5QztRQUN6QyxZQUFZLEdBQUcsSUFBSSxtQkFBSyxFQUFFLENBQUM7UUFDM0IsSUFBSSx1REFBeUIsQ0FBQyxZQUFZLEVBQUUsYUFBYSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRS9ELFdBQVcsR0FBRyxJQUFJLG1CQUFLLEVBQUUsQ0FBQztRQUMxQixJQUFJLHVEQUF5QixDQUFDLFdBQVcsRUFBRSxZQUFZLEVBQUU7WUFDdkQscUJBQXFCLEVBQUUsdUNBQXlCLENBQUMsc0NBQXNDO1lBQ3ZGLHVCQUF1QixFQUFFLEtBQUs7U0FDL0IsQ0FBQyxDQUFDO1FBRUgsZ0JBQWdCLEdBQUcsSUFBSSxtQkFBSyxFQUFFLENBQUM7UUFDL0IsSUFBSSx1REFBeUIsQ0FBQyxnQkFBZ0IsRUFBRSxpQkFBaUIsRUFBRTtZQUNqRSx1QkFBdUIsRUFBRSxJQUFJO1lBQzdCLDBCQUEwQixFQUFFLCtEQUFpQyxDQUFDLEVBQUU7U0FDakUsQ0FBQyxDQUFDO1FBRUgsMkRBQTJEO1FBQzNELGVBQWUsR0FBRyxxQkFBUSxDQUFDLFNBQVMsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUNuRCxjQUFjLEdBQUcscUJBQVEsQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDakQsbUJBQW1CLEdBQUcscUJBQVEsQ0FBQyxTQUFTLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUM3RCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQyw4QkFBOEIsRUFBRSxHQUFHLEVBQUU7UUFDeEMsZUFBZSxDQUFDLHFCQUFxQixDQUFDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQzdELGVBQWUsQ0FBQyxxQkFBcUIsQ0FBQyxpQkFBaUIsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUM3RCxlQUFlLENBQUMscUJBQXFCLENBQUMsc0JBQXNCLEVBQUUsRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyxDQUFDO1FBQ2xHLGVBQWUsQ0FBQyxxQkFBcUIsQ0FBQyxrQ0FBa0MsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUM5RSxlQUFlLENBQUMsZUFBZSxDQUFDLHVCQUF1QixFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzlELENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBSSxDQUFDLHNEQUFzRCxFQUFFLEdBQUcsRUFBRTtRQUNoRSxlQUFlLENBQUMscUJBQXFCLENBQUMsdUJBQXVCLEVBQUU7WUFDN0QsV0FBVyxFQUFFO2dCQUNYLFNBQVMsRUFBRTtvQkFDVCxRQUFRLEVBQUUsMkNBQTJDO2lCQUN0RDthQUNGO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsK0NBQStDLEVBQUUsR0FBRyxFQUFFO1FBQ3pELGNBQWMsQ0FBQyxxQkFBcUIsQ0FBQyx1QkFBdUIsRUFBRTtZQUM1RCxXQUFXLEVBQUU7Z0JBQ1gsU0FBUyxFQUFFO29CQUNULFFBQVEsRUFBRSx3Q0FBd0M7aUJBQ25EO2FBQ0Y7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQyx1Q0FBdUMsRUFBRSxHQUFHLEVBQUU7UUFDakQsbUJBQW1CLENBQUMscUJBQXFCLENBQUMsdUJBQXVCLEVBQUU7WUFDakUsV0FBVyxFQUFFO2dCQUNYLFNBQVMsRUFBRTtvQkFDVCxRQUFRLEVBQUUsOENBQThDO2lCQUN6RDthQUNGO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsNkJBQTZCLEVBQUUsR0FBRyxFQUFFO1FBQ3ZDLGVBQWUsQ0FBQyxxQkFBcUIsQ0FBQyxnQkFBZ0IsRUFBRTtZQUN0RCx3QkFBd0IsRUFBRTtnQkFDeEIsU0FBUyxFQUFFLENBQUM7d0JBQ1YsTUFBTSxFQUFFLGdCQUFnQjt3QkFDeEIsTUFBTSxFQUFFLE9BQU87d0JBQ2YsU0FBUyxFQUFFLEVBQUUsT0FBTyxFQUFFLHNCQUFzQixFQUFFO3FCQUMvQyxDQUFDO2FBQ0g7U0FDRixDQUFDLENBQUM7SUFDTCxDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3RhY2sgfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBUZW1wbGF0ZSB9IGZyb20gJ2F3cy1jZGstbGliL2Fzc2VydGlvbnMnO1xuaW1wb3J0IHsgRm91bmRhdGlvbk1vZGVsSWRlbnRpZmllciB9IGZyb20gJ2F3cy1jZGstbGliL2F3cy1iZWRyb2NrJztcbmltcG9ydCB7IEJlZHJvY2tDcm9zc1JlZ2lvbkluZmVyZW5jZVByZWZpeCwgQmVkcm9ja0RvY3VtZW50UHJvY2Vzc2luZyB9IGZyb20gJy4uL2JlZHJvY2stZG9jdW1lbnQtcHJvY2Vzc2luZyc7XG5cbmRlc2NyaWJlKCdCZWRyb2NrRG9jdW1lbnRQcm9jZXNzaW5nJywgKCkgPT4ge1xuICBsZXQgZGVmYXVsdFN0YWNrOiBTdGFjaztcbiAgbGV0IGN1c3RvbVN0YWNrOiBTdGFjaztcbiAgbGV0IGNyb3NzUmVnaW9uU3RhY2s6IFN0YWNrO1xuICBsZXQgZGVmYXVsdFRlbXBsYXRlOiBUZW1wbGF0ZTtcbiAgbGV0IGN1c3RvbVRlbXBsYXRlOiBUZW1wbGF0ZTtcbiAgbGV0IGNyb3NzUmVnaW9uVGVtcGxhdGU6IFRlbXBsYXRlO1xuXG4gIGJlZm9yZUFsbCgoKSA9PiB7XG4gICAgLy8gQ3JlYXRlIGFsbCBzdGFja3MgYW5kIGNvbnN0cnVjdHMgZmlyc3RcbiAgICBkZWZhdWx0U3RhY2sgPSBuZXcgU3RhY2soKTtcbiAgICBuZXcgQmVkcm9ja0RvY3VtZW50UHJvY2Vzc2luZyhkZWZhdWx0U3RhY2ssICdEZWZhdWx0VGVzdCcsIHt9KTtcblxuICAgIGN1c3RvbVN0YWNrID0gbmV3IFN0YWNrKCk7XG4gICAgbmV3IEJlZHJvY2tEb2N1bWVudFByb2Nlc3NpbmcoY3VzdG9tU3RhY2ssICdDdXN0b21UZXN0Jywge1xuICAgICAgY2xhc3NpZmljYXRpb25Nb2RlbElkOiBGb3VuZGF0aW9uTW9kZWxJZGVudGlmaWVyLkFOVEhST1BJQ19DTEFVREVfM19IQUlLVV8yMDI0MDMwN19WMV8wLFxuICAgICAgdXNlQ3Jvc3NSZWdpb25JbmZlcmVuY2U6IGZhbHNlLFxuICAgIH0pO1xuXG4gICAgY3Jvc3NSZWdpb25TdGFjayA9IG5ldyBTdGFjaygpO1xuICAgIG5ldyBCZWRyb2NrRG9jdW1lbnRQcm9jZXNzaW5nKGNyb3NzUmVnaW9uU3RhY2ssICdDcm9zc1JlZ2lvblRlc3QnLCB7XG4gICAgICB1c2VDcm9zc1JlZ2lvbkluZmVyZW5jZTogdHJ1ZSxcbiAgICAgIGNyb3NzUmVnaW9uSW5mZXJlbmNlUHJlZml4OiBCZWRyb2NrQ3Jvc3NSZWdpb25JbmZlcmVuY2VQcmVmaXguRVUsXG4gICAgfSk7XG5cbiAgICAvLyBHZW5lcmF0ZSB0ZW1wbGF0ZXMgb25jZSBhZnRlciBhbGwgY29uc3RydWN0cyBhcmUgY3JlYXRlZFxuICAgIGRlZmF1bHRUZW1wbGF0ZSA9IFRlbXBsYXRlLmZyb21TdGFjayhkZWZhdWx0U3RhY2spO1xuICAgIGN1c3RvbVRlbXBsYXRlID0gVGVtcGxhdGUuZnJvbVN0YWNrKGN1c3RvbVN0YWNrKTtcbiAgICBjcm9zc1JlZ2lvblRlbXBsYXRlID0gVGVtcGxhdGUuZnJvbVN0YWNrKGNyb3NzUmVnaW9uU3RhY2spO1xuICB9KTtcblxuICB0ZXN0KCdjcmVhdGVzIGJhc2ljIGluZnJhc3RydWN0dXJlJywgKCkgPT4ge1xuICAgIGRlZmF1bHRUZW1wbGF0ZS5oYXNSZXNvdXJjZVByb3BlcnRpZXMoJ0FXUzo6UzM6OkJ1Y2tldCcsIHt9KTtcbiAgICBkZWZhdWx0VGVtcGxhdGUuaGFzUmVzb3VyY2VQcm9wZXJ0aWVzKCdBV1M6OlNRUzo6UXVldWUnLCB7fSk7XG4gICAgZGVmYXVsdFRlbXBsYXRlLmhhc1Jlc291cmNlUHJvcGVydGllcygnQVdTOjpEeW5hbW9EQjo6VGFibGUnLCB7IEJpbGxpbmdNb2RlOiAnUEFZX1BFUl9SRVFVRVNUJyB9KTtcbiAgICBkZWZhdWx0VGVtcGxhdGUuaGFzUmVzb3VyY2VQcm9wZXJ0aWVzKCdBV1M6OlN0ZXBGdW5jdGlvbnM6OlN0YXRlTWFjaGluZScsIHt9KTtcbiAgICBkZWZhdWx0VGVtcGxhdGUucmVzb3VyY2VDb3VudElzKCdBV1M6OkxhbWJkYTo6RnVuY3Rpb24nLCA1KTtcbiAgfSk7XG5cbiAgdGVzdCgndXNlcyBkZWZhdWx0IG1vZGVsIHdpdGggY3Jvc3MtcmVnaW9uIHByZWZpeCBkaXNhYmxlZCcsICgpID0+IHtcbiAgICBkZWZhdWx0VGVtcGxhdGUuaGFzUmVzb3VyY2VQcm9wZXJ0aWVzKCdBV1M6OkxhbWJkYTo6RnVuY3Rpb24nLCB7XG4gICAgICBFbnZpcm9ubWVudDoge1xuICAgICAgICBWYXJpYWJsZXM6IHtcbiAgICAgICAgICBNT0RFTF9JRDogJ2FudGhyb3BpYy5jbGF1ZGUtMy03LXNvbm5ldC0yMDI1MDIxOS12MTowJyxcbiAgICAgICAgfSxcbiAgICAgIH0sXG4gICAgfSk7XG4gIH0pO1xuXG4gIHRlc3QoJ3VzZXMgY3VzdG9tIG1vZGVsIHdpdGhvdXQgY3Jvc3MtcmVnaW9uIHByZWZpeCcsICgpID0+IHtcbiAgICBjdXN0b21UZW1wbGF0ZS5oYXNSZXNvdXJjZVByb3BlcnRpZXMoJ0FXUzo6TGFtYmRhOjpGdW5jdGlvbicsIHtcbiAgICAgIEVudmlyb25tZW50OiB7XG4gICAgICAgIFZhcmlhYmxlczoge1xuICAgICAgICAgIE1PREVMX0lEOiAnYW50aHJvcGljLmNsYXVkZS0zLWhhaWt1LTIwMjQwMzA3LXYxOjAnLFxuICAgICAgICB9LFxuICAgICAgfSxcbiAgICB9KTtcbiAgfSk7XG5cbiAgdGVzdCgnY29uZmlndXJlcyBjdXN0b20gY3Jvc3MtcmVnaW9uIHByZWZpeCcsICgpID0+IHtcbiAgICBjcm9zc1JlZ2lvblRlbXBsYXRlLmhhc1Jlc291cmNlUHJvcGVydGllcygnQVdTOjpMYW1iZGE6OkZ1bmN0aW9uJywge1xuICAgICAgRW52aXJvbm1lbnQ6IHtcbiAgICAgICAgVmFyaWFibGVzOiB7XG4gICAgICAgICAgTU9ERUxfSUQ6ICdldS5hbnRocm9waWMuY2xhdWRlLTMtNy1zb25uZXQtMjAyNTAyMTktdjE6MCcsXG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgIH0pO1xuICB9KTtcblxuICB0ZXN0KCdjcmVhdGVzIGJlZHJvY2sgcGVybWlzc2lvbnMnLCAoKSA9PiB7XG4gICAgZGVmYXVsdFRlbXBsYXRlLmhhc1Jlc291cmNlUHJvcGVydGllcygnQVdTOjpJQU06OlJvbGUnLCB7XG4gICAgICBBc3N1bWVSb2xlUG9saWN5RG9jdW1lbnQ6IHtcbiAgICAgICAgU3RhdGVtZW50OiBbe1xuICAgICAgICAgIEFjdGlvbjogJ3N0czpBc3N1bWVSb2xlJyxcbiAgICAgICAgICBFZmZlY3Q6ICdBbGxvdycsXG4gICAgICAgICAgUHJpbmNpcGFsOiB7IFNlcnZpY2U6ICdsYW1iZGEuYW1hem9uYXdzLmNvbScgfSxcbiAgICAgICAgfV0sXG4gICAgICB9LFxuICAgIH0pO1xuICB9KTtcbn0pO1xuIl19

package/lib/framework/custom-resource/default-runtimes.d.ts

@@ -0,0 +1,21 @@
+import { BundlingOptions } from '@aws-cdk/aws-lambda-python-alpha';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+/**
+ * Contains default runtimes that would be referenced
+ * by Lambda functions in the various use cases. Updating of
+ * Runtime versions should be done here.
+ */
+export declare class DefaultRuntimes {
+    /**
+       * Default runtime for all Lambda functions in the use cases.
+       */
+    static readonly NODEJS: Runtime;
+    /**
+     * Default runtime for Python based Lambda functions.
+     */
+    static readonly PYTHON: Runtime;
+    /**
+     * Default bundling arguments for Python function
+     */
+    static readonly PYTHON_FUNCTION_BUNDLING: BundlingOptions;
+}

package/lib/framework/custom-resource/default-runtimes.js

@@ -0,0 +1,34 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRuntimes = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+/**
+ * Contains default runtimes that would be referenced
+ * by Lambda functions in the various use cases. Updating of
+ * Runtime versions should be done here.
+ */
+class DefaultRuntimes {
+}
+exports.DefaultRuntimes = DefaultRuntimes;
+_a = DefaultRuntimes, _b = JSII_RTTI_SYMBOL_1;
+DefaultRuntimes[_b] = { fqn: "@cdklabs/cdk-appmod-catalog-blueprints.DefaultRuntimes", version: "1.0.0" };
+/**
+   * Default runtime for all Lambda functions in the use cases.
+   */
+DefaultRuntimes.NODEJS = aws_lambda_1.Runtime.NODEJS_22_X;
+/**
+ * Default runtime for Python based Lambda functions.
+ */
+DefaultRuntimes.PYTHON = aws_lambda_1.Runtime.PYTHON_3_13;
+/**
+ * Default bundling arguments for Python function
+ */
+DefaultRuntimes.PYTHON_FUNCTION_BUNDLING = {
+    buildArgs: {
+        '--platform': 'linux/amd64',
+    },
+    image: _a.PYTHON.bundlingImage,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1ydW50aW1lcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3VzZS1jYXNlcy9mcmFtZXdvcmsvY3VzdG9tLXJlc291cmNlL2RlZmF1bHQtcnVudGltZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFHQSx1REFBaUQ7QUFFakQ7Ozs7R0FJRztBQUNILE1BQWEsZUFBZTs7QUFBNUIsMENBcUJDOzs7QUFuQkM7O0tBRUs7QUFDa0Isc0JBQU0sR0FBRyxvQkFBTyxDQUFDLFdBQVcsQUFBdEIsQ0FBdUI7QUFFcEQ7O0dBRUc7QUFDb0Isc0JBQU0sR0FBRyxvQkFBTyxDQUFDLFdBQVcsQUFBdEIsQ0FBdUI7QUFFcEQ7O0dBRUc7QUFDb0Isd0NBQXdCLEdBQW9CO0lBQ2pFLFNBQVMsRUFBRTtRQUNULFlBQVksRUFBRSxhQUFhO0tBQzVCO0lBQ0QsS0FBSyxFQUFFLEVBQUksQ0FBQyxNQUFNLENBQUMsYUFBYTtDQUNqQyxBQUw4QyxDQUs3QyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCBBbWF6b24uY29tLCBJbmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcbmltcG9ydCB7IEJ1bmRsaW5nT3B0aW9ucyB9IGZyb20gJ0Bhd3MtY2RrL2F3cy1sYW1iZGEtcHl0aG9uLWFscGhhJztcbmltcG9ydCB7IFJ1bnRpbWUgfSBmcm9tICdhd3MtY2RrLWxpYi9hd3MtbGFtYmRhJztcblxuLyoqXG4gKiBDb250YWlucyBkZWZhdWx0IHJ1bnRpbWVzIHRoYXQgd291bGQgYmUgcmVmZXJlbmNlZFxuICogYnkgTGFtYmRhIGZ1bmN0aW9ucyBpbiB0aGUgdmFyaW91cyB1c2UgY2FzZXMuIFVwZGF0aW5nIG9mXG4gKiBSdW50aW1lIHZlcnNpb25zIHNob3VsZCBiZSBkb25lIGhlcmUuXG4gKi9cbmV4cG9ydCBjbGFzcyBEZWZhdWx0UnVudGltZXMge1xuXG4gIC8qKlxuICAgICAqIERlZmF1bHQgcnVudGltZSBmb3IgYWxsIExhbWJkYSBmdW5jdGlvbnMgaW4gdGhlIHVzZSBjYXNlcy5cbiAgICAgKi9cbiAgcHVibGljIHN0YXRpYyByZWFkb25seSBOT0RFSlMgPSBSdW50aW1lLk5PREVKU18yMl9YO1xuXG4gIC8qKlxuICAgKiBEZWZhdWx0IHJ1bnRpbWUgZm9yIFB5dGhvbiBiYXNlZCBMYW1iZGEgZnVuY3Rpb25zLlxuICAgKi9cbiAgcHVibGljIHN0YXRpYyByZWFkb25seSBQWVRIT04gPSBSdW50aW1lLlBZVEhPTl8zXzEzO1xuXG4gIC8qKlxuICAgKiBEZWZhdWx0IGJ1bmRsaW5nIGFyZ3VtZW50cyBmb3IgUHl0aG9uIGZ1bmN0aW9uXG4gICAqL1xuICBwdWJsaWMgc3RhdGljIHJlYWRvbmx5IFBZVEhPTl9GVU5DVElPTl9CVU5ETElORzogQnVuZGxpbmdPcHRpb25zID0ge1xuICAgIGJ1aWxkQXJnczoge1xuICAgICAgJy0tcGxhdGZvcm0nOiAnbGludXgvYW1kNjQnLFxuICAgIH0sXG4gICAgaW1hZ2U6IHRoaXMuUFlUSE9OLmJ1bmRsaW5nSW1hZ2UsXG4gIH07XG59Il19

package/lib/framework/custom-resource/index.d.ts

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

package/lib/framework/custom-resource/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./default-runtimes"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi91c2UtY2FzZXMvZnJhbWV3b3JrL2N1c3RvbS1yZXNvdXJjZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEscURBQW1DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kZWZhdWx0LXJ1bnRpbWVzJzsiXX0=

package/lib/framework/foundation/access-log.d.ts

@@ -0,0 +1,69 @@
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+/**
+ * Configuration options for the AccessLog construct
+ */
+export interface AccessLogProps {
+    /**
+     * The name of the S3 bucket for access logs
+     * @default 'access-logs'
+     */
+    readonly bucketName?: string;
+    /**
+     * Lifecycle rules for the access logs
+     * @default Transition to IA after 30 days, delete after 90 days
+     */
+    readonly lifecycleRules?: s3.LifecycleRule[];
+    /**
+     * Whether to enable versioning on the access logs bucket
+     * @default false
+     */
+    readonly versioned?: boolean;
+    /**
+     * Custom bucket prefix for organizing access logs
+     * @default 'access-logs'
+     */
+    readonly bucketPrefix?: string;
+}
+/**
+ * AccessLog construct that provides a centralized S3 bucket for storing access logs.
+ * This construct creates a secure S3 bucket with appropriate policies for AWS services
+ * to deliver access logs.
+ *
+ * Usage:
+ *
+ * const accessLog = new AccessLog(this, 'AccessLog');
+ * const bucket = accessLog.bucket;
+ * const bucketName = accessLog.bucketName;
+ */
+export declare class AccessLog extends Construct {
+    /**
+     * The S3 bucket for storing access logs
+     */
+    readonly bucket: s3.Bucket;
+    /**
+     * The name of the S3 bucket
+     */
+    readonly bucketName: string;
+    /**
+     * The bucket prefix used for organizing access logs
+     */
+    readonly bucketPrefix: string;
+    constructor(scope: Construct, id: string, props?: AccessLogProps);
+    /**
+     * Get the S3 bucket path for a specific service's access logs
+     *
+     * @param serviceName The name of the service (e.g., 'alb', 'cloudfront', 's3')
+     * @param resourceName Optional resource name for further organization
+     * @returns The S3 path for the service's access logs
+     */
+    getLogPath(serviceName: string, resourceName?: string): string;
+    /**
+     * Get the S3 URI for a specific service's access logs
+     *
+     * @param serviceName The name of the service (e.g., 'alb', 'cloudfront', 's3')
+     * @param resourceName Optional resource name for further organization
+     * @returns The S3 URI for the service's access logs
+     */
+    getLogUri(serviceName: string, resourceName?: string): string;
+}