r'''
# AppMod Catalog Blueprints

> **Build customizable, well-architected applications on AWS in minutes, not months.**

[![GitHub](https://img.shields.io/badge/code-GitHub-green)](https://github.com/cdklabs/cdk-appmod-catalog-blueprints)
[![Construct Hub](https://img.shields.io/badge/construct--hub-cdklabs-orange)](https://constructs.dev/packages/@cdklabs/cdk-appmod-catalog-blueprints/)
[![Documentation](https://img.shields.io/badge/docs-cdklabs.github.io-blue)](https://cdklabs.github.io/cdk-appmod-catalog-blueprints/)
[![npm version](https://img.shields.io/npm/v/@cdklabs/cdk-appmod-catalog-blueprints?label=npm)](https://www.npmjs.com/package/@cdklabs/cdk-appmod-catalog-blueprints)
[![npm downloads](https://img.shields.io/npm/dt/@cdklabs/cdk-appmod-catalog-blueprints?label=npm%20downloads)](https://www.npmjs.com/package/@cdklabs/cdk-appmod-catalog-blueprints)
[![PyPI version](https://img.shields.io/pypi/v/appmod-catalog-blueprints?label=pypi)](https://pypi.org/project/appmod-catalog-blueprints/)
[![PyPI downloads](https://img.shields.io/pepy/dt/appmod-catalog-blueprints?label=pypi%20downloads)](https://pepy.tech/project/appmod-catalog-blueprints)
[![NuGet version](https://img.shields.io/nuget/v/CdklabsAppmodCatalogBlueprints?label=nuget)](https://www.nuget.org/packages/CdklabsAppmodCatalogBlueprints)
[![NuGet downloads](https://img.shields.io/nuget/dt/CdklabsAppmodCatalogBlueprints?label=nuget%20downloads)](https://www.nuget.org/packages/CdklabsAppmodCatalogBlueprints)
[![Maven version](https://img.shields.io/maven-central/v/io.github.cdklabs/appmod-catalog-blueprints?label=maven)](https://central.sonatype.com/artifact/io.github.cdklabs/appmod-catalog-blueprints)

Application Modernization (AppMod) Catalog Blueprints is a comprehensive library of **use case-driven infrastructure blueprints** and **industry-aligned solutions** built on AWS Well-Architected best practices. Designed as composable, multi-layered [AWS CDK](https://aws.amazon.com/cdk/) [L3 constructs](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html), these blueprints accelerate serverless development and modernization with multiple implementation pathways — from ready-to-deploy solutions to fully customizable building blocks.

**Why This Library?**

* **Use case-driven**: Purpose-built for real business problems — AI workflows, document processing, event-driven architectures, web applications
* **Multi-layered approach**: Infrastructure Foundation → General Use Cases → Industry Solutions — start with proven patterns, customize as needed
* **Composable architecture**: Mix and match independent components with standardized interfaces
* **Enterprise-ready security**: Built-in compliance, encryption, least-privilege IAM, and CDK Nag validation
* **Multi-language**: TypeScript, Python, Java, .NET via [JSII](https://aws.github.io/jsii/)

---


## Deploy in 3 Commands

Pick any solution from [the catalog below](#what-you-can-build) and deploy:

```bash
git clone https://github.com/cdklabs/cdk-appmod-catalog-blueprints.git
cd cdk-appmod-catalog-blueprints/examples/chatbot/customer-service-chatbot  # or any other example
npm install && npm run deploy
```

**That's it.** In this example, you now have a well-architected AI chatbot with streaming, authentication, and a React frontend. Swap the path for any other solution — fraud detection, document processing, RAG support, and more.

---


## Two Ways to Use This Library

| Approach | Best For | Get Started |
|----------|----------|-------------|
| **🚀 Deploy a Solution** | Quick evaluation, immediate value, proof-of-concepts | Pick from [ready-to-deploy solutions](#what-you-can-build) below — deploy in minutes with sensible defaults |
| **🔧 Build Custom** | Specific requirements, enterprise integration, tailored applications | Use [individual constructs](#building-blocks) — import into your CDK project, override defaults, inject custom logic |

---


## What You Can Build

### AI Chatbots & Assistants

| Solution | What It Does | Constructs Used |
|----------|--------------|-----------------|
| [**Customer Service Chatbot**](./examples/chatbot/customer-service-chatbot/) | Real-time chatbot with streaming and session management | [InteractiveAgent](./use-cases/framework/agents/), [Frontend](./use-cases/webapp/) |
| [**Retail Banking Chatbot**](./examples/chatbot/retail-banking-chatbot/) | Banking chatbot with RAG knowledge base and transaction lookup | [InteractiveAgent](./use-cases/framework/agents/), [BedrockKnowledgeBase](./use-cases/framework/agents/knowledge-base/), [Frontend](./use-cases/webapp/) |
| [**Retail Banking Chatbot (AgentCore)**](./examples/chatbot/retail-banking-chatbot-agentcore/) | High-availability banking bot on AgentCore Runtime | [InteractiveAgent](./use-cases/framework/agents/), [BedrockKnowledgeBase](./use-cases/framework/agents/knowledge-base/) |
| [**RAG Customer Support**](./examples/rag-customer-support/) | Knowledge-powered Q&A for e-commerce support | [BatchAgent](./use-cases/framework/agents/), [BedrockKnowledgeBase](./use-cases/framework/agents/knowledge-base/) |

### Intelligent Document Processing

| Solution | What It Does | Constructs Used |
|----------|--------------|-----------------|
| [**Insurance Claims Portal**](./examples/document-processing/doc-processing-fullstack-webapp/) | End-to-end claims processing with web UI | [AgenticDocumentProcessing](./use-cases/document-processing/), [Frontend](./use-cases/webapp/) |
| [**Fraud Detection**](./examples/document-processing/fraud-detection/) | AI-powered document fraud analysis with risk scoring | [AgenticDocumentProcessing](./use-cases/document-processing/) |
| [**Document Summarization**](./examples/document-processing/summarization-pipeline/) | Multi-format summarization with semantic search | [BedrockDocumentProcessing](./use-cases/document-processing/) |
| [**Agentic Document Processing**](./examples/document-processing/agentic-document-processing/) | Advanced document processing with AI reasoning | [AgenticDocumentProcessing](./use-cases/document-processing/) |
| [**Bedrock Document Processing**](./examples/document-processing/bedrock-document-processing/) | Document classification and extraction pipeline | [BedrockDocumentProcessing](./use-cases/document-processing/) |
| [**Minimal Document Processing**](./examples/document-processing/minimal-bedrock-doc-processing/) | Zero-config document processing starter | [BedrockDocumentProcessing](./use-cases/document-processing/) |

---


## Building Blocks

Use individual constructs to build custom applications:

```bash
npm install @cdklabs/cdk-appmod-catalog-blueprints
```

```python
import { InteractiveAgent } from '@cdklabs/cdk-appmod-catalog-blueprints';
import { Asset } from 'aws-cdk-lib/aws-s3-assets';

new InteractiveAgent(this, 'MyChatbot', {
  agentName: 'support-bot',
  agentDefinition: {
    bedrockModel: { useCrossRegionInference: true },
    systemPrompt: new Asset(this, 'Prompt', { path: './prompt.txt' }),
  },
});
```

### Available Constructs

| Construct | What It Does |
|-----------|--------------|
| [**InteractiveAgent**](./use-cases/framework/agents/) | Real-time chatbots with SSE streaming, sessions, and auth |
| [**BatchAgent**](./use-cases/framework/agents/) | Async AI processing for document analysis |
| [**BaseAgent**](./use-cases/framework/agents/) | Abstract base for custom agent implementations |
| [**AgenticDocumentProcessing**](./use-cases/document-processing/) | Document workflows with AI agents and tools |
| [**BedrockDocumentProcessing**](./use-cases/document-processing/) | Document classification and extraction |
| [**BaseDocumentProcessing**](./use-cases/document-processing/) | Abstract base for custom document processing |
| [**BedrockKnowledgeBase**](./use-cases/framework/agents/knowledge-base/) | RAG retrieval with access control |
| [**Frontend**](./use-cases/webapp/) | Static web hosting with CloudFront CDN |

### Foundation & Utilities

| Component | What It Does |
|-----------|--------------|
| [**Network**](./use-cases/framework/foundation/) | VPC with subnets and endpoints |
| [**Observability**](./use-cases/utilities/) | Logging, tracing, monitoring with Lambda Powertools |
| [**DataMasking**](./use-cases/utilities/) | PII protection Lambda layer |

---


## Architecture

### How It Works

```
┌─────────────────────────────────────────────────────────────────────┐
│                        Your Application                              │
├─────────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ │
│  │ Interactive │  │   Batch     │  │  Document   │  │   Frontend  │ │
│  │   Agent     │  │   Agent     │  │ Processing  │  │   (React)   │ │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘ │
├─────────┼────────────────┼────────────────┼────────────────┼────────┤
│         │                │                │                │        │
│  ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐ │
│  │  Bedrock    │  │    Step     │  │   Lambda    │  │ CloudFront  │ │
│  │  + Cognito  │  │  Functions  │  │   + S3      │  │   + S3      │ │
│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘ │
├─────────────────────────────────────────────────────────────────────┤
│                    Foundation (Network, Observability)               │
└─────────────────────────────────────────────────────────────────────┘
```

### Multi-Layered Design

The library uses a multi-layered architecture that bridges business requirements and technical implementation:

| Layer | What It Is | Purpose |
|-------|------------|---------|
| **Infrastructure Foundation** | Abstract base classes (`BaseAgent`, `BaseDocumentProcessing`) | Standardized interfaces and contracts — extend for custom implementations |
| **General Use Case Implementation** | Concrete classes (`InteractiveAgent`, `BedrockDocumentProcessing`) | Configurable implementations for common patterns — use directly or extend |
| **Industry-Aligned Solutions** | Deployable examples (`examples/`) | Pre-configured for specific domains (insurance, banking, e-commerce) — deploy as-is or use as reference |

### Composable Architecture

Build complex systems by combining independent, reusable components:

* **Independent components** with clear interfaces and loose coupling
* **Mix and match** constructs across different contexts and use cases
* **Pluggable strategies** for networking, observability, and event handling
* **Scalable composition** — incremental adoption and gradual modernization

---


## Getting Started

### Prerequisites

```bash
# Configure AWS credentials
aws configure
# OR: export AWS_PROFILE=your-profile-name

# Bootstrap CDK (one-time per account/region)
npx cdk bootstrap
```

### Option 1: Deploy a Solution

```bash
git clone https://github.com/cdklabs/cdk-appmod-catalog-blueprints.git
cd cdk-appmod-catalog-blueprints/examples/chatbot/customer-service-chatbot
npm install && npm run deploy
```

### Option 2: Use Constructs in Your Project

```bash
npm install @cdklabs/cdk-appmod-catalog-blueprints
```

```python
import { InteractiveAgent } from '@cdklabs/cdk-appmod-catalog-blueprints';
import { Asset } from 'aws-cdk-lib/aws-s3-assets';

new InteractiveAgent(this, 'MyChatbot', {
  agentName: 'my-bot',
  agentDefinition: {
    bedrockModel: { useCrossRegionInference: true },
    systemPrompt: new Asset(this, 'Prompt', { path: './prompt.txt' }),
  },
});
```

---


## Security & Compliance

All constructs include enterprise-grade security by default:

| Feature | What You Get |
|---------|--------------|
| **CDK Nag Integration** | Automated security compliance checking |
| **AWS Well-Architected** | Security, reliability, and performance best practices |
| **Encryption** | KMS at rest, TLS in transit — always on |
| **IAM** | Least-privilege, resource-scoped permissions |
| **Compliance Reports** | Generate with `npm test -- --testPathPattern="nag.test.ts"` |

---


## Documentation

* [**Website**](https://cdklabs.github.io/cdk-appmod-catalog-blueprints/) — Full documentation and guides
* [**Construct Hub**](https://constructs.dev/packages/@cdklabs/cdk-appmod-catalog-blueprints/) — API reference
* [**Examples**](./examples/) — Complete deployable solutions
* [**Building Blocks**](./use-cases/) — Individual construct documentation

---


## Contributing

We welcome contributions! See [CONTRIBUTING.md](https://github.com/cdklabs/cdk-appmod-catalog-blueprints/blob/main/CONTRIBUTING.md) for guidelines.

## Disclaimer

These solutions are examples to help you build applications, not supported products. Any applications you build should be thoroughly tested, secured, and optimized according to your security standards before production use.

## License

Apache License 2.0 — see [LICENSE](https://github.com/cdklabs/cdk-appmod-catalog-blueprints/blob/main/LICENSE) for details.
'''
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)

import abc
import builtins
import datetime
import enum
import typing

import jsii
import publication
import typing_extensions

import typeguard
from importlib.metadata import version as _metadata_package_version
TYPEGUARD_MAJOR_VERSION = int(_metadata_package_version('typeguard').split('.')[0])

def check_type(argname: str, value: object, expected_type: typing.Any) -> typing.Any:
    if TYPEGUARD_MAJOR_VERSION <= 2:
        return typeguard.check_type(argname=argname, value=value, expected_type=expected_type) # type:ignore
    else:
        if isinstance(value, jsii._reference_map.InterfaceDynamicProxy): # pyright: ignore [reportAttributeAccessIssue]
           pass
        else:
            if TYPEGUARD_MAJOR_VERSION == 3:
                typeguard.config.collection_check_strategy = typeguard.CollectionCheckStrategy.ALL_ITEMS # type:ignore
                typeguard.check_type(value=value, expected_type=expected_type) # type:ignore
            else:
                typeguard.check_type(value=value, expected_type=expected_type, collection_check_strategy=typeguard.CollectionCheckStrategy.ALL_ITEMS) # type:ignore

from ._jsii import *

import aws_cdk as _aws_cdk_ceddda9d
import aws_cdk.aws_apigateway as _aws_cdk_aws_apigateway_ceddda9d
import aws_cdk.aws_bedrock as _aws_cdk_aws_bedrock_ceddda9d
import aws_cdk.aws_bedrockagentcore as _aws_cdk_aws_bedrockagentcore_ceddda9d
import aws_cdk.aws_certificatemanager as _aws_cdk_aws_certificatemanager_ceddda9d
import aws_cdk.aws_cloudfront as _aws_cdk_aws_cloudfront_ceddda9d
import aws_cdk.aws_cloudwatch as _aws_cdk_aws_cloudwatch_ceddda9d
import aws_cdk.aws_cognito as _aws_cdk_aws_cognito_ceddda9d
import aws_cdk.aws_dynamodb as _aws_cdk_aws_dynamodb_ceddda9d
import aws_cdk.aws_ec2 as _aws_cdk_aws_ec2_ceddda9d
import aws_cdk.aws_events as _aws_cdk_aws_events_ceddda9d
import aws_cdk.aws_iam as _aws_cdk_aws_iam_ceddda9d
import aws_cdk.aws_kms as _aws_cdk_aws_kms_ceddda9d
import aws_cdk.aws_lambda as _aws_cdk_aws_lambda_ceddda9d
import aws_cdk.aws_lambda_python_alpha as _aws_cdk_aws_lambda_python_alpha_49328424
import aws_cdk.aws_logs as _aws_cdk_aws_logs_ceddda9d
import aws_cdk.aws_rds as _aws_cdk_aws_rds_ceddda9d
import aws_cdk.aws_route53 as _aws_cdk_aws_route53_ceddda9d
import aws_cdk.aws_s3 as _aws_cdk_aws_s3_ceddda9d
import aws_cdk.aws_s3_assets as _aws_cdk_aws_s3_assets_ceddda9d
import aws_cdk.aws_s3_deployment as _aws_cdk_aws_s3_deployment_ceddda9d
import aws_cdk.aws_secretsmanager as _aws_cdk_aws_secretsmanager_ceddda9d
import aws_cdk.aws_stepfunctions as _aws_cdk_aws_stepfunctions_ceddda9d
import aws_cdk.aws_stepfunctions_tasks as _aws_cdk_aws_stepfunctions_tasks_ceddda9d
import aws_cdk.custom_resources as _aws_cdk_custom_resources_ceddda9d
import constructs as _constructs_77d1e7e8


class AccessLog(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AccessLog",
):
    '''(experimental) 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;

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        bucket_name: typing.Optional[builtins.str] = None,
        bucket_prefix: typing.Optional[builtins.str] = None,
        lifecycle_rules: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_s3_ceddda9d.LifecycleRule", typing.Dict[builtins.str, typing.Any]]]] = None,
        versioned: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param bucket_name: (experimental) The name of the S3 bucket for access logs. Default: 'access-logs'
        :param bucket_prefix: (experimental) Custom bucket prefix for organizing access logs. Default: 'access-logs'
        :param lifecycle_rules: (experimental) Lifecycle rules for the access logs. Default: Transition to IA after 30 days, delete after 90 days
        :param versioned: (experimental) Whether to enable versioning on the access logs bucket. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d0c79880c62971c0b94c27211aa57e94a14b8b594133479abb3588b22b301cf7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = AccessLogProps(
            bucket_name=bucket_name,
            bucket_prefix=bucket_prefix,
            lifecycle_rules=lifecycle_rules,
            versioned=versioned,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="getLogPath")
    def get_log_path(
        self,
        service_name: builtins.str,
        resource_name: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Get the S3 bucket path for a specific service's access logs.

        :param service_name: The name of the service (e.g., 'alb', 'cloudfront', 's3').
        :param resource_name: Optional resource name for further organization.

        :return: The S3 path for the service's access logs

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__bb3bab7dfdf58893d762b8a3579b2e248b758bf8db791e3986df9451e32ada3e)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
            check_type(argname="argument resource_name", value=resource_name, expected_type=type_hints["resource_name"])
        return typing.cast(builtins.str, jsii.invoke(self, "getLogPath", [service_name, resource_name]))

    @jsii.member(jsii_name="getLogUri")
    def get_log_uri(
        self,
        service_name: builtins.str,
        resource_name: typing.Optional[builtins.str] = None,
    ) -> builtins.str:
        '''(experimental) Get the S3 URI for a specific service's access logs.

        :param service_name: The name of the service (e.g., 'alb', 'cloudfront', 's3').
        :param resource_name: Optional resource name for further organization.

        :return: The S3 URI for the service's access logs

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9988cc2b7efe7f7c7c17c94e465c36241770aa21cbe1b07c110b8e2dacedaf59)
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
            check_type(argname="argument resource_name", value=resource_name, expected_type=type_hints["resource_name"])
        return typing.cast(builtins.str, jsii.invoke(self, "getLogUri", [service_name, resource_name]))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> "_aws_cdk_aws_s3_ceddda9d.Bucket":
        '''(experimental) The S3 bucket for storing access logs.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_s3_ceddda9d.Bucket", jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="bucketName")
    def bucket_name(self) -> builtins.str:
        '''(experimental) The name of the S3 bucket.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "bucketName"))

    @builtins.property
    @jsii.member(jsii_name="bucketPrefix")
    def bucket_prefix(self) -> builtins.str:
        '''(experimental) The bucket prefix used for organizing access logs.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "bucketPrefix"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AccessLogProps",
    jsii_struct_bases=[],
    name_mapping={
        "bucket_name": "bucketName",
        "bucket_prefix": "bucketPrefix",
        "lifecycle_rules": "lifecycleRules",
        "versioned": "versioned",
    },
)
class AccessLogProps:
    def __init__(
        self,
        *,
        bucket_name: typing.Optional[builtins.str] = None,
        bucket_prefix: typing.Optional[builtins.str] = None,
        lifecycle_rules: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_s3_ceddda9d.LifecycleRule", typing.Dict[builtins.str, typing.Any]]]] = None,
        versioned: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Configuration options for the AccessLog construct.

        :param bucket_name: (experimental) The name of the S3 bucket for access logs. Default: 'access-logs'
        :param bucket_prefix: (experimental) Custom bucket prefix for organizing access logs. Default: 'access-logs'
        :param lifecycle_rules: (experimental) Lifecycle rules for the access logs. Default: Transition to IA after 30 days, delete after 90 days
        :param versioned: (experimental) Whether to enable versioning on the access logs bucket. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b0d5807bf69e9243b9fd452b7437cfe9f4102d78752673f223f3ae14073937e1)
            check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
            check_type(argname="argument bucket_prefix", value=bucket_prefix, expected_type=type_hints["bucket_prefix"])
            check_type(argname="argument lifecycle_rules", value=lifecycle_rules, expected_type=type_hints["lifecycle_rules"])
            check_type(argname="argument versioned", value=versioned, expected_type=type_hints["versioned"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if bucket_name is not None:
            self._values["bucket_name"] = bucket_name
        if bucket_prefix is not None:
            self._values["bucket_prefix"] = bucket_prefix
        if lifecycle_rules is not None:
            self._values["lifecycle_rules"] = lifecycle_rules
        if versioned is not None:
            self._values["versioned"] = versioned

    @builtins.property
    def bucket_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The name of the S3 bucket for access logs.

        :default: 'access-logs'

        :stability: experimental
        '''
        result = self._values.get("bucket_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def bucket_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom bucket prefix for organizing access logs.

        :default: 'access-logs'

        :stability: experimental
        '''
        result = self._values.get("bucket_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lifecycle_rules(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_s3_ceddda9d.LifecycleRule"]]:
        '''(experimental) Lifecycle rules for the access logs.

        :default: Transition to IA after 30 days, delete after 90 days

        :stability: experimental
        '''
        result = self._values.get("lifecycle_rules")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_s3_ceddda9d.LifecycleRule"]], result)

    @builtins.property
    def versioned(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to enable versioning on the access logs bucket.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("versioned")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AccessLogProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AclConfiguration",
    jsii_struct_bases=[],
    name_mapping={"enabled": "enabled", "metadata_field": "metadataField"},
)
class AclConfiguration:
    def __init__(
        self,
        *,
        enabled: builtins.bool,
        metadata_field: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Configuration for Access Control List (ACL) based filtering.

        When enabled, retrieval queries will be filtered based on user identity
        context, ensuring users only retrieve documents they have permission to access.

        :param enabled: (experimental) Enable ACL-based filtering for retrieval queries. When true, the retrieval tool will require user context and apply metadata filters based on user permissions. Default: false
        :param metadata_field: (experimental) Metadata field containing access permissions. This field in the document metadata should contain the group or permission identifier that controls access. The retrieval tool will filter results where this field matches the user's permissions. Default: 'group'

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__899807b7dca2d7be5f310df5984cd7a0c5fe3c612a8995f0927c15acbec703da)
            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            check_type(argname="argument metadata_field", value=metadata_field, expected_type=type_hints["metadata_field"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "enabled": enabled,
        }
        if metadata_field is not None:
            self._values["metadata_field"] = metadata_field

    @builtins.property
    def enabled(self) -> builtins.bool:
        '''(experimental) Enable ACL-based filtering for retrieval queries.

        When true, the retrieval tool will require user context and apply
        metadata filters based on user permissions.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enabled")
        assert result is not None, "Required property 'enabled' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def metadata_field(self) -> typing.Optional[builtins.str]:
        '''(experimental) Metadata field containing access permissions.

        This field in the document metadata should contain the group or
        permission identifier that controls access. The retrieval tool
        will filter results where this field matches the user's permissions.

        :default: 'group'

        :stability: experimental
        '''
        result = self._values.get("metadata_field")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AclConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AdditionalDistributionProps",
    jsii_struct_bases=[],
    name_mapping={
        "comment": "comment",
        "enabled": "enabled",
        "price_class": "priceClass",
        "web_acl_id": "webAclId",
    },
)
class AdditionalDistributionProps:
    def __init__(
        self,
        *,
        comment: typing.Optional[builtins.str] = None,
        enabled: typing.Optional[builtins.bool] = None,
        price_class: typing.Optional["_aws_cdk_aws_cloudfront_ceddda9d.PriceClass"] = None,
        web_acl_id: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Additional CloudFront distribution properties.

        :param comment: (experimental) Optional comment for the distribution.
        :param enabled: (experimental) Optional enabled flag for the distribution.
        :param price_class: (experimental) Optional price class for the distribution.
        :param web_acl_id: (experimental) Optional web ACL ID for the distribution.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__14d3ed5928e5166082cd47a907ab754473c20bb045dc424135b4690811543601)
            check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
            check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
            check_type(argname="argument price_class", value=price_class, expected_type=type_hints["price_class"])
            check_type(argname="argument web_acl_id", value=web_acl_id, expected_type=type_hints["web_acl_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if comment is not None:
            self._values["comment"] = comment
        if enabled is not None:
            self._values["enabled"] = enabled
        if price_class is not None:
            self._values["price_class"] = price_class
        if web_acl_id is not None:
            self._values["web_acl_id"] = web_acl_id

    @builtins.property
    def comment(self) -> typing.Optional[builtins.str]:
        '''(experimental) Optional comment for the distribution.

        :stability: experimental
        '''
        result = self._values.get("comment")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enabled(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Optional enabled flag for the distribution.

        :stability: experimental
        '''
        result = self._values.get("enabled")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def price_class(
        self,
    ) -> typing.Optional["_aws_cdk_aws_cloudfront_ceddda9d.PriceClass"]:
        '''(experimental) Optional price class for the distribution.

        :stability: experimental
        '''
        result = self._values.get("price_class")
        return typing.cast(typing.Optional["_aws_cdk_aws_cloudfront_ceddda9d.PriceClass"], result)

    @builtins.property
    def web_acl_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) Optional web ACL ID for the distribution.

        :stability: experimental
        '''
        result = self._values.get("web_acl_id")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AdditionalDistributionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentCoreJwtAuthorizerConfig",
    jsii_struct_bases=[],
    name_mapping={
        "discovery_url": "discoveryUrl",
        "allowed_audience": "allowedAudience",
        "allowed_clients": "allowedClients",
    },
)
class AgentCoreJwtAuthorizerConfig:
    def __init__(
        self,
        *,
        discovery_url: builtins.str,
        allowed_audience: typing.Optional[typing.Sequence[builtins.str]] = None,
        allowed_clients: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> None:
        '''(experimental) Custom JWT authorizer configuration for AgentCore Runtime.

        :param discovery_url: (experimental) OIDC discovery URL.
        :param allowed_audience: (experimental) Allowed audiences.
        :param allowed_clients: (experimental) Allowed client IDs.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f94f8a2948aa983ed72417fef6288dd7e6e44676ff9978b24bb098f0fdefe4c5)
            check_type(argname="argument discovery_url", value=discovery_url, expected_type=type_hints["discovery_url"])
            check_type(argname="argument allowed_audience", value=allowed_audience, expected_type=type_hints["allowed_audience"])
            check_type(argname="argument allowed_clients", value=allowed_clients, expected_type=type_hints["allowed_clients"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "discovery_url": discovery_url,
        }
        if allowed_audience is not None:
            self._values["allowed_audience"] = allowed_audience
        if allowed_clients is not None:
            self._values["allowed_clients"] = allowed_clients

    @builtins.property
    def discovery_url(self) -> builtins.str:
        '''(experimental) OIDC discovery URL.

        :stability: experimental
        '''
        result = self._values.get("discovery_url")
        assert result is not None, "Required property 'discovery_url' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def allowed_audience(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Allowed audiences.

        :stability: experimental
        '''
        result = self._values.get("allowed_audience")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    @builtins.property
    def allowed_clients(self) -> typing.Optional[typing.List[builtins.str]]:
        '''(experimental) Allowed client IDs.

        :stability: experimental
        '''
        result = self._values.get("allowed_clients")
        return typing.cast(typing.Optional[typing.List[builtins.str]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentCoreJwtAuthorizerConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentCoreRuntimeHostingAdapterProps",
    jsii_struct_bases=[],
    name_mapping={
        "container_image_uri": "containerImageUri",
        "custom_jwt_authorizer": "customJwtAuthorizer",
        "endpoint_name": "endpointName",
        "network_mode": "networkMode",
        "protocol_configuration": "protocolConfiguration",
    },
)
class AgentCoreRuntimeHostingAdapterProps:
    def __init__(
        self,
        *,
        container_image_uri: typing.Optional[builtins.str] = None,
        custom_jwt_authorizer: typing.Optional[typing.Union["AgentCoreJwtAuthorizerConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        endpoint_name: typing.Optional[builtins.str] = None,
        network_mode: typing.Optional[builtins.str] = None,
        protocol_configuration: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Configuration properties for AgentCoreRuntimeHostingAdapter.

        :param container_image_uri: (experimental) ECR container image URI. If not provided, builds from the bundled handler source. Default: Builds from agentcore-agent-handler directory
        :param custom_jwt_authorizer: (experimental) Custom JWT authorizer configuration. Omit for IAM-only auth.
        :param endpoint_name: (experimental) Runtime endpoint name. Default: Auto-generated from agent name
        :param network_mode: (experimental) Network mode: 'PUBLIC' or 'VPC'. Default: 'PUBLIC'
        :param protocol_configuration: (experimental) Protocol configuration: 'HTTP' | 'MCP' | 'A2A'. Default: 'HTTP'

        :stability: experimental
        '''
        if isinstance(custom_jwt_authorizer, dict):
            custom_jwt_authorizer = AgentCoreJwtAuthorizerConfig(**custom_jwt_authorizer)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb25afac88d833c132fd50b3235b65ddb59595d392340b28edd6ba7744888884)
            check_type(argname="argument container_image_uri", value=container_image_uri, expected_type=type_hints["container_image_uri"])
            check_type(argname="argument custom_jwt_authorizer", value=custom_jwt_authorizer, expected_type=type_hints["custom_jwt_authorizer"])
            check_type(argname="argument endpoint_name", value=endpoint_name, expected_type=type_hints["endpoint_name"])
            check_type(argname="argument network_mode", value=network_mode, expected_type=type_hints["network_mode"])
            check_type(argname="argument protocol_configuration", value=protocol_configuration, expected_type=type_hints["protocol_configuration"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if container_image_uri is not None:
            self._values["container_image_uri"] = container_image_uri
        if custom_jwt_authorizer is not None:
            self._values["custom_jwt_authorizer"] = custom_jwt_authorizer
        if endpoint_name is not None:
            self._values["endpoint_name"] = endpoint_name
        if network_mode is not None:
            self._values["network_mode"] = network_mode
        if protocol_configuration is not None:
            self._values["protocol_configuration"] = protocol_configuration

    @builtins.property
    def container_image_uri(self) -> typing.Optional[builtins.str]:
        '''(experimental) ECR container image URI.

        If not provided, builds from the bundled handler source.

        :default: Builds from agentcore-agent-handler directory

        :stability: experimental
        '''
        result = self._values.get("container_image_uri")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def custom_jwt_authorizer(self) -> typing.Optional["AgentCoreJwtAuthorizerConfig"]:
        '''(experimental) Custom JWT authorizer configuration.

        Omit for IAM-only auth.

        :stability: experimental
        '''
        result = self._values.get("custom_jwt_authorizer")
        return typing.cast(typing.Optional["AgentCoreJwtAuthorizerConfig"], result)

    @builtins.property
    def endpoint_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Runtime endpoint name.

        :default: Auto-generated from agent name

        :stability: experimental
        '''
        result = self._values.get("endpoint_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def network_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) Network mode: 'PUBLIC' or 'VPC'.

        :default: 'PUBLIC'

        :stability: experimental
        '''
        result = self._values.get("network_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def protocol_configuration(self) -> typing.Optional[builtins.str]:
        '''(experimental) Protocol configuration: 'HTTP' | 'MCP' | 'A2A'.

        :default: 'HTTP'

        :stability: experimental
        '''
        result = self._values.get("protocol_configuration")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentCoreRuntimeHostingAdapterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentDefinitionProps",
    jsii_struct_bases=[],
    name_mapping={
        "bedrock_model": "bedrockModel",
        "system_prompt": "systemPrompt",
        "additional_policy_statements_for_knowledge_bases": "additionalPolicyStatementsForKnowledgeBases",
        "additional_policy_statements_for_tools": "additionalPolicyStatementsForTools",
        "knowledge_bases": "knowledgeBases",
        "lambda_layers": "lambdaLayers",
        "tools": "tools",
    },
)
class AgentDefinitionProps:
    def __init__(
        self,
        *,
        bedrock_model: typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]],
        system_prompt: "_aws_cdk_aws_s3_assets_ceddda9d.Asset",
        additional_policy_statements_for_knowledge_bases: typing.Optional[typing.Sequence["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]] = None,
        additional_policy_statements_for_tools: typing.Optional[typing.Sequence["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]] = None,
        knowledge_bases: typing.Optional[typing.Sequence["IKnowledgeBase"]] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]] = None,
        tools: typing.Optional[typing.Sequence["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]] = None,
    ) -> None:
        '''(experimental) Parameters that influences the behavior of the agent.

        :param bedrock_model: (experimental) Configuration for the Bedrock Model to be used.
        :param system_prompt: (experimental) The system prompt of the agent.
        :param additional_policy_statements_for_knowledge_bases: (experimental) Additional IAM policy statements for knowledge base access. Use this when knowledge bases require permissions beyond what is automatically generated by the IKnowledgeBase implementations. These statements will be added to the agent's IAM role in addition to the auto-generated permissions. Default: - Only auto-generated permissions from knowledge bases
        :param additional_policy_statements_for_tools: (experimental) If tools need additional IAM permissions, these statements would be attached to the Agent's IAM role.
        :param knowledge_bases: (experimental) Knowledge bases available to the agent for Retrieval-Augmented Generation (RAG). When configured, the agent will have access to a built-in retrieval tool that can query these knowledge bases. The agent's system prompt will be automatically augmented with information about available knowledge bases. Each knowledge base must implement the IKnowledgeBase interface, which handles IAM permission generation and runtime configuration. Default: - No knowledge bases configured
        :param lambda_layers: (experimental) Any dependencies needed by the provided tools.
        :param tools: (experimental) List of tools defined in python files. This tools would automatically be loaded by the agent. You can also use this to incorporate other specialized agents as tools.

        :stability: experimental
        '''
        if isinstance(bedrock_model, dict):
            bedrock_model = BedrockModelProps(**bedrock_model)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4a2d1deab0cc9bf96473ffb32138a2c564c47ae7382fe5d2d1f0e43da3324272)
            check_type(argname="argument bedrock_model", value=bedrock_model, expected_type=type_hints["bedrock_model"])
            check_type(argname="argument system_prompt", value=system_prompt, expected_type=type_hints["system_prompt"])
            check_type(argname="argument additional_policy_statements_for_knowledge_bases", value=additional_policy_statements_for_knowledge_bases, expected_type=type_hints["additional_policy_statements_for_knowledge_bases"])
            check_type(argname="argument additional_policy_statements_for_tools", value=additional_policy_statements_for_tools, expected_type=type_hints["additional_policy_statements_for_tools"])
            check_type(argname="argument knowledge_bases", value=knowledge_bases, expected_type=type_hints["knowledge_bases"])
            check_type(argname="argument lambda_layers", value=lambda_layers, expected_type=type_hints["lambda_layers"])
            check_type(argname="argument tools", value=tools, expected_type=type_hints["tools"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bedrock_model": bedrock_model,
            "system_prompt": system_prompt,
        }
        if additional_policy_statements_for_knowledge_bases is not None:
            self._values["additional_policy_statements_for_knowledge_bases"] = additional_policy_statements_for_knowledge_bases
        if additional_policy_statements_for_tools is not None:
            self._values["additional_policy_statements_for_tools"] = additional_policy_statements_for_tools
        if knowledge_bases is not None:
            self._values["knowledge_bases"] = knowledge_bases
        if lambda_layers is not None:
            self._values["lambda_layers"] = lambda_layers
        if tools is not None:
            self._values["tools"] = tools

    @builtins.property
    def bedrock_model(self) -> "BedrockModelProps":
        '''(experimental) Configuration for the Bedrock Model to be used.

        :stability: experimental
        '''
        result = self._values.get("bedrock_model")
        assert result is not None, "Required property 'bedrock_model' is missing"
        return typing.cast("BedrockModelProps", result)

    @builtins.property
    def system_prompt(self) -> "_aws_cdk_aws_s3_assets_ceddda9d.Asset":
        '''(experimental) The system prompt of the agent.

        :stability: experimental
        '''
        result = self._values.get("system_prompt")
        assert result is not None, "Required property 'system_prompt' is missing"
        return typing.cast("_aws_cdk_aws_s3_assets_ceddda9d.Asset", result)

    @builtins.property
    def additional_policy_statements_for_knowledge_bases(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]]:
        '''(experimental) Additional IAM policy statements for knowledge base access.

        Use this when knowledge bases require permissions beyond what is
        automatically generated by the IKnowledgeBase implementations.
        These statements will be added to the agent's IAM role in addition
        to the auto-generated permissions.

        :default: - Only auto-generated permissions from knowledge bases

        :stability: experimental
        '''
        result = self._values.get("additional_policy_statements_for_knowledge_bases")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]], result)

    @builtins.property
    def additional_policy_statements_for_tools(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]]:
        '''(experimental) If tools need additional IAM permissions, these statements would be attached to the Agent's IAM role.

        :stability: experimental
        '''
        result = self._values.get("additional_policy_statements_for_tools")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]], result)

    @builtins.property
    def knowledge_bases(self) -> typing.Optional[typing.List["IKnowledgeBase"]]:
        '''(experimental) Knowledge bases available to the agent for Retrieval-Augmented Generation (RAG).

        When configured, the agent will have access to a built-in retrieval tool
        that can query these knowledge bases. The agent's system prompt will be
        automatically augmented with information about available knowledge bases.

        Each knowledge base must implement the IKnowledgeBase interface, which
        handles IAM permission generation and runtime configuration.

        :default: - No knowledge bases configured

        :stability: experimental
        '''
        result = self._values.get("knowledge_bases")
        return typing.cast(typing.Optional[typing.List["IKnowledgeBase"]], result)

    @builtins.property
    def lambda_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
        '''(experimental) Any dependencies needed by the provided tools.

        :stability: experimental
        '''
        result = self._values.get("lambda_layers")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]], result)

    @builtins.property
    def tools(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]]:
        '''(experimental) List of tools defined in python files.

        This tools would automatically
        be loaded by the agent. You can also use this to incorporate other specialized
        agents as tools.

        :stability: experimental
        '''
        result = self._values.get("tools")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentDefinitionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentHostingConfig",
    jsii_struct_bases=[],
    name_mapping={
        "agent_name": "agentName",
        "agent_role": "agentRole",
        "encryption_key": "encryptionKey",
        "environment": "environment",
        "scope": "scope",
        "system_prompt_bucket": "systemPromptBucket",
        "system_prompt_key": "systemPromptKey",
        "tools_config": "toolsConfig",
        "architecture": "architecture",
        "enable_observability": "enableObservability",
        "knowledge_base_configs": "knowledgeBaseConfigs",
        "knowledge_base_layers": "knowledgeBaseLayers",
        "knowledge_base_system_prompt_addition": "knowledgeBaseSystemPromptAddition",
        "lambda_layers": "lambdaLayers",
        "memory_size": "memorySize",
        "network": "network",
        "removal_policy": "removalPolicy",
        "reserved_concurrent_executions": "reservedConcurrentExecutions",
        "timeout": "timeout",
    },
)
class AgentHostingConfig:
    def __init__(
        self,
        *,
        agent_name: builtins.str,
        agent_role: "_aws_cdk_aws_iam_ceddda9d.Role",
        encryption_key: "_aws_cdk_aws_kms_ceddda9d.Key",
        environment: typing.Mapping[builtins.str, builtins.str],
        scope: "_constructs_77d1e7e8.Construct",
        system_prompt_bucket: builtins.str,
        system_prompt_key: builtins.str,
        tools_config: builtins.str,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        knowledge_base_configs: typing.Optional[builtins.str] = None,
        knowledge_base_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Configuration passed to a hosting adapter's deploy method.

        :param agent_name: (experimental) Agent name identifier.
        :param agent_role: (experimental) IAM role for the agent runtime.
        :param encryption_key: (experimental) KMS encryption key.
        :param environment: (experimental) Environment variables to set on the runtime.
        :param scope: (experimental) CDK scope for creating resources.
        :param system_prompt_bucket: (experimental) System prompt S3 bucket name.
        :param system_prompt_key: (experimental) System prompt S3 key.
        :param tools_config: (experimental) Agent tools location definitions (JSON serialized).
        :param architecture: (experimental) Lambda architecture (Lambda hosting only).
        :param enable_observability: (experimental) Whether observability is enabled.
        :param knowledge_base_configs: (experimental) Knowledge base configs (JSON serialized).
        :param knowledge_base_layers: (experimental) Lambda layers from knowledge bases (Lambda hosting only).
        :param knowledge_base_system_prompt_addition: (experimental) Knowledge base system prompt addition.
        :param lambda_layers: (experimental) Lambda layers from agent definition (Lambda hosting only).
        :param memory_size: (experimental) Lambda memory size in MB (Lambda hosting only).
        :param network: (experimental) Optional VPC network configuration.
        :param removal_policy: (experimental) Removal policy for resources.
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions (Lambda hosting only).
        :param timeout: (experimental) Lambda timeout (Lambda hosting only).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__813d39a5e98d744b41545d2dcb2ba7b3ff0536603077a6aa128c047f5b09da83)
            check_type(argname="argument agent_name", value=agent_name, expected_type=type_hints["agent_name"])
            check_type(argname="argument agent_role", value=agent_role, expected_type=type_hints["agent_role"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument system_prompt_bucket", value=system_prompt_bucket, expected_type=type_hints["system_prompt_bucket"])
            check_type(argname="argument system_prompt_key", value=system_prompt_key, expected_type=type_hints["system_prompt_key"])
            check_type(argname="argument tools_config", value=tools_config, expected_type=type_hints["tools_config"])
            check_type(argname="argument architecture", value=architecture, expected_type=type_hints["architecture"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument knowledge_base_configs", value=knowledge_base_configs, expected_type=type_hints["knowledge_base_configs"])
            check_type(argname="argument knowledge_base_layers", value=knowledge_base_layers, expected_type=type_hints["knowledge_base_layers"])
            check_type(argname="argument knowledge_base_system_prompt_addition", value=knowledge_base_system_prompt_addition, expected_type=type_hints["knowledge_base_system_prompt_addition"])
            check_type(argname="argument lambda_layers", value=lambda_layers, expected_type=type_hints["lambda_layers"])
            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument reserved_concurrent_executions", value=reserved_concurrent_executions, expected_type=type_hints["reserved_concurrent_executions"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "agent_name": agent_name,
            "agent_role": agent_role,
            "encryption_key": encryption_key,
            "environment": environment,
            "scope": scope,
            "system_prompt_bucket": system_prompt_bucket,
            "system_prompt_key": system_prompt_key,
            "tools_config": tools_config,
        }
        if architecture is not None:
            self._values["architecture"] = architecture
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if knowledge_base_configs is not None:
            self._values["knowledge_base_configs"] = knowledge_base_configs
        if knowledge_base_layers is not None:
            self._values["knowledge_base_layers"] = knowledge_base_layers
        if knowledge_base_system_prompt_addition is not None:
            self._values["knowledge_base_system_prompt_addition"] = knowledge_base_system_prompt_addition
        if lambda_layers is not None:
            self._values["lambda_layers"] = lambda_layers
        if memory_size is not None:
            self._values["memory_size"] = memory_size
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if reserved_concurrent_executions is not None:
            self._values["reserved_concurrent_executions"] = reserved_concurrent_executions
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def agent_name(self) -> builtins.str:
        '''(experimental) Agent name identifier.

        :stability: experimental
        '''
        result = self._values.get("agent_name")
        assert result is not None, "Required property 'agent_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent_role(self) -> "_aws_cdk_aws_iam_ceddda9d.Role":
        '''(experimental) IAM role for the agent runtime.

        :stability: experimental
        '''
        result = self._values.get("agent_role")
        assert result is not None, "Required property 'agent_role' is missing"
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.Role", result)

    @builtins.property
    def encryption_key(self) -> "_aws_cdk_aws_kms_ceddda9d.Key":
        '''(experimental) KMS encryption key.

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        assert result is not None, "Required property 'encryption_key' is missing"
        return typing.cast("_aws_cdk_aws_kms_ceddda9d.Key", result)

    @builtins.property
    def environment(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Environment variables to set on the runtime.

        :stability: experimental
        '''
        result = self._values.get("environment")
        assert result is not None, "Required property 'environment' is missing"
        return typing.cast(typing.Mapping[builtins.str, builtins.str], result)

    @builtins.property
    def scope(self) -> "_constructs_77d1e7e8.Construct":
        '''(experimental) CDK scope for creating resources.

        :stability: experimental
        '''
        result = self._values.get("scope")
        assert result is not None, "Required property 'scope' is missing"
        return typing.cast("_constructs_77d1e7e8.Construct", result)

    @builtins.property
    def system_prompt_bucket(self) -> builtins.str:
        '''(experimental) System prompt S3 bucket name.

        :stability: experimental
        '''
        result = self._values.get("system_prompt_bucket")
        assert result is not None, "Required property 'system_prompt_bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def system_prompt_key(self) -> builtins.str:
        '''(experimental) System prompt S3 key.

        :stability: experimental
        '''
        result = self._values.get("system_prompt_key")
        assert result is not None, "Required property 'system_prompt_key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def tools_config(self) -> builtins.str:
        '''(experimental) Agent tools location definitions (JSON serialized).

        :stability: experimental
        '''
        result = self._values.get("tools_config")
        assert result is not None, "Required property 'tools_config' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) Lambda architecture (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether observability is enabled.

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def knowledge_base_configs(self) -> typing.Optional[builtins.str]:
        '''(experimental) Knowledge base configs (JSON serialized).

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_configs")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def knowledge_base_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]]:
        '''(experimental) Lambda layers from knowledge bases (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_layers")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]], result)

    @builtins.property
    def knowledge_base_system_prompt_addition(self) -> typing.Optional[builtins.str]:
        '''(experimental) Knowledge base system prompt addition.

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_system_prompt_addition")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def lambda_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]]:
        '''(experimental) Lambda layers from agent definition (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("lambda_layers")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]], result)

    @builtins.property
    def memory_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Lambda memory size in MB (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("memory_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) Optional VPC network configuration.

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for resources.

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def reserved_concurrent_executions(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Reserved concurrent executions (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("reserved_concurrent_executions")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Lambda timeout (Lambda hosting only).

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentHostingConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentHostingResult",
    jsii_struct_bases=[],
    name_mapping={
        "endpoint": "endpoint",
        "agent_function": "agentFunction",
        "cfn_runtime": "cfnRuntime",
    },
)
class AgentHostingResult:
    def __init__(
        self,
        *,
        endpoint: builtins.str,
        agent_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"] = None,
        cfn_runtime: typing.Optional["_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime"] = None,
    ) -> None:
        '''(experimental) Result returned by a hosting adapter's deploy method.

        :param endpoint: (experimental) The agent endpoint URL or ARN.
        :param agent_function: (experimental) The Lambda function (if Lambda-hosted).
        :param cfn_runtime: (experimental) The AgentCore CfnRuntime (if AgentCore-hosted).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6e7a193ab7503b5bc22ec5155a0096d212a3a31a90893b3fc9b006d21caf8619)
            check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
            check_type(argname="argument agent_function", value=agent_function, expected_type=type_hints["agent_function"])
            check_type(argname="argument cfn_runtime", value=cfn_runtime, expected_type=type_hints["cfn_runtime"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "endpoint": endpoint,
        }
        if agent_function is not None:
            self._values["agent_function"] = agent_function
        if cfn_runtime is not None:
            self._values["cfn_runtime"] = cfn_runtime

    @builtins.property
    def endpoint(self) -> builtins.str:
        '''(experimental) The agent endpoint URL or ARN.

        :stability: experimental
        '''
        result = self._values.get("endpoint")
        assert result is not None, "Required property 'endpoint' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"]:
        '''(experimental) The Lambda function (if Lambda-hosted).

        :stability: experimental
        '''
        result = self._values.get("agent_function")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"], result)

    @builtins.property
    def cfn_runtime(
        self,
    ) -> typing.Optional["_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime"]:
        '''(experimental) The AgentCore CfnRuntime (if AgentCore-hosted).

        :stability: experimental
        '''
        result = self._values.get("cfn_runtime")
        return typing.cast(typing.Optional["_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentHostingResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentToolsLocationDefinition",
    jsii_struct_bases=[],
    name_mapping={
        "bucket_name": "bucketName",
        "is_file": "isFile",
        "is_zip_archive": "isZipArchive",
        "key": "key",
    },
)
class AgentToolsLocationDefinition:
    def __init__(
        self,
        *,
        bucket_name: builtins.str,
        is_file: builtins.bool,
        is_zip_archive: builtins.bool,
        key: builtins.str,
    ) -> None:
        '''
        :param bucket_name: 
        :param is_file: 
        :param is_zip_archive: 
        :param key: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__127edbe188000e5bd850f207a22867fb37ca32772d05138c8caeec887b302f84)
            check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
            check_type(argname="argument is_file", value=is_file, expected_type=type_hints["is_file"])
            check_type(argname="argument is_zip_archive", value=is_zip_archive, expected_type=type_hints["is_zip_archive"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket_name": bucket_name,
            "is_file": is_file,
            "is_zip_archive": is_zip_archive,
            "key": key,
        }

    @builtins.property
    def bucket_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("bucket_name")
        assert result is not None, "Required property 'bucket_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def is_file(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("is_file")
        assert result is not None, "Required property 'is_file' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def is_zip_archive(self) -> builtins.bool:
        '''
        :stability: experimental
        '''
        result = self._values.get("is_zip_archive")
        assert result is not None, "Required property 'is_zip_archive' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgentToolsLocationDefinition(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AggregatedResult",
    jsii_struct_bases=[],
    name_mapping={
        "chunks_summary": "chunksSummary",
        "classification": "classification",
        "classification_confidence": "classificationConfidence",
        "document_id": "documentId",
        "entities": "entities",
        "partial_result": "partialResult",
    },
)
class AggregatedResult:
    def __init__(
        self,
        *,
        chunks_summary: typing.Union["ChunksSummary", typing.Dict[builtins.str, typing.Any]],
        classification: builtins.str,
        classification_confidence: jsii.Number,
        document_id: builtins.str,
        entities: typing.Sequence[typing.Union["Entity", typing.Dict[builtins.str, typing.Any]]],
        partial_result: builtins.bool,
    ) -> None:
        '''(experimental) Aggregated result from processing all chunks.

        Combines classification and extraction results into final output.

        :param chunks_summary: (experimental) Summary of chunk processing results.
        :param classification: (experimental) Final document classification (from majority vote or other strategy).
        :param classification_confidence: (experimental) Confidence score for the classification (0-1). For majority vote: (count of majority / total chunks)
        :param document_id: (experimental) Document identifier.
        :param entities: (experimental) Deduplicated entities from all chunks. Entities without page numbers are deduplicated by (type, value). Entities with page numbers are preserved even if duplicated.
        :param partial_result: (experimental) Indicates if result is partial due to chunk failures. True if fewer than minSuccessThreshold chunks succeeded.

        :stability: experimental
        '''
        if isinstance(chunks_summary, dict):
            chunks_summary = ChunksSummary(**chunks_summary)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a3d00e6593683f5dec7ec3c48b2f42490178605c9014ef127d0b29e509121357)
            check_type(argname="argument chunks_summary", value=chunks_summary, expected_type=type_hints["chunks_summary"])
            check_type(argname="argument classification", value=classification, expected_type=type_hints["classification"])
            check_type(argname="argument classification_confidence", value=classification_confidence, expected_type=type_hints["classification_confidence"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument entities", value=entities, expected_type=type_hints["entities"])
            check_type(argname="argument partial_result", value=partial_result, expected_type=type_hints["partial_result"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "chunks_summary": chunks_summary,
            "classification": classification,
            "classification_confidence": classification_confidence,
            "document_id": document_id,
            "entities": entities,
            "partial_result": partial_result,
        }

    @builtins.property
    def chunks_summary(self) -> "ChunksSummary":
        '''(experimental) Summary of chunk processing results.

        :stability: experimental
        '''
        result = self._values.get("chunks_summary")
        assert result is not None, "Required property 'chunks_summary' is missing"
        return typing.cast("ChunksSummary", result)

    @builtins.property
    def classification(self) -> builtins.str:
        '''(experimental) Final document classification (from majority vote or other strategy).

        :stability: experimental
        '''
        result = self._values.get("classification")
        assert result is not None, "Required property 'classification' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def classification_confidence(self) -> jsii.Number:
        '''(experimental) Confidence score for the classification (0-1).

        For majority vote: (count of majority / total chunks)

        :stability: experimental
        '''
        result = self._values.get("classification_confidence")
        assert result is not None, "Required property 'classification_confidence' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def entities(self) -> typing.List["Entity"]:
        '''(experimental) Deduplicated entities from all chunks.

        Entities without page numbers are deduplicated by (type, value).
        Entities with page numbers are preserved even if duplicated.

        :stability: experimental
        '''
        result = self._values.get("entities")
        assert result is not None, "Required property 'entities' is missing"
        return typing.cast(typing.List["Entity"], result)

    @builtins.property
    def partial_result(self) -> builtins.bool:
        '''(experimental) Indicates if result is partial due to chunk failures.

        True if fewer than minSuccessThreshold chunks succeeded.

        :stability: experimental
        '''
        result = self._values.get("partial_result")
        assert result is not None, "Required property 'partial_result' is missing"
        return typing.cast(builtins.bool, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AggregatedResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AggregationRequest",
    jsii_struct_bases=[],
    name_mapping={
        "chunk_results": "chunkResults",
        "document_id": "documentId",
        "aggregation_strategy": "aggregationStrategy",
    },
)
class AggregationRequest:
    def __init__(
        self,
        *,
        chunk_results: typing.Sequence[typing.Union["ChunkResult", typing.Dict[builtins.str, typing.Any]]],
        document_id: builtins.str,
        aggregation_strategy: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Request payload for aggregation Lambda.

        Contains results from all processed chunks.

        :param chunk_results: (experimental) Results from all processed chunks.
        :param document_id: (experimental) Document identifier.
        :param aggregation_strategy: (experimental) Strategy to use for aggregation. Default: 'majority-vote'

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__500ce1d863484da9d361c48793d43ddb7af599b17ddd5d5bbe06cd62611c965f)
            check_type(argname="argument chunk_results", value=chunk_results, expected_type=type_hints["chunk_results"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument aggregation_strategy", value=aggregation_strategy, expected_type=type_hints["aggregation_strategy"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "chunk_results": chunk_results,
            "document_id": document_id,
        }
        if aggregation_strategy is not None:
            self._values["aggregation_strategy"] = aggregation_strategy

    @builtins.property
    def chunk_results(self) -> typing.List["ChunkResult"]:
        '''(experimental) Results from all processed chunks.

        :stability: experimental
        '''
        result = self._values.get("chunk_results")
        assert result is not None, "Required property 'chunk_results' is missing"
        return typing.cast(typing.List["ChunkResult"], result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def aggregation_strategy(self) -> typing.Optional[builtins.str]:
        '''(experimental) Strategy to use for aggregation.

        :default: 'majority-vote'

        :stability: experimental
        '''
        result = self._values.get("aggregation_strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AggregationRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BaseAgent(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseAgent",
):
    '''(experimental) Base class for all agent types in the framework.

    Provides common infrastructure for AI agents including:

    - IAM role and permissions management
    - Encryption key for environment variables
    - Tool integration and S3 asset management
    - Knowledge base integration for RAG (Retrieval-Augmented Generation)
    - Observability configuration (Lambda Powertools + AgentCore)

    Subclasses must implement the agent-specific Lambda function creation.

    **Observability**: When ``enableObservability: true``, BaseAgent configures both
    Lambda Powertools (function-level) and AWS Bedrock AgentCore (agent-level)
    observability. Both systems work together to provide complete visibility:

    - Lambda Powertools captures function execution, logs, and custom metrics
    - AgentCore captures agent reasoning, tool usage, and token consumption
    - Both publish to CloudWatch with correlated service names for unified monitoring

    The observability integration includes:

    - Automatic IAM permission grants for CloudWatch Logs and X-Ray
    - Environment variable configuration for OpenTelemetry
    - ADOT Lambda Layer attachment (handled by concrete implementations)

    :see: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71b734ed2750632299f59fd7513ccde0ee5f9974b68f8c52b53e2255cdee86ff)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BaseAgentProps(
            agent_definition=agent_definition,
            agent_name=agent_name,
            agent_architecture=agent_architecture,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            network=network,
            removal_policy=removal_policy,
            service_principal=service_principal,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="createADOTLayer")
    def _create_adot_layer(self) -> "_aws_cdk_aws_lambda_ceddda9d.ILayerVersion":
        '''(experimental) Creates the AWS Distro for OpenTelemetry (ADOT) Lambda Layer.

        The ADOT layer provides automatic instrumentation for observability.
        Layer versions vary by region - some regions have newer versions with
        better Python 3.13 support. If you encounter compatibility issues,
        the layer ARNs can be found at:
        https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns

        :return: The ADOT Lambda Layer for the current region

        :stability: experimental
        :throws: Error if the region is not supported
        '''
        return typing.cast("_aws_cdk_aws_lambda_ceddda9d.ILayerVersion", jsii.invoke(self, "createADOTLayer", []))

    @builtins.property
    @jsii.member(jsii_name="agentRole")
    def agent_role(self) -> "_aws_cdk_aws_iam_ceddda9d.Role":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.Role", jsii.get(self, "agentRole"))

    @builtins.property
    @jsii.member(jsii_name="agentToolsLocationDefinitions")
    def _agent_tools_location_definitions(
        self,
    ) -> typing.List["AgentToolsLocationDefinition"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List["AgentToolsLocationDefinition"], jsii.get(self, "agentToolsLocationDefinitions"))

    @builtins.property
    @jsii.member(jsii_name="encryptionKey")
    def encryption_key(self) -> "_aws_cdk_aws_kms_ceddda9d.Key":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_kms_ceddda9d.Key", jsii.get(self, "encryptionKey"))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseConfigs")
    def _knowledge_base_configs(self) -> typing.List["KnowledgeBaseRuntimeConfig"]:
        '''(experimental) Knowledge base configurations for runtime use.

        This array contains the exported configurations from all configured
        knowledge bases. Subclasses use this to set the KNOWLEDGE_BASES_CONFIG
        environment variable on the agent Lambda function.

        :stability: experimental
        '''
        return typing.cast(typing.List["KnowledgeBaseRuntimeConfig"], jsii.get(self, "knowledgeBaseConfigs"))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseLayers")
    def _knowledge_base_layers(
        self,
    ) -> typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]:
        '''(experimental) Lambda layers required by knowledge base retrieval tools.

        This array contains Lambda layers from all configured knowledge bases.
        Subclasses should add these layers to the agent Lambda function to
        ensure retrieval tools have access to required dependencies.

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"], jsii.get(self, "knowledgeBaseLayers"))

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def _log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''(experimental) log group data protection configuration.

        :stability: experimental
        '''
        return typing.cast("LogGroupDataProtectionProps", jsii.get(self, "logGroupDataProtection"))

    @builtins.property
    @jsii.member(jsii_name="agentFunction")
    @abc.abstractmethod
    def agent_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"]:
        '''(experimental) The Lambda function for the agent (when using Lambda hosting).

        May be undefined for non-Lambda hosting backends (e.g. AgentCore Runtime).

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="bedrockModel")
    def bedrock_model(self) -> typing.Optional["BedrockModelProps"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["BedrockModelProps"], jsii.get(self, "bedrockModel"))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseToolAsset")
    def _knowledge_base_tool_asset(
        self,
    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
        '''(experimental) Asset containing the knowledge base retrieval tool.

        This is automatically created when knowledge bases are configured.
        The asset is added to the agent's tools and granted read access.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.get(self, "knowledgeBaseToolAsset"))


class _BaseAgentProxy(BaseAgent):
    @builtins.property
    @jsii.member(jsii_name="agentFunction")
    def agent_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"]:
        '''(experimental) The Lambda function for the agent (when using Lambda hosting).

        May be undefined for non-Lambda hosting backends (e.g. AgentCore Runtime).

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"], jsii.get(self, "agentFunction"))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, BaseAgent).__jsii_proxy_class__ = lambda : _BaseAgentProxy


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBaseProps",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "name": "name",
        "acl": "acl",
        "retrieval": "retrieval",
    },
)
class BaseKnowledgeBaseProps:
    def __init__(
        self,
        *,
        description: builtins.str,
        name: builtins.str,
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Base configuration for all knowledge base implementations.

        This interface defines the common properties shared by all knowledge
        base types. Specific implementations (like BedrockKnowledgeBase) extend
        this with additional properties.

        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }

        :stability: experimental
        '''
        if isinstance(acl, dict):
            acl = AclConfiguration(**acl)
        if isinstance(retrieval, dict):
            retrieval = RetrievalConfiguration(**retrieval)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__40fa4a59f1a0502756f07aba8d6cba5255e1743cbc160af92ff68cb3b17fef23)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "description": description,
            "name": name,
        }
        if acl is not None:
            self._values["acl"] = acl
        if retrieval is not None:
            self._values["retrieval"] = retrieval

    @builtins.property
    def description(self) -> builtins.str:
        '''(experimental) Description of what this knowledge base contains and when to use it.

        This description is shown to the agent in its system prompt to help
        it decide when to query this knowledge base. Be specific about the
        type of information contained and appropriate use cases.

        :stability: experimental

        Example::

            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
        '''
        result = self._values.get("description")
        assert result is not None, "Required property 'description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name/identifier for this knowledge base.

        Used for logging, display purposes, and to help the agent identify
        which knowledge base to query. Should be unique within the set of
        knowledge bases configured for an agent.

        :stability: experimental

        Example::

            'product-documentation'
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def acl(self) -> typing.Optional["AclConfiguration"]:
        '''(experimental) Access control configuration for identity-aware retrieval.

        When enabled, retrieval queries will be filtered based on user
        identity context to ensure users only access permitted documents.

        :default: - ACL disabled

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional["AclConfiguration"], result)

    @builtins.property
    def retrieval(self) -> typing.Optional["RetrievalConfiguration"]:
        '''(experimental) Retrieval configuration options.

        Controls the number of results returned and optional metadata filtering.

        :default: { numberOfResults: 5 }

        :stability: experimental
        '''
        result = self._values.get("retrieval")
        return typing.cast(typing.Optional["RetrievalConfiguration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseKnowledgeBaseProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BatchAgent(
    BaseAgent,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BatchAgent",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        prompt: builtins.str,
        expect_json: typing.Optional[builtins.bool] = None,
        invoke_type: typing.Optional["InvokeType"] = None,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param prompt: 
        :param expect_json: 
        :param invoke_type: (experimental) Agent invocation type. Defines how the agent is invoked and what processing mode to use. Default: InvokeType.BATCH
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2677306b18b77c5114d824ae734b83ac837c5ea4a5b8805948f0388f1dd7995)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BatchAgentProps(
            prompt=prompt,
            expect_json=expect_json,
            invoke_type=invoke_type,
            agent_definition=agent_definition,
            agent_name=agent_name,
            agent_architecture=agent_architecture,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            network=network,
            removal_policy=removal_policy,
            service_principal=service_principal,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="agentFunction")
    def agent_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"]:
        '''(experimental) The Lambda function for the agent (when using Lambda hosting).

        May be undefined for non-Lambda hosting backends (e.g. AgentCore Runtime).

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"], jsii.get(self, "agentFunction"))


@jsii.enum(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockCrossRegionInferencePrefix"
)
class BedrockCrossRegionInferencePrefix(enum.Enum):
    '''(experimental) Cross-region inference prefix options for Bedrock models.

    Used to configure inference profiles for improved availability and performance.

    :stability: experimental
    '''

    US = "US"
    '''(experimental) US-based cross-region inference profile.

    :stability: experimental
    '''
    EU = "EU"
    '''(experimental) EU-based cross-region inference profile.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBaseProps",
    jsii_struct_bases=[BaseKnowledgeBaseProps],
    name_mapping={
        "description": "description",
        "name": "name",
        "acl": "acl",
        "retrieval": "retrieval",
        "knowledge_base_id": "knowledgeBaseId",
        "create": "create",
        "guardrail": "guardrail",
        "knowledge_base_arn": "knowledgeBaseArn",
        "vector_store": "vectorStore",
    },
)
class BedrockKnowledgeBaseProps(BaseKnowledgeBaseProps):
    def __init__(
        self,
        *,
        description: builtins.str,
        name: builtins.str,
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        knowledge_base_id: builtins.str,
        create: typing.Optional[typing.Union["CreateKnowledgeBaseConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        knowledge_base_arn: typing.Optional[builtins.str] = None,
        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Configuration for Amazon Bedrock Knowledge Base.

        This interface extends the base configuration with Bedrock-specific
        properties for connecting to an existing Bedrock Knowledge Base.

        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }
        :param knowledge_base_id: (experimental) Unique identifier for the Bedrock Knowledge Base. This is the ID assigned by Bedrock when the knowledge base was created. You can find this in the Bedrock console or via the AWS CLI. Required when referencing an existing knowledge base. Not required when using the ``create`` property to create a new KB.
        :param create: (experimental) Configuration for creating a new knowledge base. When provided, a new Bedrock Knowledge Base will be created with the specified data source and embedding configuration. Note: This is an advanced feature that creates AWS resources. For most use cases, referencing an existing knowledge base by ID is recommended. Default: - Reference existing KB only (no creation)
        :param guardrail: (experimental) Guardrail configuration for content filtering. When configured, the guardrail will be applied during retrieval operations to filter inappropriate or sensitive content. Default: - No guardrail applied
        :param knowledge_base_arn: (experimental) ARN of the Bedrock Knowledge Base. If not provided, the ARN will be constructed from the knowledgeBaseId using the current region and account. Default: - Constructed from knowledgeBaseId
        :param vector_store: (experimental) Vector store configuration. Defines the type of vector store used by this knowledge base. This is informational and used for generating appropriate IAM permissions when needed. Default: - S3 Vectors (type: 's3-vectors')

        :stability: experimental
        '''
        if isinstance(acl, dict):
            acl = AclConfiguration(**acl)
        if isinstance(retrieval, dict):
            retrieval = RetrievalConfiguration(**retrieval)
        if isinstance(create, dict):
            create = CreateKnowledgeBaseConfiguration(**create)
        if isinstance(guardrail, dict):
            guardrail = GuardrailConfiguration(**guardrail)
        if isinstance(vector_store, dict):
            vector_store = VectorStoreConfiguration(**vector_store)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fa5a5937a282e8ddfa91598805b072febd3483c7f6ad9ed8eed9f52e4f0912e9)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
            check_type(argname="argument knowledge_base_id", value=knowledge_base_id, expected_type=type_hints["knowledge_base_id"])
            check_type(argname="argument create", value=create, expected_type=type_hints["create"])
            check_type(argname="argument guardrail", value=guardrail, expected_type=type_hints["guardrail"])
            check_type(argname="argument knowledge_base_arn", value=knowledge_base_arn, expected_type=type_hints["knowledge_base_arn"])
            check_type(argname="argument vector_store", value=vector_store, expected_type=type_hints["vector_store"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "description": description,
            "name": name,
            "knowledge_base_id": knowledge_base_id,
        }
        if acl is not None:
            self._values["acl"] = acl
        if retrieval is not None:
            self._values["retrieval"] = retrieval
        if create is not None:
            self._values["create"] = create
        if guardrail is not None:
            self._values["guardrail"] = guardrail
        if knowledge_base_arn is not None:
            self._values["knowledge_base_arn"] = knowledge_base_arn
        if vector_store is not None:
            self._values["vector_store"] = vector_store

    @builtins.property
    def description(self) -> builtins.str:
        '''(experimental) Description of what this knowledge base contains and when to use it.

        This description is shown to the agent in its system prompt to help
        it decide when to query this knowledge base. Be specific about the
        type of information contained and appropriate use cases.

        :stability: experimental

        Example::

            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
        '''
        result = self._values.get("description")
        assert result is not None, "Required property 'description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name/identifier for this knowledge base.

        Used for logging, display purposes, and to help the agent identify
        which knowledge base to query. Should be unique within the set of
        knowledge bases configured for an agent.

        :stability: experimental

        Example::

            'product-documentation'
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def acl(self) -> typing.Optional["AclConfiguration"]:
        '''(experimental) Access control configuration for identity-aware retrieval.

        When enabled, retrieval queries will be filtered based on user
        identity context to ensure users only access permitted documents.

        :default: - ACL disabled

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional["AclConfiguration"], result)

    @builtins.property
    def retrieval(self) -> typing.Optional["RetrievalConfiguration"]:
        '''(experimental) Retrieval configuration options.

        Controls the number of results returned and optional metadata filtering.

        :default: { numberOfResults: 5 }

        :stability: experimental
        '''
        result = self._values.get("retrieval")
        return typing.cast(typing.Optional["RetrievalConfiguration"], result)

    @builtins.property
    def knowledge_base_id(self) -> builtins.str:
        '''(experimental) Unique identifier for the Bedrock Knowledge Base.

        This is the ID assigned by Bedrock when the knowledge base was created.
        You can find this in the Bedrock console or via the AWS CLI.

        Required when referencing an existing knowledge base.
        Not required when using the ``create`` property to create a new KB.

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_id")
        assert result is not None, "Required property 'knowledge_base_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def create(self) -> typing.Optional["CreateKnowledgeBaseConfiguration"]:
        '''(experimental) Configuration for creating a new knowledge base.

        When provided, a new Bedrock Knowledge Base will be created with
        the specified data source and embedding configuration.

        Note: This is an advanced feature that creates AWS resources.
        For most use cases, referencing an existing knowledge base by ID
        is recommended.

        :default: - Reference existing KB only (no creation)

        :stability: experimental
        '''
        result = self._values.get("create")
        return typing.cast(typing.Optional["CreateKnowledgeBaseConfiguration"], result)

    @builtins.property
    def guardrail(self) -> typing.Optional["GuardrailConfiguration"]:
        '''(experimental) Guardrail configuration for content filtering.

        When configured, the guardrail will be applied during retrieval
        operations to filter inappropriate or sensitive content.

        :default: - No guardrail applied

        :stability: experimental
        '''
        result = self._values.get("guardrail")
        return typing.cast(typing.Optional["GuardrailConfiguration"], result)

    @builtins.property
    def knowledge_base_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) ARN of the Bedrock Knowledge Base.

        If not provided, the ARN will be constructed from the knowledgeBaseId
        using the current region and account.

        :default: - Constructed from knowledgeBaseId

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vector_store(self) -> typing.Optional["VectorStoreConfiguration"]:
        '''(experimental) Vector store configuration.

        Defines the type of vector store used by this knowledge base.
        This is informational and used for generating appropriate IAM
        permissions when needed.

        :default: - S3 Vectors (type: 's3-vectors')

        :stability: experimental
        '''
        result = self._values.get("vector_store")
        return typing.cast(typing.Optional["VectorStoreConfiguration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BedrockKnowledgeBaseProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockModelProps",
    jsii_struct_bases=[],
    name_mapping={
        "cross_region_inference_prefix": "crossRegionInferencePrefix",
        "fm_model_id": "fmModelId",
        "use_cross_region_inference": "useCrossRegionInference",
    },
)
class BedrockModelProps:
    def __init__(
        self,
        *,
        cross_region_inference_prefix: typing.Optional["BedrockCrossRegionInferencePrefix"] = None,
        fm_model_id: typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"] = None,
        use_cross_region_inference: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''
        :param cross_region_inference_prefix: (experimental) Prefix for cross-region inference configuration. Only used when useCrossRegionInference is true. Default: BedrockCrossRegionInferencePrefix.US
        :param fm_model_id: (experimental) Foundation model to use. Default: FoundationModelIdentifier.ANTHROPIC_CLAUDE_SONNET_4_20250514_V1_0
        :param use_cross_region_inference: (experimental) Enable cross-region inference for Bedrock models to improve availability and performance. When enabled, uses inference profiles instead of direct model invocation. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e45242c855c6631d66b287b02966cc10c7006e63b282779a6fdb35ce0a2a7a67)
            check_type(argname="argument cross_region_inference_prefix", value=cross_region_inference_prefix, expected_type=type_hints["cross_region_inference_prefix"])
            check_type(argname="argument fm_model_id", value=fm_model_id, expected_type=type_hints["fm_model_id"])
            check_type(argname="argument use_cross_region_inference", value=use_cross_region_inference, expected_type=type_hints["use_cross_region_inference"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if cross_region_inference_prefix is not None:
            self._values["cross_region_inference_prefix"] = cross_region_inference_prefix
        if fm_model_id is not None:
            self._values["fm_model_id"] = fm_model_id
        if use_cross_region_inference is not None:
            self._values["use_cross_region_inference"] = use_cross_region_inference

    @builtins.property
    def cross_region_inference_prefix(
        self,
    ) -> typing.Optional["BedrockCrossRegionInferencePrefix"]:
        '''(experimental) Prefix for cross-region inference configuration.

        Only used when useCrossRegionInference is true.

        :default: BedrockCrossRegionInferencePrefix.US

        :stability: experimental
        '''
        result = self._values.get("cross_region_inference_prefix")
        return typing.cast(typing.Optional["BedrockCrossRegionInferencePrefix"], result)

    @builtins.property
    def fm_model_id(
        self,
    ) -> typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"]:
        '''(experimental) Foundation model to use.

        :default: FoundationModelIdentifier.ANTHROPIC_CLAUDE_SONNET_4_20250514_V1_0

        :stability: experimental
        '''
        result = self._values.get("fm_model_id")
        return typing.cast(typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"], result)

    @builtins.property
    def use_cross_region_inference(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable cross-region inference for Bedrock models to improve availability and performance.

        When enabled, uses inference profiles instead of direct model invocation.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("use_cross_region_inference")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BedrockModelProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BedrockModelUtils(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockModelUtils",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="deriveActualModelId")
    @builtins.classmethod
    def derive_actual_model_id(
        cls,
        *,
        cross_region_inference_prefix: typing.Optional["BedrockCrossRegionInferencePrefix"] = None,
        fm_model_id: typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"] = None,
        use_cross_region_inference: typing.Optional[builtins.bool] = None,
    ) -> builtins.str:
        '''
        :param cross_region_inference_prefix: (experimental) Prefix for cross-region inference configuration. Only used when useCrossRegionInference is true. Default: BedrockCrossRegionInferencePrefix.US
        :param fm_model_id: (experimental) Foundation model to use. Default: FoundationModelIdentifier.ANTHROPIC_CLAUDE_SONNET_4_20250514_V1_0
        :param use_cross_region_inference: (experimental) Enable cross-region inference for Bedrock models to improve availability and performance. When enabled, uses inference profiles instead of direct model invocation. Default: false

        :stability: experimental
        '''
        props = BedrockModelProps(
            cross_region_inference_prefix=cross_region_inference_prefix,
            fm_model_id=fm_model_id,
            use_cross_region_inference=use_cross_region_inference,
        )

        return typing.cast(builtins.str, jsii.sinvoke(cls, "deriveActualModelId", [props]))

    @jsii.member(jsii_name="generateModelIAMPermissions")
    @builtins.classmethod
    def generate_model_iam_permissions(
        cls,
        scope: "_constructs_77d1e7e8.Construct",
        *,
        cross_region_inference_prefix: typing.Optional["BedrockCrossRegionInferencePrefix"] = None,
        fm_model_id: typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"] = None,
        use_cross_region_inference: typing.Optional[builtins.bool] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''
        :param scope: -
        :param cross_region_inference_prefix: (experimental) Prefix for cross-region inference configuration. Only used when useCrossRegionInference is true. Default: BedrockCrossRegionInferencePrefix.US
        :param fm_model_id: (experimental) Foundation model to use. Default: FoundationModelIdentifier.ANTHROPIC_CLAUDE_SONNET_4_20250514_V1_0
        :param use_cross_region_inference: (experimental) Enable cross-region inference for Bedrock models to improve availability and performance. When enabled, uses inference profiles instead of direct model invocation. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2d6dd904193a96951d351d9b9f88371b9b85f9f44a00b0cbdbfba9f24849527)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = BedrockModelProps(
            cross_region_inference_prefix=cross_region_inference_prefix,
            fm_model_id=fm_model_id,
            use_cross_region_inference=use_cross_region_inference,
        )

        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "generateModelIAMPermissions", [scope, props]))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkClassificationResult",
    jsii_struct_bases=[],
    name_mapping={
        "document_classification": "documentClassification",
        "confidence": "confidence",
    },
)
class ChunkClassificationResult:
    def __init__(
        self,
        *,
        document_classification: builtins.str,
        confidence: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Classification result for a chunk.

        :param document_classification: 
        :param confidence: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd9e20bf6521c15d5e5562ba4c6c68cd96f7bb6427af870a73ad163c3439483b)
            check_type(argname="argument document_classification", value=document_classification, expected_type=type_hints["document_classification"])
            check_type(argname="argument confidence", value=confidence, expected_type=type_hints["confidence"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "document_classification": document_classification,
        }
        if confidence is not None:
            self._values["confidence"] = confidence

    @builtins.property
    def document_classification(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("document_classification")
        assert result is not None, "Required property 'document_classification' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def confidence(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("confidence")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkClassificationResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkMetadata",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "chunk_id": "chunkId",
        "chunk_index": "chunkIndex",
        "end_page": "endPage",
        "estimated_tokens": "estimatedTokens",
        "key": "key",
        "page_count": "pageCount",
        "start_page": "startPage",
        "total_chunks": "totalChunks",
    },
)
class ChunkMetadata:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        chunk_id: builtins.str,
        chunk_index: jsii.Number,
        end_page: jsii.Number,
        estimated_tokens: jsii.Number,
        key: builtins.str,
        page_count: jsii.Number,
        start_page: jsii.Number,
        total_chunks: jsii.Number,
    ) -> None:
        '''(experimental) Metadata about a single chunk of a document.

        Contains information about the chunk's position, size, and S3 location.

        :param bucket: (experimental) S3 bucket containing the chunk file.
        :param chunk_id: (experimental) Unique identifier for this chunk. Format: {documentId}*chunk*{index}
        :param chunk_index: (experimental) Zero-based index of this chunk in the document.
        :param end_page: (experimental) Ending page number (zero-based, inclusive) of this chunk.
        :param estimated_tokens: (experimental) Estimated token count for this chunk. Based on word-count heuristic (1.3 tokens per word).
        :param key: (experimental) S3 key for the chunk file. Typically in chunks/ prefix.
        :param page_count: (experimental) Number of pages in this chunk.
        :param start_page: (experimental) Starting page number (zero-based) of this chunk.
        :param total_chunks: (experimental) Total number of chunks in the document.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__dff34b4820a98b0388febbe964d8d3a5e892547b131e5dae54581ec4a2640cad)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument chunk_id", value=chunk_id, expected_type=type_hints["chunk_id"])
            check_type(argname="argument chunk_index", value=chunk_index, expected_type=type_hints["chunk_index"])
            check_type(argname="argument end_page", value=end_page, expected_type=type_hints["end_page"])
            check_type(argname="argument estimated_tokens", value=estimated_tokens, expected_type=type_hints["estimated_tokens"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument page_count", value=page_count, expected_type=type_hints["page_count"])
            check_type(argname="argument start_page", value=start_page, expected_type=type_hints["start_page"])
            check_type(argname="argument total_chunks", value=total_chunks, expected_type=type_hints["total_chunks"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "chunk_id": chunk_id,
            "chunk_index": chunk_index,
            "end_page": end_page,
            "estimated_tokens": estimated_tokens,
            "key": key,
            "page_count": page_count,
            "start_page": start_page,
            "total_chunks": total_chunks,
        }

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) S3 bucket containing the chunk file.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def chunk_id(self) -> builtins.str:
        '''(experimental) Unique identifier for this chunk.

        Format: {documentId}*chunk*{index}

        :stability: experimental
        '''
        result = self._values.get("chunk_id")
        assert result is not None, "Required property 'chunk_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def chunk_index(self) -> jsii.Number:
        '''(experimental) Zero-based index of this chunk in the document.

        :stability: experimental
        '''
        result = self._values.get("chunk_index")
        assert result is not None, "Required property 'chunk_index' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def end_page(self) -> jsii.Number:
        '''(experimental) Ending page number (zero-based, inclusive) of this chunk.

        :stability: experimental
        '''
        result = self._values.get("end_page")
        assert result is not None, "Required property 'end_page' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def estimated_tokens(self) -> jsii.Number:
        '''(experimental) Estimated token count for this chunk.

        Based on word-count heuristic (1.3 tokens per word).

        :stability: experimental
        '''
        result = self._values.get("estimated_tokens")
        assert result is not None, "Required property 'estimated_tokens' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) S3 key for the chunk file.

        Typically in chunks/ prefix.

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def page_count(self) -> jsii.Number:
        '''(experimental) Number of pages in this chunk.

        :stability: experimental
        '''
        result = self._values.get("page_count")
        assert result is not None, "Required property 'page_count' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def start_page(self) -> jsii.Number:
        '''(experimental) Starting page number (zero-based) of this chunk.

        :stability: experimental
        '''
        result = self._values.get("start_page")
        assert result is not None, "Required property 'start_page' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_chunks(self) -> jsii.Number:
        '''(experimental) Total number of chunks in the document.

        :stability: experimental
        '''
        result = self._values.get("total_chunks")
        assert result is not None, "Required property 'total_chunks' is missing"
        return typing.cast(jsii.Number, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkMetadata(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkProcessingResult",
    jsii_struct_bases=[],
    name_mapping={"entities": "entities"},
)
class ChunkProcessingResult:
    def __init__(
        self,
        *,
        entities: typing.Sequence[typing.Union["Entity", typing.Dict[builtins.str, typing.Any]]],
    ) -> None:
        '''(experimental) Processing result for a chunk.

        :param entities: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__84bb0c085311676bc3e27ceca4b53069c592a7e70466cf418df2f50d6da4b126)
            check_type(argname="argument entities", value=entities, expected_type=type_hints["entities"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "entities": entities,
        }

    @builtins.property
    def entities(self) -> typing.List["Entity"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("entities")
        assert result is not None, "Required property 'entities' is missing"
        return typing.cast(typing.List["Entity"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkProcessingResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkResult",
    jsii_struct_bases=[],
    name_mapping={
        "chunk_id": "chunkId",
        "chunk_index": "chunkIndex",
        "classification_result": "classificationResult",
        "error": "error",
        "processing_result": "processingResult",
    },
)
class ChunkResult:
    def __init__(
        self,
        *,
        chunk_id: builtins.str,
        chunk_index: jsii.Number,
        classification_result: typing.Optional[typing.Union["ChunkClassificationResult", typing.Dict[builtins.str, typing.Any]]] = None,
        error: typing.Optional[builtins.str] = None,
        processing_result: typing.Optional[typing.Union["ChunkProcessingResult", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Result from processing a single chunk.

        Contains classification and extraction results, or error information.

        :param chunk_id: (experimental) Chunk identifier.
        :param chunk_index: (experimental) Zero-based chunk index.
        :param classification_result: (experimental) Optional classification result for this chunk.
        :param error: (experimental) Error message if chunk processing failed.
        :param processing_result: (experimental) Optional extraction result for this chunk.

        :stability: experimental
        '''
        if isinstance(classification_result, dict):
            classification_result = ChunkClassificationResult(**classification_result)
        if isinstance(processing_result, dict):
            processing_result = ChunkProcessingResult(**processing_result)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__74cdd2c037c32a152c200fbc3680ef5c78fb6788f991311e1236992871f04ab8)
            check_type(argname="argument chunk_id", value=chunk_id, expected_type=type_hints["chunk_id"])
            check_type(argname="argument chunk_index", value=chunk_index, expected_type=type_hints["chunk_index"])
            check_type(argname="argument classification_result", value=classification_result, expected_type=type_hints["classification_result"])
            check_type(argname="argument error", value=error, expected_type=type_hints["error"])
            check_type(argname="argument processing_result", value=processing_result, expected_type=type_hints["processing_result"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "chunk_id": chunk_id,
            "chunk_index": chunk_index,
        }
        if classification_result is not None:
            self._values["classification_result"] = classification_result
        if error is not None:
            self._values["error"] = error
        if processing_result is not None:
            self._values["processing_result"] = processing_result

    @builtins.property
    def chunk_id(self) -> builtins.str:
        '''(experimental) Chunk identifier.

        :stability: experimental
        '''
        result = self._values.get("chunk_id")
        assert result is not None, "Required property 'chunk_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def chunk_index(self) -> jsii.Number:
        '''(experimental) Zero-based chunk index.

        :stability: experimental
        '''
        result = self._values.get("chunk_index")
        assert result is not None, "Required property 'chunk_index' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def classification_result(self) -> typing.Optional["ChunkClassificationResult"]:
        '''(experimental) Optional classification result for this chunk.

        :stability: experimental
        '''
        result = self._values.get("classification_result")
        return typing.cast(typing.Optional["ChunkClassificationResult"], result)

    @builtins.property
    def error(self) -> typing.Optional[builtins.str]:
        '''(experimental) Error message if chunk processing failed.

        :stability: experimental
        '''
        result = self._values.get("error")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def processing_result(self) -> typing.Optional["ChunkProcessingResult"]:
        '''(experimental) Optional extraction result for this chunk.

        :stability: experimental
        '''
        result = self._values.get("processing_result")
        return typing.cast(typing.Optional["ChunkProcessingResult"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkingConfig",
    jsii_struct_bases=[],
    name_mapping={
        "aggregation_strategy": "aggregationStrategy",
        "chunk_size": "chunkSize",
        "max_concurrency": "maxConcurrency",
        "max_pages_per_chunk": "maxPagesPerChunk",
        "max_tokens_per_chunk": "maxTokensPerChunk",
        "min_success_threshold": "minSuccessThreshold",
        "overlap_pages": "overlapPages",
        "overlap_tokens": "overlapTokens",
        "page_threshold": "pageThreshold",
        "processing_mode": "processingMode",
        "strategy": "strategy",
        "target_tokens_per_chunk": "targetTokensPerChunk",
        "token_threshold": "tokenThreshold",
    },
)
class ChunkingConfig:
    def __init__(
        self,
        *,
        aggregation_strategy: typing.Optional[builtins.str] = None,
        chunk_size: typing.Optional[jsii.Number] = None,
        max_concurrency: typing.Optional[jsii.Number] = None,
        max_pages_per_chunk: typing.Optional[jsii.Number] = None,
        max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
        min_success_threshold: typing.Optional[jsii.Number] = None,
        overlap_pages: typing.Optional[jsii.Number] = None,
        overlap_tokens: typing.Optional[jsii.Number] = None,
        page_threshold: typing.Optional[jsii.Number] = None,
        processing_mode: typing.Optional[builtins.str] = None,
        strategy: typing.Optional[builtins.str] = None,
        target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
        token_threshold: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Comprehensive configuration for PDF chunking behavior.

        This interface provides fine-grained control over how large PDF documents are
        split into manageable chunks for processing. The chunking system supports three
        strategies, each optimized for different document types and use cases.


        Chunking Strategies



        1. Hybrid Strategy (RECOMMENDED)

        Balances both token count and page limits for optimal chunking. Best for most
        documents as it respects model token limits while preventing excessively large chunks.


        2. Token-Based Strategy

        Splits documents based on estimated token count. Best for documents with variable
        content density (e.g., mixed text and images, tables, charts).


        3. Fixed-Pages Strategy (Legacy)

        Simple page-based splitting. Fast but may exceed token limits for dense documents.
        Use only for documents with uniform content density.


        Processing Modes

        - **parallel**: Process multiple chunks simultaneously (faster, higher cost)
        - **sequential**: Process chunks one at a time (slower, lower cost)



        Aggregation Strategies

        - **majority-vote**: Most frequent classification wins (recommended)
        - **weighted-vote**: Early chunks weighted higher
        - **first-chunk**: Use first chunk's classification only



        Default Values

        | Parameter | Default | Description |
        |-----------|---------|-------------|
        | strategy | 'hybrid' | Chunking strategy |
        | pageThreshold | 100 | Pages to trigger chunking |
        | tokenThreshold | 150000 | Tokens to trigger chunking |
        | chunkSize | 50 | Pages per chunk (fixed-pages) |
        | overlapPages | 5 | Overlap pages (fixed-pages) |
        | maxTokensPerChunk | 100000 | Max tokens per chunk (token-based) |
        | overlapTokens | 5000 | Overlap tokens (token-based, hybrid) |
        | targetTokensPerChunk | 80000 | Target tokens per chunk (hybrid) |
        | maxPagesPerChunk | 99 | Max pages per chunk (hybrid) |
        | processingMode | 'parallel' | Processing mode |
        | maxConcurrency | 10 | Max parallel chunks |
        | aggregationStrategy | 'majority-vote' | Result aggregation |
        | minSuccessThreshold | 0.5 | Min success rate for valid result |

        :param aggregation_strategy: (experimental) Strategy for aggregating results from multiple chunks. - **majority-vote**: Most frequent classification wins - **weighted-vote**: Early chunks weighted higher - **first-chunk**: Use first chunk's classification Default: 'majority-vote'
        :param chunk_size: (experimental) Number of pages per chunk (fixed-pages strategy). Default: 50
        :param max_concurrency: (experimental) Maximum number of chunks to process concurrently (parallel mode only). Higher values increase speed but also cost. Default: 10
        :param max_pages_per_chunk: (experimental) Hard limit on pages per chunk (hybrid strategy). Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99 to provide a safety margin. Default: 99
        :param max_tokens_per_chunk: (experimental) Maximum tokens per chunk (token-based strategy). Default: 100000
        :param min_success_threshold: (experimental) Minimum percentage of chunks that must succeed for aggregation. If fewer chunks succeed, the result is marked as partial failure. Default: 0.5 (50%)
        :param overlap_pages: (experimental) Number of overlapping pages between chunks (fixed-pages strategy). Default: 5
        :param overlap_tokens: (experimental) Number of overlapping tokens between chunks (token-based and hybrid strategies). Default: 5000
        :param page_threshold: (experimental) Threshold for triggering chunking based on page count (fixed-pages strategy). Default: 100
        :param processing_mode: (experimental) Processing mode for chunks. - **parallel**: Process multiple chunks simultaneously (faster, higher cost) - **sequential**: Process chunks one at a time (slower, lower cost) Default: 'parallel'
        :param strategy: (experimental) Chunking strategy to use. - **hybrid** (RECOMMENDED): Balances token count and page limits - **token-based**: Respects model token limits, good for variable density - **fixed-pages**: Simple page-based splitting (legacy, not recommended) Default: 'hybrid'
        :param target_tokens_per_chunk: (experimental) Soft target for tokens per chunk (hybrid strategy). Default: 80000
        :param token_threshold: (experimental) Threshold for triggering chunking based on token count (token-based strategy). Default: 150000

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__af1fff712e836fae5842106b6630cf29c804320a96e688f2f9522a85655cffcf)
            check_type(argname="argument aggregation_strategy", value=aggregation_strategy, expected_type=type_hints["aggregation_strategy"])
            check_type(argname="argument chunk_size", value=chunk_size, expected_type=type_hints["chunk_size"])
            check_type(argname="argument max_concurrency", value=max_concurrency, expected_type=type_hints["max_concurrency"])
            check_type(argname="argument max_pages_per_chunk", value=max_pages_per_chunk, expected_type=type_hints["max_pages_per_chunk"])
            check_type(argname="argument max_tokens_per_chunk", value=max_tokens_per_chunk, expected_type=type_hints["max_tokens_per_chunk"])
            check_type(argname="argument min_success_threshold", value=min_success_threshold, expected_type=type_hints["min_success_threshold"])
            check_type(argname="argument overlap_pages", value=overlap_pages, expected_type=type_hints["overlap_pages"])
            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
            check_type(argname="argument page_threshold", value=page_threshold, expected_type=type_hints["page_threshold"])
            check_type(argname="argument processing_mode", value=processing_mode, expected_type=type_hints["processing_mode"])
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
            check_type(argname="argument target_tokens_per_chunk", value=target_tokens_per_chunk, expected_type=type_hints["target_tokens_per_chunk"])
            check_type(argname="argument token_threshold", value=token_threshold, expected_type=type_hints["token_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if aggregation_strategy is not None:
            self._values["aggregation_strategy"] = aggregation_strategy
        if chunk_size is not None:
            self._values["chunk_size"] = chunk_size
        if max_concurrency is not None:
            self._values["max_concurrency"] = max_concurrency
        if max_pages_per_chunk is not None:
            self._values["max_pages_per_chunk"] = max_pages_per_chunk
        if max_tokens_per_chunk is not None:
            self._values["max_tokens_per_chunk"] = max_tokens_per_chunk
        if min_success_threshold is not None:
            self._values["min_success_threshold"] = min_success_threshold
        if overlap_pages is not None:
            self._values["overlap_pages"] = overlap_pages
        if overlap_tokens is not None:
            self._values["overlap_tokens"] = overlap_tokens
        if page_threshold is not None:
            self._values["page_threshold"] = page_threshold
        if processing_mode is not None:
            self._values["processing_mode"] = processing_mode
        if strategy is not None:
            self._values["strategy"] = strategy
        if target_tokens_per_chunk is not None:
            self._values["target_tokens_per_chunk"] = target_tokens_per_chunk
        if token_threshold is not None:
            self._values["token_threshold"] = token_threshold

    @builtins.property
    def aggregation_strategy(self) -> typing.Optional[builtins.str]:
        '''(experimental) Strategy for aggregating results from multiple chunks.

        - **majority-vote**: Most frequent classification wins
        - **weighted-vote**: Early chunks weighted higher
        - **first-chunk**: Use first chunk's classification

        :default: 'majority-vote'

        :stability: experimental
        '''
        result = self._values.get("aggregation_strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def chunk_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of pages per chunk (fixed-pages strategy).

        :default: 50

        :stability: experimental
        '''
        result = self._values.get("chunk_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_concurrency(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum number of chunks to process concurrently (parallel mode only).

        Higher values increase speed but also cost.

        :default: 10

        :stability: experimental
        '''
        result = self._values.get("max_concurrency")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_pages_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Hard limit on pages per chunk (hybrid strategy).

        Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99
        to provide a safety margin.

        :default: 99

        :stability: experimental
        '''
        result = self._values.get("max_pages_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum tokens per chunk (token-based strategy).

        :default: 100000

        :stability: experimental
        '''
        result = self._values.get("max_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def min_success_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Minimum percentage of chunks that must succeed for aggregation.

        If fewer chunks succeed, the result is marked as partial failure.

        :default: 0.5 (50%)

        :stability: experimental
        '''
        result = self._values.get("min_success_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_pages(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of overlapping pages between chunks (fixed-pages strategy).

        :default: 5

        :stability: experimental
        '''
        result = self._values.get("overlap_pages")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of overlapping tokens between chunks (token-based and hybrid strategies).

        :default: 5000

        :stability: experimental
        '''
        result = self._values.get("overlap_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def page_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on page count (fixed-pages strategy).

        :default: 100

        :stability: experimental
        '''
        result = self._values.get("page_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def processing_mode(self) -> typing.Optional[builtins.str]:
        '''(experimental) Processing mode for chunks.

        - **parallel**: Process multiple chunks simultaneously (faster, higher cost)
        - **sequential**: Process chunks one at a time (slower, lower cost)

        :default: 'parallel'

        :stability: experimental
        '''
        result = self._values.get("processing_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def strategy(self) -> typing.Optional[builtins.str]:
        '''(experimental) Chunking strategy to use.

        - **hybrid** (RECOMMENDED): Balances token count and page limits
        - **token-based**: Respects model token limits, good for variable density
        - **fixed-pages**: Simple page-based splitting (legacy, not recommended)

        :default: 'hybrid'

        :stability: experimental
        '''
        result = self._values.get("strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def target_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Soft target for tokens per chunk (hybrid strategy).

        :default: 80000

        :stability: experimental
        '''
        result = self._values.get("target_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def token_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on token count (token-based strategy).

        :default: 150000

        :stability: experimental
        '''
        result = self._values.get("token_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkingConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkingConfigUsed",
    jsii_struct_bases=[],
    name_mapping={
        "strategy": "strategy",
        "total_pages": "totalPages",
        "total_tokens": "totalTokens",
        "chunk_size": "chunkSize",
        "max_pages_per_chunk": "maxPagesPerChunk",
        "max_tokens_per_chunk": "maxTokensPerChunk",
        "overlap_pages": "overlapPages",
        "overlap_tokens": "overlapTokens",
        "processing_mode": "processingMode",
        "target_tokens_per_chunk": "targetTokensPerChunk",
    },
)
class ChunkingConfigUsed:
    def __init__(
        self,
        *,
        strategy: builtins.str,
        total_pages: jsii.Number,
        total_tokens: jsii.Number,
        chunk_size: typing.Optional[jsii.Number] = None,
        max_pages_per_chunk: typing.Optional[jsii.Number] = None,
        max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
        overlap_pages: typing.Optional[jsii.Number] = None,
        overlap_tokens: typing.Optional[jsii.Number] = None,
        processing_mode: typing.Optional[builtins.str] = None,
        target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Chunking configuration used for processing.

        Includes both user-provided and default values.

        :param strategy: 
        :param total_pages: 
        :param total_tokens: 
        :param chunk_size: 
        :param max_pages_per_chunk: 
        :param max_tokens_per_chunk: 
        :param overlap_pages: 
        :param overlap_tokens: 
        :param processing_mode: 
        :param target_tokens_per_chunk: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__52f725ee23e9fd3affa617e37a2e0d10494eac3a12ba1d5fc39ac6dbd56def5f)
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
            check_type(argname="argument total_pages", value=total_pages, expected_type=type_hints["total_pages"])
            check_type(argname="argument total_tokens", value=total_tokens, expected_type=type_hints["total_tokens"])
            check_type(argname="argument chunk_size", value=chunk_size, expected_type=type_hints["chunk_size"])
            check_type(argname="argument max_pages_per_chunk", value=max_pages_per_chunk, expected_type=type_hints["max_pages_per_chunk"])
            check_type(argname="argument max_tokens_per_chunk", value=max_tokens_per_chunk, expected_type=type_hints["max_tokens_per_chunk"])
            check_type(argname="argument overlap_pages", value=overlap_pages, expected_type=type_hints["overlap_pages"])
            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
            check_type(argname="argument processing_mode", value=processing_mode, expected_type=type_hints["processing_mode"])
            check_type(argname="argument target_tokens_per_chunk", value=target_tokens_per_chunk, expected_type=type_hints["target_tokens_per_chunk"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "strategy": strategy,
            "total_pages": total_pages,
            "total_tokens": total_tokens,
        }
        if chunk_size is not None:
            self._values["chunk_size"] = chunk_size
        if max_pages_per_chunk is not None:
            self._values["max_pages_per_chunk"] = max_pages_per_chunk
        if max_tokens_per_chunk is not None:
            self._values["max_tokens_per_chunk"] = max_tokens_per_chunk
        if overlap_pages is not None:
            self._values["overlap_pages"] = overlap_pages
        if overlap_tokens is not None:
            self._values["overlap_tokens"] = overlap_tokens
        if processing_mode is not None:
            self._values["processing_mode"] = processing_mode
        if target_tokens_per_chunk is not None:
            self._values["target_tokens_per_chunk"] = target_tokens_per_chunk

    @builtins.property
    def strategy(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("strategy")
        assert result is not None, "Required property 'strategy' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def total_pages(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("total_pages")
        assert result is not None, "Required property 'total_pages' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_tokens(self) -> jsii.Number:
        '''
        :stability: experimental
        '''
        result = self._values.get("total_tokens")
        assert result is not None, "Required property 'total_tokens' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def chunk_size(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("chunk_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_pages_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_pages_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def max_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_pages(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("overlap_pages")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("overlap_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def processing_mode(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("processing_mode")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def target_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("target_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkingConfigUsed(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkingRequest",
    jsii_struct_bases=[],
    name_mapping={
        "content": "content",
        "content_type": "contentType",
        "document_id": "documentId",
        "config": "config",
    },
)
class ChunkingRequest:
    def __init__(
        self,
        *,
        content: typing.Union["DocumentContent", typing.Dict[builtins.str, typing.Any]],
        content_type: builtins.str,
        document_id: builtins.str,
        config: typing.Optional[typing.Union["ChunkingConfig", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Request payload for PDF analysis and chunking Lambda.

        Contains document information and chunking configuration.

        :param content: (experimental) Document content location information.
        :param content_type: (experimental) Content type of the document. Typically 'file' for S3-based documents.
        :param document_id: (experimental) Unique identifier for the document.
        :param config: (experimental) Optional chunking configuration. If not provided, uses default configuration.

        :stability: experimental
        '''
        if isinstance(content, dict):
            content = DocumentContent(**content)
        if isinstance(config, dict):
            config = ChunkingConfig(**config)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__18556a2a972ec6282556c235c52399c48b90014067a995b2f0cb0cc47dd790f3)
            check_type(argname="argument content", value=content, expected_type=type_hints["content"])
            check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "content": content,
            "content_type": content_type,
            "document_id": document_id,
        }
        if config is not None:
            self._values["config"] = config

    @builtins.property
    def content(self) -> "DocumentContent":
        '''(experimental) Document content location information.

        :stability: experimental
        '''
        result = self._values.get("content")
        assert result is not None, "Required property 'content' is missing"
        return typing.cast("DocumentContent", result)

    @builtins.property
    def content_type(self) -> builtins.str:
        '''(experimental) Content type of the document.

        Typically 'file' for S3-based documents.

        :stability: experimental
        '''
        result = self._values.get("content_type")
        assert result is not None, "Required property 'content_type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Unique identifier for the document.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def config(self) -> typing.Optional["ChunkingConfig"]:
        '''(experimental) Optional chunking configuration.

        If not provided, uses default configuration.

        :stability: experimental
        '''
        result = self._values.get("config")
        return typing.cast(typing.Optional["ChunkingConfig"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkingRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunkingResponse",
    jsii_struct_bases=[],
    name_mapping={
        "chunks": "chunks",
        "config": "config",
        "document_id": "documentId",
        "requires_chunking": "requiresChunking",
        "strategy": "strategy",
        "token_analysis": "tokenAnalysis",
    },
)
class ChunkingResponse:
    def __init__(
        self,
        *,
        chunks: typing.Sequence[typing.Union["ChunkMetadata", typing.Dict[builtins.str, typing.Any]]],
        config: typing.Union["ChunkingConfigUsed", typing.Dict[builtins.str, typing.Any]],
        document_id: builtins.str,
        requires_chunking: builtins.bool,
        strategy: builtins.str,
        token_analysis: typing.Union["TokenAnalysis", typing.Dict[builtins.str, typing.Any]],
    ) -> None:
        '''(experimental) Response when chunking IS required.

        Document exceeds thresholds and has been split into chunks.

        :param chunks: (experimental) Array of chunk metadata for all created chunks.
        :param config: (experimental) Configuration used for chunking. Includes both user-provided and default values.
        :param document_id: (experimental) Document identifier.
        :param requires_chunking: (experimental) Indicates chunking is required.
        :param strategy: (experimental) Strategy used for chunking.
        :param token_analysis: (experimental) Token analysis results with detailed per-page information.

        :stability: experimental
        '''
        if isinstance(config, dict):
            config = ChunkingConfigUsed(**config)
        if isinstance(token_analysis, dict):
            token_analysis = TokenAnalysis(**token_analysis)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30392a0d7945b1a642c3ae79c76025695230f699b4688f6ed29e409a39f321f2)
            check_type(argname="argument chunks", value=chunks, expected_type=type_hints["chunks"])
            check_type(argname="argument config", value=config, expected_type=type_hints["config"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument requires_chunking", value=requires_chunking, expected_type=type_hints["requires_chunking"])
            check_type(argname="argument strategy", value=strategy, expected_type=type_hints["strategy"])
            check_type(argname="argument token_analysis", value=token_analysis, expected_type=type_hints["token_analysis"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "chunks": chunks,
            "config": config,
            "document_id": document_id,
            "requires_chunking": requires_chunking,
            "strategy": strategy,
            "token_analysis": token_analysis,
        }

    @builtins.property
    def chunks(self) -> typing.List["ChunkMetadata"]:
        '''(experimental) Array of chunk metadata for all created chunks.

        :stability: experimental
        '''
        result = self._values.get("chunks")
        assert result is not None, "Required property 'chunks' is missing"
        return typing.cast(typing.List["ChunkMetadata"], result)

    @builtins.property
    def config(self) -> "ChunkingConfigUsed":
        '''(experimental) Configuration used for chunking.

        Includes both user-provided and default values.

        :stability: experimental
        '''
        result = self._values.get("config")
        assert result is not None, "Required property 'config' is missing"
        return typing.cast("ChunkingConfigUsed", result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def requires_chunking(self) -> builtins.bool:
        '''(experimental) Indicates chunking is required.

        :stability: experimental
        '''
        result = self._values.get("requires_chunking")
        assert result is not None, "Required property 'requires_chunking' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def strategy(self) -> builtins.str:
        '''(experimental) Strategy used for chunking.

        :stability: experimental
        '''
        result = self._values.get("strategy")
        assert result is not None, "Required property 'strategy' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def token_analysis(self) -> "TokenAnalysis":
        '''(experimental) Token analysis results with detailed per-page information.

        :stability: experimental
        '''
        result = self._values.get("token_analysis")
        assert result is not None, "Required property 'token_analysis' is missing"
        return typing.cast("TokenAnalysis", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunkingResponse(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ChunksSummary",
    jsii_struct_bases=[],
    name_mapping={
        "failed_chunks": "failedChunks",
        "successful_chunks": "successfulChunks",
        "total_chunks": "totalChunks",
        "total_tokens_processed": "totalTokensProcessed",
    },
)
class ChunksSummary:
    def __init__(
        self,
        *,
        failed_chunks: jsii.Number,
        successful_chunks: jsii.Number,
        total_chunks: jsii.Number,
        total_tokens_processed: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Summary of chunk processing results.

        :param failed_chunks: (experimental) Number of chunks that failed processing.
        :param successful_chunks: (experimental) Number of chunks that processed successfully.
        :param total_chunks: (experimental) Total number of chunks created.
        :param total_tokens_processed: (experimental) Optional total tokens processed across all chunks.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9b7fa01f3556d4c74e9b1095a671fde30d6c5b5c71c294ca4412ce58dc15f535)
            check_type(argname="argument failed_chunks", value=failed_chunks, expected_type=type_hints["failed_chunks"])
            check_type(argname="argument successful_chunks", value=successful_chunks, expected_type=type_hints["successful_chunks"])
            check_type(argname="argument total_chunks", value=total_chunks, expected_type=type_hints["total_chunks"])
            check_type(argname="argument total_tokens_processed", value=total_tokens_processed, expected_type=type_hints["total_tokens_processed"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "failed_chunks": failed_chunks,
            "successful_chunks": successful_chunks,
            "total_chunks": total_chunks,
        }
        if total_tokens_processed is not None:
            self._values["total_tokens_processed"] = total_tokens_processed

    @builtins.property
    def failed_chunks(self) -> jsii.Number:
        '''(experimental) Number of chunks that failed processing.

        :stability: experimental
        '''
        result = self._values.get("failed_chunks")
        assert result is not None, "Required property 'failed_chunks' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def successful_chunks(self) -> jsii.Number:
        '''(experimental) Number of chunks that processed successfully.

        :stability: experimental
        '''
        result = self._values.get("successful_chunks")
        assert result is not None, "Required property 'successful_chunks' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_chunks(self) -> jsii.Number:
        '''(experimental) Total number of chunks created.

        :stability: experimental
        '''
        result = self._values.get("total_chunks")
        assert result is not None, "Required property 'total_chunks' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_tokens_processed(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Optional total tokens processed across all chunks.

        :stability: experimental
        '''
        result = self._values.get("total_tokens_processed")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ChunksSummary(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CleanupRequest",
    jsii_struct_bases=[],
    name_mapping={"chunks": "chunks", "document_id": "documentId"},
)
class CleanupRequest:
    def __init__(
        self,
        *,
        chunks: typing.Sequence[typing.Union["ChunkMetadata", typing.Dict[builtins.str, typing.Any]]],
        document_id: builtins.str,
    ) -> None:
        '''(experimental) Request payload for cleanup Lambda.

        Contains information about chunks to delete.

        :param chunks: (experimental) Array of chunk metadata for chunks to delete.
        :param document_id: (experimental) Document identifier.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c4209557aad5933432f5d67ea04b9856c85e9fd94b4d488179516f51e1e41cc7)
            check_type(argname="argument chunks", value=chunks, expected_type=type_hints["chunks"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "chunks": chunks,
            "document_id": document_id,
        }

    @builtins.property
    def chunks(self) -> typing.List["ChunkMetadata"]:
        '''(experimental) Array of chunk metadata for chunks to delete.

        :stability: experimental
        '''
        result = self._values.get("chunks")
        assert result is not None, "Required property 'chunks' is missing"
        return typing.cast(typing.List["ChunkMetadata"], result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CleanupRequest(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CleanupResponse",
    jsii_struct_bases=[],
    name_mapping={
        "deleted_chunks": "deletedChunks",
        "document_id": "documentId",
        "errors": "errors",
    },
)
class CleanupResponse:
    def __init__(
        self,
        *,
        deleted_chunks: jsii.Number,
        document_id: builtins.str,
        errors: typing.Sequence[builtins.str],
    ) -> None:
        '''(experimental) Response from cleanup Lambda.

        Reports success and any errors encountered.

        :param deleted_chunks: (experimental) Number of chunks successfully deleted.
        :param document_id: (experimental) Document identifier.
        :param errors: (experimental) Array of error messages for failed deletions. Empty if all deletions succeeded.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c65b9a851a891fc5241b9fce5931c7b91903c7f335a932bec1803689cc2b3619)
            check_type(argname="argument deleted_chunks", value=deleted_chunks, expected_type=type_hints["deleted_chunks"])
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument errors", value=errors, expected_type=type_hints["errors"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "deleted_chunks": deleted_chunks,
            "document_id": document_id,
            "errors": errors,
        }

    @builtins.property
    def deleted_chunks(self) -> jsii.Number:
        '''(experimental) Number of chunks successfully deleted.

        :stability: experimental
        '''
        result = self._values.get("deleted_chunks")
        assert result is not None, "Required property 'deleted_chunks' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def errors(self) -> typing.List[builtins.str]:
        '''(experimental) Array of error messages for failed deletions.

        Empty if all deletions succeeded.

        :stability: experimental
        '''
        result = self._values.get("errors")
        assert result is not None, "Required property 'errors' is missing"
        return typing.cast(typing.List[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CleanupResponse(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class CloudWatchTransactionSearch(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CloudWatchTransactionSearch",
):
    '''(experimental) Enables CloudWatch Transaction Search for X-Ray traces.

    This construct configures account-level settings to enable cost-effective
    collection of all X-Ray spans through CloudWatch Logs. It performs three steps:

    1. Creates a CloudWatch Logs resource-based policy allowing X-Ray to send traces
    2. Configures X-Ray to send trace segments to CloudWatch Logs
    3. Sets the sampling percentage for span indexing (default 1%)

    The construct checks if Transaction Search is already enabled and only applies
    configuration if needed. It's idempotent and safe to deploy multiple times.


    Benefits

    - Cost-effective: Uses CloudWatch Logs pricing instead of X-Ray pricing
    - Full visibility: All spans are collected and searchable
    - Automatic indexing: 1% of spans indexed by default for trace summaries



    Usage

    Example::

       new CloudWatchTransactionSearch(this, 'TransactionSearch', {
         samplingPercentage: 1  // Optional: 1% is default
       });

    :see: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Enable-TransactionSearch.html
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        policy_name: typing.Optional[builtins.str] = None,
        sampling_percentage: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param policy_name: (experimental) Name of the CloudWatch Logs resource policy. Default: 'TransactionSearchXRayAccess'
        :param sampling_percentage: (experimental) Sampling percentage for span indexing. Default: 1 (1% of spans indexed)

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f3c5a017e701e8d87469e4e204b145be1e398bb7f4bfa38aa21c16115939e71f)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = CloudWatchTransactionSearchProps(
            policy_name=policy_name, sampling_percentage=sampling_percentage
        )

        jsii.create(self.__class__, self, [scope, id, props])


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CloudWatchTransactionSearchProps",
    jsii_struct_bases=[],
    name_mapping={
        "policy_name": "policyName",
        "sampling_percentage": "samplingPercentage",
    },
)
class CloudWatchTransactionSearchProps:
    def __init__(
        self,
        *,
        policy_name: typing.Optional[builtins.str] = None,
        sampling_percentage: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Configuration properties for CloudWatch Transaction Search.

        :param policy_name: (experimental) Name of the CloudWatch Logs resource policy. Default: 'TransactionSearchXRayAccess'
        :param sampling_percentage: (experimental) Sampling percentage for span indexing. Default: 1 (1% of spans indexed)

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__516779ddac5a1226a9b564150c57d6b9dbf9971e2131b677de99815d4d81c964)
            check_type(argname="argument policy_name", value=policy_name, expected_type=type_hints["policy_name"])
            check_type(argname="argument sampling_percentage", value=sampling_percentage, expected_type=type_hints["sampling_percentage"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if policy_name is not None:
            self._values["policy_name"] = policy_name
        if sampling_percentage is not None:
            self._values["sampling_percentage"] = sampling_percentage

    @builtins.property
    def policy_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Name of the CloudWatch Logs resource policy.

        :default: 'TransactionSearchXRayAccess'

        :stability: experimental
        '''
        result = self._values.get("policy_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def sampling_percentage(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Sampling percentage for span indexing.

        :default: 1 (1% of spans indexed)

        :stability: experimental
        '''
        result = self._values.get("sampling_percentage")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CloudWatchTransactionSearchProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_aws_cdk_ceddda9d.IPropertyInjector)
class CloudfrontDistributionObservabilityPropertyInjector(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CloudfrontDistributionObservabilityPropertyInjector",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="inject")
    def inject(
        self,
        original_props: typing.Any,
        *,
        id: builtins.str,
        scope: "_constructs_77d1e7e8.Construct",
    ) -> typing.Any:
        '''(experimental) The injector to be applied to the constructor properties of the Construct.

        :param original_props: -
        :param id: id from the Construct constructor.
        :param scope: scope from the constructor.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2270aedab8c9db027e16b28fd9de8610d0f7e47778cdf1d501539d0e440a561d)
            check_type(argname="argument original_props", value=original_props, expected_type=type_hints["original_props"])
        context = _aws_cdk_ceddda9d.InjectionContext(id=id, scope=scope)

        return typing.cast(typing.Any, jsii.invoke(self, "inject", [original_props, context]))

    @builtins.property
    @jsii.member(jsii_name="constructUniqueId")
    def construct_unique_id(self) -> builtins.str:
        '''(experimental) The unique Id of the Construct class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "constructUniqueId"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CognitoAuthenticatorProps",
    jsii_struct_bases=[],
    name_mapping={
        "removal_policy": "removalPolicy",
        "user_pool": "userPool",
        "user_pool_client": "userPoolClient",
    },
)
class CognitoAuthenticatorProps:
    def __init__(
        self,
        *,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        user_pool: typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"] = None,
        user_pool_client: typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"] = None,
    ) -> None:
        '''(experimental) Configuration properties for CognitoAuthenticator.

        :param removal_policy: (experimental) Removal policy for Cognito resources. Default: RemovalPolicy.DESTROY
        :param user_pool: (experimental) Cognito User Pool for authentication. Default: Auto-created User Pool with secure defaults
        :param user_pool_client: (experimental) Cognito User Pool Client. Default: Auto-created client with appropriate auth flows

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__624aa76fbb25c1b63246b5b7fab2db8d727c5e5e55244e35cf75c4df67c9498b)
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument user_pool", value=user_pool, expected_type=type_hints["user_pool"])
            check_type(argname="argument user_pool_client", value=user_pool_client, expected_type=type_hints["user_pool_client"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if user_pool is not None:
            self._values["user_pool"] = user_pool
        if user_pool_client is not None:
            self._values["user_pool_client"] = user_pool_client

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for Cognito resources.

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def user_pool(self) -> typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"]:
        '''(experimental) Cognito User Pool for authentication.

        :default: Auto-created User Pool with secure defaults

        :stability: experimental
        '''
        result = self._values.get("user_pool")
        return typing.cast(typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"], result)

    @builtins.property
    def user_pool_client(
        self,
    ) -> typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"]:
        '''(experimental) Cognito User Pool Client.

        :default: Auto-created client with appropriate auth flows

        :stability: experimental
        '''
        result = self._values.get("user_pool_client")
        return typing.cast(typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CognitoAuthenticatorProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CreateKnowledgeBaseConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "data_source_bucket_name": "dataSourceBucketName",
        "chunking_strategy": "chunkingStrategy",
        "data_source_prefix": "dataSourcePrefix",
        "embedding_model_id": "embeddingModelId",
        "max_tokens": "maxTokens",
        "overlap_tokens": "overlapTokens",
    },
)
class CreateKnowledgeBaseConfiguration:
    def __init__(
        self,
        *,
        data_source_bucket_name: builtins.str,
        chunking_strategy: typing.Optional[builtins.str] = None,
        data_source_prefix: typing.Optional[builtins.str] = None,
        embedding_model_id: typing.Optional[builtins.str] = None,
        max_tokens: typing.Optional[jsii.Number] = None,
        overlap_tokens: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Configuration for creating a new Bedrock Knowledge Base.

        When provided to BedrockKnowledgeBase, a new knowledge base will be
        created with the specified data source and embedding configuration.

        Note: This is an advanced feature. For most use cases, referencing
        an existing knowledge base by ID is recommended.

        :param data_source_bucket_name: (experimental) S3 bucket name containing source documents. The bucket must exist and contain the documents to be indexed.
        :param chunking_strategy: (experimental) Chunking strategy for document processing. - 'fixed-size': Split documents into fixed-size chunks - 'semantic': Use semantic boundaries for chunking - 'none': No chunking (use entire documents) Default: 'fixed-size'
        :param data_source_prefix: (experimental) S3 prefix for source documents within the bucket. Only documents under this prefix will be indexed. Default: - Root of bucket (all documents)
        :param embedding_model_id: (experimental) Embedding model to use for vectorization. Must be a valid Bedrock embedding model ID. Default: 'amazon.titan-embed-text-v2:0'
        :param max_tokens: (experimental) Maximum chunk size in tokens (for fixed-size chunking). Only used when chunkingStrategy is 'fixed-size'. Default: 300
        :param overlap_tokens: (experimental) Overlap between chunks in tokens (for fixed-size chunking). Only used when chunkingStrategy is 'fixed-size'. Default: 20

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5a66ad6b4c71f08ad11270f15622825326a8ae23d1f4b8349ee45ee1997ed029)
            check_type(argname="argument data_source_bucket_name", value=data_source_bucket_name, expected_type=type_hints["data_source_bucket_name"])
            check_type(argname="argument chunking_strategy", value=chunking_strategy, expected_type=type_hints["chunking_strategy"])
            check_type(argname="argument data_source_prefix", value=data_source_prefix, expected_type=type_hints["data_source_prefix"])
            check_type(argname="argument embedding_model_id", value=embedding_model_id, expected_type=type_hints["embedding_model_id"])
            check_type(argname="argument max_tokens", value=max_tokens, expected_type=type_hints["max_tokens"])
            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "data_source_bucket_name": data_source_bucket_name,
        }
        if chunking_strategy is not None:
            self._values["chunking_strategy"] = chunking_strategy
        if data_source_prefix is not None:
            self._values["data_source_prefix"] = data_source_prefix
        if embedding_model_id is not None:
            self._values["embedding_model_id"] = embedding_model_id
        if max_tokens is not None:
            self._values["max_tokens"] = max_tokens
        if overlap_tokens is not None:
            self._values["overlap_tokens"] = overlap_tokens

    @builtins.property
    def data_source_bucket_name(self) -> builtins.str:
        '''(experimental) S3 bucket name containing source documents.

        The bucket must exist and contain the documents to be indexed.

        :stability: experimental
        '''
        result = self._values.get("data_source_bucket_name")
        assert result is not None, "Required property 'data_source_bucket_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def chunking_strategy(self) -> typing.Optional[builtins.str]:
        '''(experimental) Chunking strategy for document processing.

        - 'fixed-size': Split documents into fixed-size chunks
        - 'semantic': Use semantic boundaries for chunking
        - 'none': No chunking (use entire documents)

        :default: 'fixed-size'

        :stability: experimental
        '''
        result = self._values.get("chunking_strategy")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def data_source_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 prefix for source documents within the bucket.

        Only documents under this prefix will be indexed.

        :default: - Root of bucket (all documents)

        :stability: experimental
        '''
        result = self._values.get("data_source_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def embedding_model_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) Embedding model to use for vectorization.

        Must be a valid Bedrock embedding model ID.

        :default: 'amazon.titan-embed-text-v2:0'

        :stability: experimental
        '''
        result = self._values.get("embedding_model_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def max_tokens(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum chunk size in tokens (for fixed-size chunking).

        Only used when chunkingStrategy is 'fixed-size'.

        :default: 300

        :stability: experimental
        '''
        result = self._values.get("max_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Overlap between chunks in tokens (for fixed-size chunking).

        Only used when chunkingStrategy is 'fixed-size'.

        :default: 20

        :stability: experimental
        '''
        result = self._values.get("overlap_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CreateKnowledgeBaseConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CustomDomainConfig",
    jsii_struct_bases=[],
    name_mapping={
        "certificate": "certificate",
        "domain_name": "domainName",
        "hosted_zone": "hostedZone",
    },
)
class CustomDomainConfig:
    def __init__(
        self,
        *,
        certificate: "_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate",
        domain_name: builtins.str,
        hosted_zone: typing.Optional["_aws_cdk_aws_route53_ceddda9d.IHostedZone"] = None,
    ) -> None:
        '''(experimental) Custom domain configuration for the frontend.

        :param certificate: (experimental) SSL certificate for the domain (required when domainName is provided).
        :param domain_name: (experimental) Domain name for the frontend (e.g., 'app.example.com').
        :param hosted_zone: (experimental) Optional hosted zone for automatic DNS record creation.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__45e622c5dc8075e1ee5cdf9df72ea9b7ca33e0a7cf348dfaf54f93e635e9dde8)
            check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
            check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
            check_type(argname="argument hosted_zone", value=hosted_zone, expected_type=type_hints["hosted_zone"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "certificate": certificate,
            "domain_name": domain_name,
        }
        if hosted_zone is not None:
            self._values["hosted_zone"] = hosted_zone

    @builtins.property
    def certificate(self) -> "_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate":
        '''(experimental) SSL certificate for the domain (required when domainName is provided).

        :stability: experimental
        '''
        result = self._values.get("certificate")
        assert result is not None, "Required property 'certificate' is missing"
        return typing.cast("_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate", result)

    @builtins.property
    def domain_name(self) -> builtins.str:
        '''(experimental) Domain name for the frontend (e.g., 'app.example.com').

        :stability: experimental
        '''
        result = self._values.get("domain_name")
        assert result is not None, "Required property 'domain_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def hosted_zone(
        self,
    ) -> typing.Optional["_aws_cdk_aws_route53_ceddda9d.IHostedZone"]:
        '''(experimental) Optional hosted zone for automatic DNS record creation.

        :stability: experimental
        '''
        result = self._values.get("hosted_zone")
        return typing.cast(typing.Optional["_aws_cdk_aws_route53_ceddda9d.IHostedZone"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "CustomDomainConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class DataLoader(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DataLoader",
):
    '''(experimental) DataLoader construct for loading data into Aurora/RDS databases.

    This construct provides a simplified solution for loading data from various file formats
    (SQL, mysqldump, pg_dump) into MySQL or PostgreSQL databases. It uses S3 for file storage,
    Step Functions for orchestration, and Lambda for processing.

    Architecture:

    1. Files are uploaded to S3 bucket
    2. Step Function is triggered with list of S3 keys
    3. Step Function iterates over files in execution order
    4. Lambda function processes each file against the database

    Example usage:
    Create a DataLoader with database configuration and file inputs.
    The construct will handle uploading files to S3, creating a Step Function
    to orchestrate processing, and executing the data loading pipeline.

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        database_config: typing.Union["DatabaseConfig", typing.Dict[builtins.str, typing.Any]],
        file_inputs: typing.Sequence[typing.Union["FileInput", typing.Dict[builtins.str, typing.Any]]],
        memory_size: typing.Optional[jsii.Number] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param database_config: (experimental) Database configuration.
        :param file_inputs: (experimental) List of files to load.
        :param memory_size: (experimental) Optional memory size for Lambda function (defaults to 1024 MB).
        :param removal_policy: (experimental) Optional removal policy for resources (defaults to DESTROY).
        :param timeout: (experimental) Optional timeout for Lambda function (defaults to 15 minutes).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__270a76813d598a503e52c71a882567ace4b31275076ba0bcefcc5ff1011d5018)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = DataLoaderProps(
            database_config=database_config,
            file_inputs=file_inputs,
            memory_size=memory_size,
            removal_policy=removal_policy,
            timeout=timeout,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="grantExecutionTriggerPermissions")
    def grant_execution_trigger_permissions(
        self,
        statement: "_aws_cdk_aws_iam_ceddda9d.PolicyStatement",
    ) -> None:
        '''(experimental) Grants additional IAM permissions to the execution trigger Lambda function.

        :param statement: The IAM policy statement to add.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efd46917d5b396c28d8f6ffeea52cc31230f92bb12d3a0b916d59526a781140a)
            check_type(argname="argument statement", value=statement, expected_type=type_hints["statement"])
        return typing.cast(None, jsii.invoke(self, "grantExecutionTriggerPermissions", [statement]))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> "_aws_cdk_aws_s3_ceddda9d.Bucket":
        '''(experimental) The S3 bucket used for storing files.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_s3_ceddda9d.Bucket", jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="customResourceProvider")
    def custom_resource_provider(self) -> "_aws_cdk_custom_resources_ceddda9d.Provider":
        '''(experimental) The custom resource provider for triggering state machine execution.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_custom_resources_ceddda9d.Provider", jsii.get(self, "customResourceProvider"))

    @builtins.property
    @jsii.member(jsii_name="executionTrigger")
    def execution_trigger(self) -> "_aws_cdk_ceddda9d.CustomResource":
        '''(experimental) The custom resource that triggers the state machine.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_ceddda9d.CustomResource", jsii.get(self, "executionTrigger"))

    @builtins.property
    @jsii.member(jsii_name="processorFunction")
    def processor_function(self) -> "_aws_cdk_aws_lambda_ceddda9d.Function":
        '''(experimental) The Lambda function that processes the data loading.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_lambda_ceddda9d.Function", jsii.get(self, "processorFunction"))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine":
        '''(experimental) The Step Functions state machine for orchestration.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine", jsii.get(self, "stateMachine"))

    @builtins.property
    @jsii.member(jsii_name="bucketDeployment")
    def bucket_deployment(
        self,
    ) -> typing.Optional["_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment"]:
        '''(experimental) The bucket deployment for uploading files.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment"], jsii.get(self, "bucketDeployment"))

    @bucket_deployment.setter
    def bucket_deployment(
        self,
        value: typing.Optional["_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment"],
    ) -> None:
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd063a11debecd44b792418fb4aa1f7320d173a2fbc3280588266e303321f59e)
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
        jsii.set(self, "bucketDeployment", value) # pyright: ignore[reportArgumentType]


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DataLoaderProps",
    jsii_struct_bases=[],
    name_mapping={
        "database_config": "databaseConfig",
        "file_inputs": "fileInputs",
        "memory_size": "memorySize",
        "removal_policy": "removalPolicy",
        "timeout": "timeout",
    },
)
class DataLoaderProps:
    def __init__(
        self,
        *,
        database_config: typing.Union["DatabaseConfig", typing.Dict[builtins.str, typing.Any]],
        file_inputs: typing.Sequence[typing.Union["FileInput", typing.Dict[builtins.str, typing.Any]]],
        memory_size: typing.Optional[jsii.Number] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Properties for the DataLoader construct.

        :param database_config: (experimental) Database configuration.
        :param file_inputs: (experimental) List of files to load.
        :param memory_size: (experimental) Optional memory size for Lambda function (defaults to 1024 MB).
        :param removal_policy: (experimental) Optional removal policy for resources (defaults to DESTROY).
        :param timeout: (experimental) Optional timeout for Lambda function (defaults to 15 minutes).

        :stability: experimental
        '''
        if isinstance(database_config, dict):
            database_config = DatabaseConfig(**database_config)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__79385aca2a5a0bb7a2e64dbdad2106a739cca7fbad6670895f995ed402f5a8fe)
            check_type(argname="argument database_config", value=database_config, expected_type=type_hints["database_config"])
            check_type(argname="argument file_inputs", value=file_inputs, expected_type=type_hints["file_inputs"])
            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "database_config": database_config,
            "file_inputs": file_inputs,
        }
        if memory_size is not None:
            self._values["memory_size"] = memory_size
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def database_config(self) -> "DatabaseConfig":
        '''(experimental) Database configuration.

        :stability: experimental
        '''
        result = self._values.get("database_config")
        assert result is not None, "Required property 'database_config' is missing"
        return typing.cast("DatabaseConfig", result)

    @builtins.property
    def file_inputs(self) -> typing.List["FileInput"]:
        '''(experimental) List of files to load.

        :stability: experimental
        '''
        result = self._values.get("file_inputs")
        assert result is not None, "Required property 'file_inputs' is missing"
        return typing.cast(typing.List["FileInput"], result)

    @builtins.property
    def memory_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Optional memory size for Lambda function (defaults to 1024 MB).

        :stability: experimental
        '''
        result = self._values.get("memory_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Optional removal policy for resources (defaults to DESTROY).

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Optional timeout for Lambda function (defaults to 15 minutes).

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DataLoaderProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DatabaseConfig",
    jsii_struct_bases=[],
    name_mapping={
        "database_name": "databaseName",
        "engine": "engine",
        "secret": "secret",
        "security_group": "securityGroup",
        "vpc": "vpc",
        "cluster": "cluster",
        "instance": "instance",
    },
)
class DatabaseConfig:
    def __init__(
        self,
        *,
        database_name: builtins.str,
        engine: "DatabaseEngine",
        secret: "_aws_cdk_aws_secretsmanager_ceddda9d.ISecret",
        security_group: "_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup",
        vpc: "_aws_cdk_aws_ec2_ceddda9d.IVpc",
        cluster: typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster"] = None,
        instance: typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance"] = None,
    ) -> None:
        '''(experimental) Database connection configuration.

        :param database_name: (experimental) Database name to connect to.
        :param engine: (experimental) Database engine type.
        :param secret: (experimental) Database credentials secret.
        :param security_group: (experimental) Security group for database access.
        :param vpc: (experimental) VPC where the database is located.
        :param cluster: (experimental) Database cluster (for Aurora).
        :param instance: (experimental) Database instance (for RDS).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28429cd4673598c14d3b2db601f7758c41a1c9972a1d3aeb36a73a6d7afffe94)
            check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
            check_type(argname="argument engine", value=engine, expected_type=type_hints["engine"])
            check_type(argname="argument secret", value=secret, expected_type=type_hints["secret"])
            check_type(argname="argument security_group", value=security_group, expected_type=type_hints["security_group"])
            check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
            check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "database_name": database_name,
            "engine": engine,
            "secret": secret,
            "security_group": security_group,
            "vpc": vpc,
        }
        if cluster is not None:
            self._values["cluster"] = cluster
        if instance is not None:
            self._values["instance"] = instance

    @builtins.property
    def database_name(self) -> builtins.str:
        '''(experimental) Database name to connect to.

        :stability: experimental
        '''
        result = self._values.get("database_name")
        assert result is not None, "Required property 'database_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def engine(self) -> "DatabaseEngine":
        '''(experimental) Database engine type.

        :stability: experimental
        '''
        result = self._values.get("engine")
        assert result is not None, "Required property 'engine' is missing"
        return typing.cast("DatabaseEngine", result)

    @builtins.property
    def secret(self) -> "_aws_cdk_aws_secretsmanager_ceddda9d.ISecret":
        '''(experimental) Database credentials secret.

        :stability: experimental
        '''
        result = self._values.get("secret")
        assert result is not None, "Required property 'secret' is missing"
        return typing.cast("_aws_cdk_aws_secretsmanager_ceddda9d.ISecret", result)

    @builtins.property
    def security_group(self) -> "_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup":
        '''(experimental) Security group for database access.

        :stability: experimental
        '''
        result = self._values.get("security_group")
        assert result is not None, "Required property 'security_group' is missing"
        return typing.cast("_aws_cdk_aws_ec2_ceddda9d.ISecurityGroup", result)

    @builtins.property
    def vpc(self) -> "_aws_cdk_aws_ec2_ceddda9d.IVpc":
        '''(experimental) VPC where the database is located.

        :stability: experimental
        '''
        result = self._values.get("vpc")
        assert result is not None, "Required property 'vpc' is missing"
        return typing.cast("_aws_cdk_aws_ec2_ceddda9d.IVpc", result)

    @builtins.property
    def cluster(self) -> typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster"]:
        '''(experimental) Database cluster (for Aurora).

        :stability: experimental
        '''
        result = self._values.get("cluster")
        return typing.cast(typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster"], result)

    @builtins.property
    def instance(
        self,
    ) -> typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance"]:
        '''(experimental) Database instance (for RDS).

        :stability: experimental
        '''
        result = self._values.get("instance")
        return typing.cast(typing.Optional["_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DatabaseConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DatabaseEngine")
class DatabaseEngine(enum.Enum):
    '''(experimental) Supported database engines.

    :stability: experimental
    '''

    MYSQL = "MYSQL"
    '''
    :stability: experimental
    '''
    POSTGRESQL = "POSTGRESQL"
    '''
    :stability: experimental
    '''


class DefaultAgentConfig(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DefaultAgentConfig",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_OBSERVABILITY_METRIC_SVC_NAME")
    def DEFAULT_OBSERVABILITY_METRIC_SVC_NAME(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_OBSERVABILITY_METRIC_SVC_NAME"))


class DefaultDocumentProcessingConfig(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DefaultDocumentProcessingConfig",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_OBSERVABILITY_METRIC_SVC_NAME")
    def DEFAULT_OBSERVABILITY_METRIC_SVC_NAME(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_OBSERVABILITY_METRIC_SVC_NAME"))


class DefaultObservabilityConfig(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DefaultObservabilityConfig",
):
    '''(experimental) Contains default constants for Observability related configuration.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_METRIC_NAMESPACE")
    def DEFAULT_METRIC_NAMESPACE(cls) -> builtins.str:
        '''(experimental) Default namespace for powertools.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_METRIC_NAMESPACE"))


class DefaultRuntimes(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DefaultRuntimes",
):
    '''(experimental) Contains default runtimes that would be referenced by Lambda functions in the various use cases.

    Updating of
    Runtime versions should be done here.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.python.classproperty
    @jsii.member(jsii_name="NODEJS")
    def NODEJS(cls) -> "_aws_cdk_aws_lambda_ceddda9d.Runtime":
        '''(experimental) Default runtime for all Lambda functions in the use cases.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_lambda_ceddda9d.Runtime", jsii.sget(cls, "NODEJS"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PYTHON")
    def PYTHON(cls) -> "_aws_cdk_aws_lambda_ceddda9d.Runtime":
        '''(experimental) Default runtime for Python based Lambda functions.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_lambda_ceddda9d.Runtime", jsii.sget(cls, "PYTHON"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PYTHON_BUNDLING_IMAGE")
    def PYTHON_BUNDLING_IMAGE(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "PYTHON_BUNDLING_IMAGE"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="PYTHON_FUNCTION_BUNDLING")
    def PYTHON_FUNCTION_BUNDLING(
        cls,
    ) -> "_aws_cdk_aws_lambda_python_alpha_49328424.BundlingOptions":
        '''(experimental) Default bundling arguments for Python function.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_lambda_python_alpha_49328424.BundlingOptions", jsii.sget(cls, "PYTHON_FUNCTION_BUNDLING"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.DocumentContent",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "filename": "filename",
        "key": "key",
        "location": "location",
    },
)
class DocumentContent:
    def __init__(
        self,
        *,
        bucket: builtins.str,
        filename: builtins.str,
        key: builtins.str,
        location: builtins.str,
    ) -> None:
        '''(experimental) Document content location information.

        :param bucket: (experimental) S3 bucket containing the document.
        :param filename: (experimental) Original filename of the document.
        :param key: (experimental) S3 key for the document.
        :param location: (experimental) Storage location type (e.g., 's3').

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4cb6edfc3ff826b337155281a5d87d7f3be9eab183ccc4426ff88802b3e0c0b4)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument filename", value=filename, expected_type=type_hints["filename"])
            check_type(argname="argument key", value=key, expected_type=type_hints["key"])
            check_type(argname="argument location", value=location, expected_type=type_hints["location"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "bucket": bucket,
            "filename": filename,
            "key": key,
            "location": location,
        }

    @builtins.property
    def bucket(self) -> builtins.str:
        '''(experimental) S3 bucket containing the document.

        :stability: experimental
        '''
        result = self._values.get("bucket")
        assert result is not None, "Required property 'bucket' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def filename(self) -> builtins.str:
        '''(experimental) Original filename of the document.

        :stability: experimental
        '''
        result = self._values.get("filename")
        assert result is not None, "Required property 'filename' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def key(self) -> builtins.str:
        '''(experimental) S3 key for the document.

        :stability: experimental
        '''
        result = self._values.get("key")
        assert result is not None, "Required property 'key' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def location(self) -> builtins.str:
        '''(experimental) Storage location type (e.g., 's3').

        :stability: experimental
        '''
        result = self._values.get("location")
        assert result is not None, "Required property 'location' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "DocumentContent(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.Entity",
    jsii_struct_bases=[],
    name_mapping={
        "type": "type",
        "value": "value",
        "chunk_index": "chunkIndex",
        "page": "page",
    },
)
class Entity:
    def __init__(
        self,
        *,
        type: builtins.str,
        value: builtins.str,
        chunk_index: typing.Optional[jsii.Number] = None,
        page: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Extracted entity from document processing.

        :param type: (experimental) Type of entity (e.g., 'NAME', 'DATE', 'AMOUNT', 'ADDRESS').
        :param value: (experimental) Value of the entity.
        :param chunk_index: (experimental) Optional chunk index where entity was found.
        :param page: (experimental) Optional page number where entity was found. Entities with page numbers are preserved even if duplicated.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__efeba2470d944f9864ade05399b91a8692e4fbe022602a30b2b4ef50a015b2fb)
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
            check_type(argname="argument chunk_index", value=chunk_index, expected_type=type_hints["chunk_index"])
            check_type(argname="argument page", value=page, expected_type=type_hints["page"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "type": type,
            "value": value,
        }
        if chunk_index is not None:
            self._values["chunk_index"] = chunk_index
        if page is not None:
            self._values["page"] = page

    @builtins.property
    def type(self) -> builtins.str:
        '''(experimental) Type of entity (e.g., 'NAME', 'DATE', 'AMOUNT', 'ADDRESS').

        :stability: experimental
        '''
        result = self._values.get("type")
        assert result is not None, "Required property 'type' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def value(self) -> builtins.str:
        '''(experimental) Value of the entity.

        :stability: experimental
        '''
        result = self._values.get("value")
        assert result is not None, "Required property 'value' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def chunk_index(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Optional chunk index where entity was found.

        :stability: experimental
        '''
        result = self._values.get("chunk_index")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def page(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Optional page number where entity was found.

        Entities with page numbers are preserved even if duplicated.

        :stability: experimental
        '''
        result = self._values.get("page")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "Entity(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class EventbridgeBroker(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.EventbridgeBroker",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        event_source: builtins.str,
        kms_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        name: typing.Optional[builtins.str] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param event_source: 
        :param kms_key: 
        :param name: 
        :param removal_policy: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5391a3753ae12822ab842065b2f29fede1c6b75f7e0ba6cdca1be351c9c104c3)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = EventbridgeBrokerProps(
            event_source=event_source,
            kms_key=kms_key,
            name=name,
            removal_policy=removal_policy,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="sendViaSfnChain")
    def send_via_sfn_chain(
        self,
        detail_type: builtins.str,
        event_detail: typing.Any,
    ) -> "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EventBridgePutEvents":
        '''
        :param detail_type: -
        :param event_detail: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__71a910ff106734bd214c5973b84305b89274d3d6adbe4eedaa2c546cb060d0d7)
            check_type(argname="argument detail_type", value=detail_type, expected_type=type_hints["detail_type"])
            check_type(argname="argument event_detail", value=event_detail, expected_type=type_hints["event_detail"])
        return typing.cast("_aws_cdk_aws_stepfunctions_tasks_ceddda9d.EventBridgePutEvents", jsii.invoke(self, "sendViaSfnChain", [detail_type, event_detail]))

    @builtins.property
    @jsii.member(jsii_name="eventbus")
    def eventbus(self) -> "_aws_cdk_aws_events_ceddda9d.EventBus":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_events_ceddda9d.EventBus", jsii.get(self, "eventbus"))

    @builtins.property
    @jsii.member(jsii_name="kmsKey")
    def kms_key(self) -> "_aws_cdk_aws_kms_ceddda9d.Key":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_kms_ceddda9d.Key", jsii.get(self, "kmsKey"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.EventbridgeBrokerProps",
    jsii_struct_bases=[],
    name_mapping={
        "event_source": "eventSource",
        "kms_key": "kmsKey",
        "name": "name",
        "removal_policy": "removalPolicy",
    },
)
class EventbridgeBrokerProps:
    def __init__(
        self,
        *,
        event_source: builtins.str,
        kms_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        name: typing.Optional[builtins.str] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
    ) -> None:
        '''
        :param event_source: 
        :param kms_key: 
        :param name: 
        :param removal_policy: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ecd91fa4cae79b6f27bdbae2c38230e7edda9cec831ac503ca3b7c01b0311241)
            check_type(argname="argument event_source", value=event_source, expected_type=type_hints["event_source"])
            check_type(argname="argument kms_key", value=kms_key, expected_type=type_hints["kms_key"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "event_source": event_source,
        }
        if kms_key is not None:
            self._values["kms_key"] = kms_key
        if name is not None:
            self._values["name"] = name
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy

    @builtins.property
    def event_source(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("event_source")
        assert result is not None, "Required property 'event_source' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def kms_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("kms_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def name(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "EventbridgeBrokerProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.FileInput",
    jsii_struct_bases=[],
    name_mapping={
        "file_path": "filePath",
        "file_type": "fileType",
        "continue_on_error": "continueOnError",
        "execution_order": "executionOrder",
    },
)
class FileInput:
    def __init__(
        self,
        *,
        file_path: builtins.str,
        file_type: "FileType",
        continue_on_error: typing.Optional[builtins.bool] = None,
        execution_order: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) File input configuration.

        :param file_path: (experimental) Path to the file (local path or S3 URI).
        :param file_type: (experimental) Type of file.
        :param continue_on_error: (experimental) Whether to continue on error.
        :param execution_order: (experimental) Execution order (lower numbers execute first).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f22614c3ee9aff68919f8ac64743fb8c255ed9c33337d90d40c2622733942ed5)
            check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
            check_type(argname="argument file_type", value=file_type, expected_type=type_hints["file_type"])
            check_type(argname="argument continue_on_error", value=continue_on_error, expected_type=type_hints["continue_on_error"])
            check_type(argname="argument execution_order", value=execution_order, expected_type=type_hints["execution_order"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "file_path": file_path,
            "file_type": file_type,
        }
        if continue_on_error is not None:
            self._values["continue_on_error"] = continue_on_error
        if execution_order is not None:
            self._values["execution_order"] = execution_order

    @builtins.property
    def file_path(self) -> builtins.str:
        '''(experimental) Path to the file (local path or S3 URI).

        :stability: experimental
        '''
        result = self._values.get("file_path")
        assert result is not None, "Required property 'file_path' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def file_type(self) -> "FileType":
        '''(experimental) Type of file.

        :stability: experimental
        '''
        result = self._values.get("file_type")
        assert result is not None, "Required property 'file_type' is missing"
        return typing.cast("FileType", result)

    @builtins.property
    def continue_on_error(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether to continue on error.

        :stability: experimental
        '''
        result = self._values.get("continue_on_error")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def execution_order(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Execution order (lower numbers execute first).

        :stability: experimental
        '''
        result = self._values.get("execution_order")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FileInput(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.enum(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.FileType")
class FileType(enum.Enum):
    '''(experimental) Supported file types for data loading.

    :stability: experimental
    '''

    SQL = "SQL"
    '''(experimental) Standard SQL file.

    :stability: experimental
    '''
    MYSQLDUMP = "MYSQLDUMP"
    '''(experimental) MySQL dump file generated by mysqldump.

    :stability: experimental
    '''
    PGDUMP = "PGDUMP"
    '''(experimental) PostgreSQL dump file generated by pg_dump.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.FixedPagesConfig",
    jsii_struct_bases=[],
    name_mapping={
        "chunk_size": "chunkSize",
        "overlap_pages": "overlapPages",
        "page_threshold": "pageThreshold",
    },
)
class FixedPagesConfig:
    def __init__(
        self,
        *,
        chunk_size: typing.Optional[jsii.Number] = None,
        overlap_pages: typing.Optional[jsii.Number] = None,
        page_threshold: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Configuration for fixed-pages chunking strategy.

        Splits documents by fixed page count (legacy approach).

        :param chunk_size: (experimental) Number of pages per chunk. Default: 50
        :param overlap_pages: (experimental) Number of overlapping pages between consecutive chunks. Must be less than chunkSize. Default: 5
        :param page_threshold: (experimental) Threshold for triggering chunking based on page count. Documents with pages > threshold will be chunked. Default: 100

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9790b02ab060fae9c48b274099105523cb8bc3432d04149d0b7a5f204a8b1bac)
            check_type(argname="argument chunk_size", value=chunk_size, expected_type=type_hints["chunk_size"])
            check_type(argname="argument overlap_pages", value=overlap_pages, expected_type=type_hints["overlap_pages"])
            check_type(argname="argument page_threshold", value=page_threshold, expected_type=type_hints["page_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if chunk_size is not None:
            self._values["chunk_size"] = chunk_size
        if overlap_pages is not None:
            self._values["overlap_pages"] = overlap_pages
        if page_threshold is not None:
            self._values["page_threshold"] = page_threshold

    @builtins.property
    def chunk_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of pages per chunk.

        :default: 50

        :stability: experimental
        '''
        result = self._values.get("chunk_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_pages(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of overlapping pages between consecutive chunks.

        Must be less than chunkSize.

        :default: 5

        :stability: experimental
        '''
        result = self._values.get("overlap_pages")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def page_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on page count.

        Documents with pages > threshold will be chunked.

        :default: 100

        :stability: experimental
        '''
        result = self._values.get("page_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FixedPagesConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class Frontend(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.Frontend",
):
    '''(experimental) Frontend construct that deploys a frontend application to S3 and CloudFront.

    This construct provides a complete solution for hosting static frontend applications
    with the following features:

    - S3 bucket for hosting static assets with security best practices
    - CloudFront distribution for global content delivery
    - Optional custom domain with SSL certificate
    - Automatic build process execution
    - SPA-friendly error handling by default
    - Security configurations

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        source_directory: builtins.str,
        build_command: typing.Optional[builtins.str] = None,
        build_output_directory: typing.Optional[builtins.str] = None,
        custom_domain: typing.Optional[typing.Union["CustomDomainConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        distribution_props: typing.Optional[typing.Union["AdditionalDistributionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        error_responses: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse", typing.Dict[builtins.str, typing.Any]]]] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        skip_build: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Creates a new Frontend.

        :param scope: The construct scope.
        :param id: The construct ID.
        :param source_directory: (experimental) Base directory of the frontend source code.
        :param build_command: (experimental) Optional build command (defaults to 'npm run build').
        :param build_output_directory: (experimental) Directory where build artifacts are located after build command completes (defaults to '{sourceDirectory}/build').
        :param custom_domain: (experimental) Optional custom domain configuration.
        :param distribution_props: (experimental) Optional additional CloudFront distribution properties.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param error_responses: (experimental) Optional CloudFront error responses (defaults to SPA-friendly responses).
        :param removal_policy: (experimental) Optional removal policy for all resources (defaults to DESTROY).
        :param skip_build: (experimental) Optional flag to skip the build process (useful for pre-built artifacts).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__59f5637ea312a9fb8090cc497bbaa3fb29d31e5a16d1958df0e9a4337936da88)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = FrontendProps(
            source_directory=source_directory,
            build_command=build_command,
            build_output_directory=build_output_directory,
            custom_domain=custom_domain,
            distribution_props=distribution_props,
            enable_observability=enable_observability,
            error_responses=error_responses,
            removal_policy=removal_policy,
            skip_build=skip_build,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="bucketName")
    def bucket_name(self) -> builtins.str:
        '''(experimental) Gets the S3 bucket name.

        :return: The S3 bucket name

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "bucketName", []))

    @jsii.member(jsii_name="distributionDomainName")
    def distribution_domain_name(self) -> builtins.str:
        '''(experimental) Gets the CloudFront distribution domain name.

        :return: The CloudFront domain name

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "distributionDomainName", []))

    @jsii.member(jsii_name="url")
    def url(self) -> builtins.str:
        '''(experimental) Gets the URL of the frontend application.

        :return: The frontend URL

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.invoke(self, "url", []))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> "_aws_cdk_aws_s3_ceddda9d.Bucket":
        '''(experimental) The S3 bucket hosting the frontend assets.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_s3_ceddda9d.Bucket", jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="bucketDeployment")
    def bucket_deployment(
        self,
    ) -> "_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment":
        '''(experimental) The bucket deployment that uploads the frontend assets.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment", jsii.get(self, "bucketDeployment"))

    @builtins.property
    @jsii.member(jsii_name="distribution")
    def distribution(self) -> "_aws_cdk_aws_cloudfront_ceddda9d.Distribution":
        '''(experimental) The CloudFront distribution.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_cloudfront_ceddda9d.Distribution", jsii.get(self, "distribution"))

    @builtins.property
    @jsii.member(jsii_name="asset")
    def asset(self) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
        '''(experimental) The Asset containing the frontend source code.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.get(self, "asset"))

    @builtins.property
    @jsii.member(jsii_name="domainName")
    def domain_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) The custom domain name (if configured).

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "domainName"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.FrontendProps",
    jsii_struct_bases=[],
    name_mapping={
        "source_directory": "sourceDirectory",
        "build_command": "buildCommand",
        "build_output_directory": "buildOutputDirectory",
        "custom_domain": "customDomain",
        "distribution_props": "distributionProps",
        "enable_observability": "enableObservability",
        "error_responses": "errorResponses",
        "removal_policy": "removalPolicy",
        "skip_build": "skipBuild",
    },
)
class FrontendProps:
    def __init__(
        self,
        *,
        source_directory: builtins.str,
        build_command: typing.Optional[builtins.str] = None,
        build_output_directory: typing.Optional[builtins.str] = None,
        custom_domain: typing.Optional[typing.Union["CustomDomainConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        distribution_props: typing.Optional[typing.Union["AdditionalDistributionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        error_responses: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse", typing.Dict[builtins.str, typing.Any]]]] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        skip_build: typing.Optional[builtins.bool] = None,
    ) -> None:
        '''(experimental) Properties for the Frontend construct.

        :param source_directory: (experimental) Base directory of the frontend source code.
        :param build_command: (experimental) Optional build command (defaults to 'npm run build').
        :param build_output_directory: (experimental) Directory where build artifacts are located after build command completes (defaults to '{sourceDirectory}/build').
        :param custom_domain: (experimental) Optional custom domain configuration.
        :param distribution_props: (experimental) Optional additional CloudFront distribution properties.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param error_responses: (experimental) Optional CloudFront error responses (defaults to SPA-friendly responses).
        :param removal_policy: (experimental) Optional removal policy for all resources (defaults to DESTROY).
        :param skip_build: (experimental) Optional flag to skip the build process (useful for pre-built artifacts).

        :stability: experimental
        '''
        if isinstance(custom_domain, dict):
            custom_domain = CustomDomainConfig(**custom_domain)
        if isinstance(distribution_props, dict):
            distribution_props = AdditionalDistributionProps(**distribution_props)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2648a6f2c6f02177f5b324264b7de549aa23b0c1d93c8d6cccbc307a85e0c0fc)
            check_type(argname="argument source_directory", value=source_directory, expected_type=type_hints["source_directory"])
            check_type(argname="argument build_command", value=build_command, expected_type=type_hints["build_command"])
            check_type(argname="argument build_output_directory", value=build_output_directory, expected_type=type_hints["build_output_directory"])
            check_type(argname="argument custom_domain", value=custom_domain, expected_type=type_hints["custom_domain"])
            check_type(argname="argument distribution_props", value=distribution_props, expected_type=type_hints["distribution_props"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument error_responses", value=error_responses, expected_type=type_hints["error_responses"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument skip_build", value=skip_build, expected_type=type_hints["skip_build"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "source_directory": source_directory,
        }
        if build_command is not None:
            self._values["build_command"] = build_command
        if build_output_directory is not None:
            self._values["build_output_directory"] = build_output_directory
        if custom_domain is not None:
            self._values["custom_domain"] = custom_domain
        if distribution_props is not None:
            self._values["distribution_props"] = distribution_props
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if error_responses is not None:
            self._values["error_responses"] = error_responses
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if skip_build is not None:
            self._values["skip_build"] = skip_build

    @builtins.property
    def source_directory(self) -> builtins.str:
        '''(experimental) Base directory of the frontend source code.

        :stability: experimental
        '''
        result = self._values.get("source_directory")
        assert result is not None, "Required property 'source_directory' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def build_command(self) -> typing.Optional[builtins.str]:
        '''(experimental) Optional build command (defaults to 'npm run build').

        :stability: experimental
        '''
        result = self._values.get("build_command")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def build_output_directory(self) -> typing.Optional[builtins.str]:
        '''(experimental) Directory where build artifacts are located after build command completes (defaults to '{sourceDirectory}/build').

        :stability: experimental
        '''
        result = self._values.get("build_output_directory")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def custom_domain(self) -> typing.Optional["CustomDomainConfig"]:
        '''(experimental) Optional custom domain configuration.

        :stability: experimental
        '''
        result = self._values.get("custom_domain")
        return typing.cast(typing.Optional["CustomDomainConfig"], result)

    @builtins.property
    def distribution_props(self) -> typing.Optional["AdditionalDistributionProps"]:
        '''(experimental) Optional additional CloudFront distribution properties.

        :stability: experimental
        '''
        result = self._values.get("distribution_props")
        return typing.cast(typing.Optional["AdditionalDistributionProps"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable logging and tracing for all supporting resource.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def error_responses(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse"]]:
        '''(experimental) Optional CloudFront error responses (defaults to SPA-friendly responses).

        :stability: experimental
        '''
        result = self._values.get("error_responses")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse"]], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Optional removal policy for all resources (defaults to DESTROY).

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def skip_build(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Optional flag to skip the build process (useful for pre-built artifacts).

        :stability: experimental
        '''
        result = self._values.get("skip_build")
        return typing.cast(typing.Optional[builtins.bool], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "FrontendProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.GuardrailConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "guardrail_id": "guardrailId",
        "guardrail_version": "guardrailVersion",
    },
)
class GuardrailConfiguration:
    def __init__(
        self,
        *,
        guardrail_id: builtins.str,
        guardrail_version: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Configuration for Bedrock Guardrails.

        Guardrails filter content during retrieval operations to prevent
        inappropriate or sensitive content from being returned.

        :param guardrail_id: (experimental) ID of the Bedrock Guardrail to apply. The guardrail must exist in the same region as the knowledge base.
        :param guardrail_version: (experimental) Version of the guardrail to use. Use 'DRAFT' for testing or a specific version number for production. Default: 'DRAFT'

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d604d1407a674dc8a1780469f6fca800816236372c95a3b5438a97e1c9faff32)
            check_type(argname="argument guardrail_id", value=guardrail_id, expected_type=type_hints["guardrail_id"])
            check_type(argname="argument guardrail_version", value=guardrail_version, expected_type=type_hints["guardrail_version"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "guardrail_id": guardrail_id,
        }
        if guardrail_version is not None:
            self._values["guardrail_version"] = guardrail_version

    @builtins.property
    def guardrail_id(self) -> builtins.str:
        '''(experimental) ID of the Bedrock Guardrail to apply.

        The guardrail must exist in the same region as the knowledge base.

        :stability: experimental
        '''
        result = self._values.get("guardrail_id")
        assert result is not None, "Required property 'guardrail_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def guardrail_version(self) -> typing.Optional[builtins.str]:
        '''(experimental) Version of the guardrail to use.

        Use 'DRAFT' for testing or a specific version number for production.

        :default: 'DRAFT'

        :stability: experimental
        '''
        result = self._values.get("guardrail_version")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "GuardrailConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.HybridConfig",
    jsii_struct_bases=[],
    name_mapping={
        "max_pages_per_chunk": "maxPagesPerChunk",
        "overlap_tokens": "overlapTokens",
        "page_threshold": "pageThreshold",
        "target_tokens_per_chunk": "targetTokensPerChunk",
        "token_threshold": "tokenThreshold",
    },
)
class HybridConfig:
    def __init__(
        self,
        *,
        max_pages_per_chunk: typing.Optional[jsii.Number] = None,
        overlap_tokens: typing.Optional[jsii.Number] = None,
        page_threshold: typing.Optional[jsii.Number] = None,
        target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
        token_threshold: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Configuration for hybrid chunking strategy (RECOMMENDED).

        Balances token count and page limits for optimal chunking.

        :param max_pages_per_chunk: (experimental) Hard limit on pages per chunk. Prevents very large chunks even if token count is low. Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99 to provide a safety margin. Default: 99
        :param overlap_tokens: (experimental) Number of overlapping tokens between consecutive chunks. Provides context continuity across chunks. Default: 5000
        :param page_threshold: (experimental) Threshold for triggering chunking based on page count. Documents with pages > threshold will be chunked. Default: 100
        :param target_tokens_per_chunk: (experimental) Soft target for tokens per chunk. Chunks aim for this token count but respect maxPagesPerChunk. Default: 80000
        :param token_threshold: (experimental) Threshold for triggering chunking based on token count. Documents with tokens > threshold will be chunked. Default: 150000

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d99de61f167223b9a43c96878ed271835a461896851550035527119e8b896dfb)
            check_type(argname="argument max_pages_per_chunk", value=max_pages_per_chunk, expected_type=type_hints["max_pages_per_chunk"])
            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
            check_type(argname="argument page_threshold", value=page_threshold, expected_type=type_hints["page_threshold"])
            check_type(argname="argument target_tokens_per_chunk", value=target_tokens_per_chunk, expected_type=type_hints["target_tokens_per_chunk"])
            check_type(argname="argument token_threshold", value=token_threshold, expected_type=type_hints["token_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if max_pages_per_chunk is not None:
            self._values["max_pages_per_chunk"] = max_pages_per_chunk
        if overlap_tokens is not None:
            self._values["overlap_tokens"] = overlap_tokens
        if page_threshold is not None:
            self._values["page_threshold"] = page_threshold
        if target_tokens_per_chunk is not None:
            self._values["target_tokens_per_chunk"] = target_tokens_per_chunk
        if token_threshold is not None:
            self._values["token_threshold"] = token_threshold

    @builtins.property
    def max_pages_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Hard limit on pages per chunk.

        Prevents very large chunks even if token count is low.
        Note: Bedrock has a hard limit of 100 pages per PDF, so we default to 99
        to provide a safety margin.

        :default: 99

        :stability: experimental
        '''
        result = self._values.get("max_pages_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of overlapping tokens between consecutive chunks.

        Provides context continuity across chunks.

        :default: 5000

        :stability: experimental
        '''
        result = self._values.get("overlap_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def page_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on page count.

        Documents with pages > threshold will be chunked.

        :default: 100

        :stability: experimental
        '''
        result = self._values.get("page_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def target_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Soft target for tokens per chunk.

        Chunks aim for this token count but respect maxPagesPerChunk.

        :default: 80000

        :stability: experimental
        '''
        result = self._values.get("target_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def token_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on token count.

        Documents with tokens > threshold will be chunked.

        :default: 150000

        :stability: experimental
        '''
        result = self._values.get("token_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "HybridConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IAdapter")
class IAdapter(typing_extensions.Protocol):
    '''(experimental) Abstraction to enable different types of source triggers for the intelligent document processing workflow.

    :stability: experimental
    '''

    @jsii.member(jsii_name="createFailedChain")
    def create_failed_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for failed processing.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param id_prefix: Optional prefix for construct IDs to ensure uniqueness when called multiple times.

        :return: Chain to be added to the state machine to handle failure scenarios

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createIngressTrigger")
    def create_ingress_trigger(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        state_machine: "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) Create resources that would receive the data and trigger the workflow.

        Important: resource created should trigger the state machine

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param state_machine: The workflow of the document processor.
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :return: Resources that are created

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createSuccessChain")
    def create_success_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for successful processing.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param id_prefix: Optional prefix for construct IDs to ensure uniqueness when called multiple times.

        :return: Chain to be added to the state machine to handle successful scenarios

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="generateAdapterIAMPolicies")
    def generate_adapter_iam_policies(
        self,
        additional_iam_actions: typing.Optional[typing.Sequence[builtins.str]] = None,
        narrow_actions: typing.Optional[builtins.bool] = None,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM statements that can be used by other resources to access the storage.

        :param additional_iam_actions: (Optional) list of additional actions in relation to the underlying storage for the adapter.
        :param narrow_actions: (Optional) whether the resulting permissions would only be the IAM actions indicated in the ``additionalIAMActions`` parameter.

        :default: false

        :return: PolicyStatement[] IAM policy statements that would included in the state machine IAM role

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="init")
    def init(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Initializes the adapter.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        ...


class _IAdapterProxy:
    '''(experimental) Abstraction to enable different types of source triggers for the intelligent document processing workflow.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IAdapter"

    @jsii.member(jsii_name="createFailedChain")
    def create_failed_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for failed processing.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param id_prefix: Optional prefix for construct IDs to ensure uniqueness when called multiple times.

        :return: Chain to be added to the state machine to handle failure scenarios

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5998f6c7e16512d92cd00097e77d737333304685208eb36a522c156f8378a9e7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id_prefix", value=id_prefix, expected_type=type_hints["id_prefix"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.Chain", jsii.invoke(self, "createFailedChain", [scope, id_prefix]))

    @jsii.member(jsii_name="createIngressTrigger")
    def create_ingress_trigger(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        state_machine: "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) Create resources that would receive the data and trigger the workflow.

        Important: resource created should trigger the state machine

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param state_machine: The workflow of the document processor.
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :return: Resources that are created

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b61e74ddd8982f4b30ae59307c9fb3adaff26122ddc7f5faabc2cc8e1e2da034)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
        props = BaseDocumentProcessingProps(
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "createIngressTrigger", [scope, state_machine, props]))

    @jsii.member(jsii_name="createSuccessChain")
    def create_success_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for successful processing.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param id_prefix: Optional prefix for construct IDs to ensure uniqueness when called multiple times.

        :return: Chain to be added to the state machine to handle successful scenarios

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cd0aad7a5879633fca8d89cbf92e8f5a13e31615116036f29a82a58c1bb4727d)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id_prefix", value=id_prefix, expected_type=type_hints["id_prefix"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.Chain", jsii.invoke(self, "createSuccessChain", [scope, id_prefix]))

    @jsii.member(jsii_name="generateAdapterIAMPolicies")
    def generate_adapter_iam_policies(
        self,
        additional_iam_actions: typing.Optional[typing.Sequence[builtins.str]] = None,
        narrow_actions: typing.Optional[builtins.bool] = None,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM statements that can be used by other resources to access the storage.

        :param additional_iam_actions: (Optional) list of additional actions in relation to the underlying storage for the adapter.
        :param narrow_actions: (Optional) whether the resulting permissions would only be the IAM actions indicated in the ``additionalIAMActions`` parameter.

        :default: false

        :return: PolicyStatement[] IAM policy statements that would included in the state machine IAM role

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__82a45114a0ff76d4b9d091edd6674d4e762dc5ca19631d61579cf1aa47e30b5e)
            check_type(argname="argument additional_iam_actions", value=additional_iam_actions, expected_type=type_hints["additional_iam_actions"])
            check_type(argname="argument narrow_actions", value=narrow_actions, expected_type=type_hints["narrow_actions"])
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateAdapterIAMPolicies", [additional_iam_actions, narrow_actions]))

    @jsii.member(jsii_name="init")
    def init(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Initializes the adapter.

        :param scope: Scope to use in relation to the CDK hierarchy.
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__17f7e7f35ea8e49cf6ded248435aa1e1dcf416e61c549f3e7b74baad3ac399e7)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = BaseDocumentProcessingProps(
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        return typing.cast(None, jsii.invoke(self, "init", [scope, props]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAdapter).__jsii_proxy_class__ = lambda : _IAdapterProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IAuthenticator")
class IAuthenticator(typing_extensions.Protocol):
    '''(experimental) Strategy interface for authentication mechanisms.

    Authenticators control how API endpoints are secured.
    Different implementations support various authentication methods.

    :stability: experimental
    '''

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Get environment variables for Lambda configuration.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="grantAuthenticate")
    def grant_authenticate(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant authentication permissions to a Lambda function.

        :param lambda_function: -

        :stability: experimental
        '''
        ...


class _IAuthenticatorProxy:
    '''(experimental) Strategy interface for authentication mechanisms.

    Authenticators control how API endpoints are secured.
    Different implementations support various authentication methods.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IAuthenticator"

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Get environment variables for Lambda configuration.

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))

    @jsii.member(jsii_name="grantAuthenticate")
    def grant_authenticate(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant authentication permissions to a Lambda function.

        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1637565319dd5e7a968e97c2502fcec6902286f0199800d1c319b13e1be9e8bf)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantAuthenticate", [lambda_function]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAuthenticator).__jsii_proxy_class__ = lambda : _IAuthenticatorProxy


@jsii.interface(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ICommunicationAdapter"
)
class ICommunicationAdapter(typing_extensions.Protocol):
    '''(experimental) Strategy interface for pluggable communication mechanisms.

    Default implementation is StreamingHttpAdapter (API Gateway REST API with response streaming).

    :stability: experimental
    '''

    @jsii.member(jsii_name="attachToFunction")
    def attach_to_function(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> builtins.str:
        '''(experimental) Attach the adapter to a Lambda function and create communication infrastructure.

        Returns the public endpoint URL for client connections.

        :param lambda_function: -

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="grantInvoke")
    def grant_invoke(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant the Lambda function permission to send responses back to clients.

        :param lambda_function: -

        :stability: experimental
        '''
        ...


class _ICommunicationAdapterProxy:
    '''(experimental) Strategy interface for pluggable communication mechanisms.

    Default implementation is StreamingHttpAdapter (API Gateway REST API with response streaming).

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.ICommunicationAdapter"

    @jsii.member(jsii_name="attachToFunction")
    def attach_to_function(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> builtins.str:
        '''(experimental) Attach the adapter to a Lambda function and create communication infrastructure.

        Returns the public endpoint URL for client connections.

        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3b2728940dd748cbcf160c1d51bd321bce3e08a61f3cef60874a4c209a397858)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(builtins.str, jsii.invoke(self, "attachToFunction", [lambda_function]))

    @jsii.member(jsii_name="grantInvoke")
    def grant_invoke(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant the Lambda function permission to send responses back to clients.

        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ebc9cce6c384f39d072a81b2fdb80ed48808971e0a0f1bce9b65437a686b37c)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantInvoke", [lambda_function]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ICommunicationAdapter).__jsii_proxy_class__ = lambda : _ICommunicationAdapterProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IContextStrategy")
class IContextStrategy(typing_extensions.Protocol):
    '''(deprecated) Strategy interface for conversation history management.

    Context strategies control how conversation history is maintained and provided
    to the agent. Different strategies enable different conversation patterns.

    :deprecated:

    Use Strands-native ``SlidingWindowConversationManager`` from
    ``strands.agent.conversation_manager`` instead. The Python handler now uses
    Strands-native conversation management automatically.

    :stability: deprecated
    '''

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(deprecated) Get environment variables for Lambda configuration.

        :return: Environment variables to configure the context manager

        :stability: deprecated
        '''
        ...


class _IContextStrategyProxy:
    '''(deprecated) Strategy interface for conversation history management.

    Context strategies control how conversation history is maintained and provided
    to the agent. Different strategies enable different conversation patterns.

    :deprecated:

    Use Strands-native ``SlidingWindowConversationManager`` from
    ``strands.agent.conversation_manager`` instead. The Python handler now uses
    Strands-native conversation management automatically.

    :stability: deprecated
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IContextStrategy"

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(deprecated) Get environment variables for Lambda configuration.

        :return: Environment variables to configure the context manager

        :stability: deprecated
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IContextStrategy).__jsii_proxy_class__ = lambda : _IContextStrategyProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IHostingAdapter")
class IHostingAdapter(typing_extensions.Protocol):
    '''(experimental) Strategy interface for pluggable hosting backends.

    Hosting adapters encapsulate the infrastructure needed to run an agent.
    The default implementation is ``LambdaHostingAdapter`` (Lambda + LWA + API Gateway).
    ``AgentCoreRuntimeHostingAdapter`` provides an alternative using AgentCore Runtime.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="servicePrincipal")
    def service_principal(self) -> "_aws_cdk_aws_iam_ceddda9d.ServicePrincipal":
        '''(experimental) The IAM service principal that this hosting backend requires.

        BaseAgent uses this to create the agent role with the correct trust policy.
        For example, Lambda hosting requires ``lambda.amazonaws.com`` while AgentCore
        hosting requires ``bedrock-agentcore.amazonaws.com``.

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="deploy")
    def deploy(
        self,
        *,
        agent_name: builtins.str,
        agent_role: "_aws_cdk_aws_iam_ceddda9d.Role",
        encryption_key: "_aws_cdk_aws_kms_ceddda9d.Key",
        environment: typing.Mapping[builtins.str, builtins.str],
        scope: "_constructs_77d1e7e8.Construct",
        system_prompt_bucket: builtins.str,
        system_prompt_key: builtins.str,
        tools_config: builtins.str,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        knowledge_base_configs: typing.Optional[builtins.str] = None,
        knowledge_base_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> "AgentHostingResult":
        '''(experimental) Deploy the agent hosting infrastructure.

        :param agent_name: (experimental) Agent name identifier.
        :param agent_role: (experimental) IAM role for the agent runtime.
        :param encryption_key: (experimental) KMS encryption key.
        :param environment: (experimental) Environment variables to set on the runtime.
        :param scope: (experimental) CDK scope for creating resources.
        :param system_prompt_bucket: (experimental) System prompt S3 bucket name.
        :param system_prompt_key: (experimental) System prompt S3 key.
        :param tools_config: (experimental) Agent tools location definitions (JSON serialized).
        :param architecture: (experimental) Lambda architecture (Lambda hosting only).
        :param enable_observability: (experimental) Whether observability is enabled.
        :param knowledge_base_configs: (experimental) Knowledge base configs (JSON serialized).
        :param knowledge_base_layers: (experimental) Lambda layers from knowledge bases (Lambda hosting only).
        :param knowledge_base_system_prompt_addition: (experimental) Knowledge base system prompt addition.
        :param lambda_layers: (experimental) Lambda layers from agent definition (Lambda hosting only).
        :param memory_size: (experimental) Lambda memory size in MB (Lambda hosting only).
        :param network: (experimental) Optional VPC network configuration.
        :param removal_policy: (experimental) Removal policy for resources.
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions (Lambda hosting only).
        :param timeout: (experimental) Lambda timeout (Lambda hosting only).

        :return: The hosting result including endpoint and optional resources

        :stability: experimental
        '''
        ...


class _IHostingAdapterProxy:
    '''(experimental) Strategy interface for pluggable hosting backends.

    Hosting adapters encapsulate the infrastructure needed to run an agent.
    The default implementation is ``LambdaHostingAdapter`` (Lambda + LWA + API Gateway).
    ``AgentCoreRuntimeHostingAdapter`` provides an alternative using AgentCore Runtime.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IHostingAdapter"

    @builtins.property
    @jsii.member(jsii_name="servicePrincipal")
    def service_principal(self) -> "_aws_cdk_aws_iam_ceddda9d.ServicePrincipal":
        '''(experimental) The IAM service principal that this hosting backend requires.

        BaseAgent uses this to create the agent role with the correct trust policy.
        For example, Lambda hosting requires ``lambda.amazonaws.com`` while AgentCore
        hosting requires ``bedrock-agentcore.amazonaws.com``.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.ServicePrincipal", jsii.get(self, "servicePrincipal"))

    @jsii.member(jsii_name="deploy")
    def deploy(
        self,
        *,
        agent_name: builtins.str,
        agent_role: "_aws_cdk_aws_iam_ceddda9d.Role",
        encryption_key: "_aws_cdk_aws_kms_ceddda9d.Key",
        environment: typing.Mapping[builtins.str, builtins.str],
        scope: "_constructs_77d1e7e8.Construct",
        system_prompt_bucket: builtins.str,
        system_prompt_key: builtins.str,
        tools_config: builtins.str,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        knowledge_base_configs: typing.Optional[builtins.str] = None,
        knowledge_base_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> "AgentHostingResult":
        '''(experimental) Deploy the agent hosting infrastructure.

        :param agent_name: (experimental) Agent name identifier.
        :param agent_role: (experimental) IAM role for the agent runtime.
        :param encryption_key: (experimental) KMS encryption key.
        :param environment: (experimental) Environment variables to set on the runtime.
        :param scope: (experimental) CDK scope for creating resources.
        :param system_prompt_bucket: (experimental) System prompt S3 bucket name.
        :param system_prompt_key: (experimental) System prompt S3 key.
        :param tools_config: (experimental) Agent tools location definitions (JSON serialized).
        :param architecture: (experimental) Lambda architecture (Lambda hosting only).
        :param enable_observability: (experimental) Whether observability is enabled.
        :param knowledge_base_configs: (experimental) Knowledge base configs (JSON serialized).
        :param knowledge_base_layers: (experimental) Lambda layers from knowledge bases (Lambda hosting only).
        :param knowledge_base_system_prompt_addition: (experimental) Knowledge base system prompt addition.
        :param lambda_layers: (experimental) Lambda layers from agent definition (Lambda hosting only).
        :param memory_size: (experimental) Lambda memory size in MB (Lambda hosting only).
        :param network: (experimental) Optional VPC network configuration.
        :param removal_policy: (experimental) Removal policy for resources.
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions (Lambda hosting only).
        :param timeout: (experimental) Lambda timeout (Lambda hosting only).

        :return: The hosting result including endpoint and optional resources

        :stability: experimental
        '''
        config = AgentHostingConfig(
            agent_name=agent_name,
            agent_role=agent_role,
            encryption_key=encryption_key,
            environment=environment,
            scope=scope,
            system_prompt_bucket=system_prompt_bucket,
            system_prompt_key=system_prompt_key,
            tools_config=tools_config,
            architecture=architecture,
            enable_observability=enable_observability,
            knowledge_base_configs=knowledge_base_configs,
            knowledge_base_layers=knowledge_base_layers,
            knowledge_base_system_prompt_addition=knowledge_base_system_prompt_addition,
            lambda_layers=lambda_layers,
            memory_size=memory_size,
            network=network,
            removal_policy=removal_policy,
            reserved_concurrent_executions=reserved_concurrent_executions,
            timeout=timeout,
        )

        return typing.cast("AgentHostingResult", jsii.invoke(self, "deploy", [config]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IHostingAdapter).__jsii_proxy_class__ = lambda : _IHostingAdapterProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IKnowledgeBase")
class IKnowledgeBase(typing_extensions.Protocol):
    '''(experimental) Interface for knowledge base implementations.

    This interface defines the contract that all knowledge base implementations must satisfy,
    allowing different KB backends (Bedrock KB, OpenSearch, custom) to be used interchangeably
    with the agent framework.

    Implementations of this interface are responsible for:

    - Providing metadata about the knowledge base (name, description)
    - Generating the IAM permissions required for the agent to access the KB
    - Exporting runtime configuration for the retrieval tool
    - Optionally providing a custom retrieval tool implementation

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''(experimental) Human-readable description of what this knowledge base contains.

        This description is included in the agent's system prompt to help
        the agent decide when to query this knowledge base. It should clearly
        indicate what type of information the KB contains and when it should
        be used.

        :stability: experimental

        Example::

            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name for this knowledge base.

        This name is used for logging, display purposes, and to help the agent
        identify which knowledge base to query. It should be unique within
        the set of knowledge bases configured for an agent.

        :stability: experimental

        Example::

            'product-documentation'
        '''
        ...

    @jsii.member(jsii_name="exportConfiguration")
    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
        '''(experimental) Export configuration for runtime use by the retrieval tool.

        This method returns a configuration object that will be serialized
        and passed to the retrieval tool via environment variables. The
        configuration includes all information needed to query the KB at runtime.

        :return: Runtime configuration object for the retrieval tool

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="generateIamPermissions")
    def generate_iam_permissions(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.

        This method returns the IAM permissions that the agent's Lambda function
        role needs to query this knowledge base. The permissions should follow
        the principle of least privilege, scoped to the specific resources.

        :return: Array of IAM PolicyStatement objects granting necessary permissions

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="retrievalToolAsset")
    def retrieval_tool_asset(
        self,
    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
        '''(experimental) Provide the retrieval tool asset for this knowledge base type.

        This optional method allows knowledge base implementations to provide
        a custom retrieval tool. If not implemented or returns undefined,
        the framework's default retrieval tool will be used.

        :return: S3 Asset containing the retrieval tool code, or undefined to use the default

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="retrievalToolLayers")
    def retrieval_tool_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
        '''(experimental) Provide Lambda layers required by the retrieval tool.

        This optional method allows knowledge base implementations to provide
        Lambda layers containing dependencies needed by their retrieval tool.
        For example, a knowledge base might need specific boto3 versions,
        custom libraries, or SDK extensions.

        The layers will be added to the agent's Lambda function, making the
        dependencies available to the retrieval tool at runtime.

        :return: Array of Lambda LayerVersion objects, or undefined if no layers needed

        :stability: experimental
        '''
        ...


class _IKnowledgeBaseProxy:
    '''(experimental) Interface for knowledge base implementations.

    This interface defines the contract that all knowledge base implementations must satisfy,
    allowing different KB backends (Bedrock KB, OpenSearch, custom) to be used interchangeably
    with the agent framework.

    Implementations of this interface are responsible for:

    - Providing metadata about the knowledge base (name, description)
    - Generating the IAM permissions required for the agent to access the KB
    - Exporting runtime configuration for the retrieval tool
    - Optionally providing a custom retrieval tool implementation

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IKnowledgeBase"

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''(experimental) Human-readable description of what this knowledge base contains.

        This description is included in the agent's system prompt to help
        the agent decide when to query this knowledge base. It should clearly
        indicate what type of information the KB contains and when it should
        be used.

        :stability: experimental

        Example::

            'Contains product documentation, user guides, and FAQs. Use when answering questions about product features or troubleshooting.'
        '''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name for this knowledge base.

        This name is used for logging, display purposes, and to help the agent
        identify which knowledge base to query. It should be unique within
        the set of knowledge bases configured for an agent.

        :stability: experimental

        Example::

            'product-documentation'
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @jsii.member(jsii_name="exportConfiguration")
    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
        '''(experimental) Export configuration for runtime use by the retrieval tool.

        This method returns a configuration object that will be serialized
        and passed to the retrieval tool via environment variables. The
        configuration includes all information needed to query the KB at runtime.

        :return: Runtime configuration object for the retrieval tool

        :stability: experimental
        '''
        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))

    @jsii.member(jsii_name="generateIamPermissions")
    def generate_iam_permissions(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.

        This method returns the IAM permissions that the agent's Lambda function
        role needs to query this knowledge base. The permissions should follow
        the principle of least privilege, scoped to the specific resources.

        :return: Array of IAM PolicyStatement objects granting necessary permissions

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))

    @jsii.member(jsii_name="retrievalToolAsset")
    def retrieval_tool_asset(
        self,
    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
        '''(experimental) Provide the retrieval tool asset for this knowledge base type.

        This optional method allows knowledge base implementations to provide
        a custom retrieval tool. If not implemented or returns undefined,
        the framework's default retrieval tool will be used.

        :return: S3 Asset containing the retrieval tool code, or undefined to use the default

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.invoke(self, "retrievalToolAsset", []))

    @jsii.member(jsii_name="retrievalToolLayers")
    def retrieval_tool_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
        '''(experimental) Provide Lambda layers required by the retrieval tool.

        This optional method allows knowledge base implementations to provide
        Lambda layers containing dependencies needed by their retrieval tool.
        For example, a knowledge base might need specific boto3 versions,
        custom libraries, or SDK extensions.

        The layers will be added to the agent's Lambda function, making the
        dependencies available to the retrieval tool at runtime.

        :return: Array of Lambda LayerVersion objects, or undefined if no layers needed

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]], jsii.invoke(self, "retrievalToolLayers", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IKnowledgeBase).__jsii_proxy_class__ = lambda : _IKnowledgeBaseProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.IObservable")
class IObservable(typing_extensions.Protocol):
    '''(experimental) Interface providing configuration parameters for constructs that support Observability.

    :stability: experimental
    '''

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="metricNamespace")
    def metric_namespace(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="metricServiceName")
    def metric_service_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="metrics")
    def metrics(self) -> typing.List["_aws_cdk_aws_cloudwatch_ceddda9d.IMetric"]:
        '''
        :stability: experimental
        '''
        ...


class _IObservableProxy:
    '''(experimental) Interface providing configuration parameters for constructs that support Observability.

    :stability: experimental
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.IObservable"

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''
        :stability: experimental
        '''
        return typing.cast("LogGroupDataProtectionProps", jsii.get(self, "logGroupDataProtection"))

    @builtins.property
    @jsii.member(jsii_name="metricNamespace")
    def metric_namespace(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "metricNamespace"))

    @builtins.property
    @jsii.member(jsii_name="metricServiceName")
    def metric_service_name(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "metricServiceName"))

    @jsii.member(jsii_name="metrics")
    def metrics(self) -> typing.List["_aws_cdk_aws_cloudwatch_ceddda9d.IMetric"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_cloudwatch_ceddda9d.IMetric"], jsii.invoke(self, "metrics", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IObservable).__jsii_proxy_class__ = lambda : _IObservableProxy


@jsii.interface(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ISessionStore")
class ISessionStore(typing_extensions.Protocol):
    '''(deprecated) Strategy interface for session persistence.

    Session stores manage conversation state persistence across HTTP requests.
    The default implementation (S3SessionManager) uses S3 for durable storage.

    :deprecated:

    Use Strands-native ``S3SessionManager`` from ``strands.session.s3_session_manager`` instead.
    The Python handler now uses Strands-native session management automatically.

    :stability: deprecated
    '''

    @builtins.property
    @jsii.member(jsii_name="sessionBucket")
    def session_bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''(deprecated) The S3 bucket used for session storage (if S3-based).

        :stability: deprecated
        '''
        ...

    @jsii.member(jsii_name="grantReadWrite")
    def grant_read_write(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(deprecated) Grant read/write permissions to a Lambda function.

        :param lambda_function: - The Lambda function that needs access to the session store.

        :stability: deprecated
        '''
        ...


class _ISessionStoreProxy:
    '''(deprecated) Strategy interface for session persistence.

    Session stores manage conversation state persistence across HTTP requests.
    The default implementation (S3SessionManager) uses S3 for durable storage.

    :deprecated:

    Use Strands-native ``S3SessionManager`` from ``strands.session.s3_session_manager`` instead.
    The Python handler now uses Strands-native session management automatically.

    :stability: deprecated
    '''

    __jsii_type__: typing.ClassVar[str] = "@cdklabs/cdk-appmod-catalog-blueprints.ISessionStore"

    @builtins.property
    @jsii.member(jsii_name="sessionBucket")
    def session_bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''(deprecated) The S3 bucket used for session storage (if S3-based).

        :stability: deprecated
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"], jsii.get(self, "sessionBucket"))

    @jsii.member(jsii_name="grantReadWrite")
    def grant_read_write(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(deprecated) Grant read/write permissions to a Lambda function.

        :param lambda_function: - The Lambda function that needs access to the session store.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__548d7298dba8149d507666f77a3ac2d921fe8d37efcb6d53d0ac3fadcec0ef38)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantReadWrite", [lambda_function]))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISessionStore).__jsii_proxy_class__ = lambda : _ISessionStoreProxy


class InteractiveAgent(
    BaseAgent,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.InteractiveAgent",
):
    '''(experimental) Interactive Agent for real-time conversational AI with SSE streaming.

    Creates a complete serverless infrastructure for interactive AI conversations
    using API Gateway REST API with response streaming, Lambda Web Adapter,
    FastAPI, and standard Strands Agent.


    Architecture

    Example::

       Client (fetch + ReadableStream)
           ↓ POST /chat (Authorization: Bearer JWT)
       API Gateway REST API (responseTransferMode: STREAM)
           ↓ InvokeWithResponseStream
       Lambda (Python + Lambda Web Adapter + FastAPI)
           ↓ strands.Agent streaming
       Amazon Bedrock (Claude)


    Features

    - **SSE Streaming**: Real-time token-by-token response streaming
    - **15-Minute Timeout**: Extended timeout for long conversations
    - **Session Management**: S3-based conversation persistence
    - **Context Windowing**: Sliding window conversation history
    - **Cognito Auth**: Native JWT validation on REST API
    - **Strategy Interfaces**: Pluggable adapters for all components
    - **Observability**: Lambda Powertools integration



    Usage

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { InteractiveAgent } from '@cdklabs/cdk-appmod-catalog-blueprints';

       const systemPrompt = new Asset(this, 'Prompt', { path: './prompt.txt' });

       const agent = new InteractiveAgent(this, 'ChatAgent', {
         agentName: 'MyChatbot',
         agentDefinition: {
           bedrockModel: { useCrossRegionInference: true },
           systemPrompt: systemPrompt,
         },
       });

       // Access outputs
       agent.apiEndpoint;       // REST API endpoint URL
       agent.sessionBucket;     // S3 session bucket
       agent.authenticator;     // Cognito authenticator (for User Pool info)

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        authenticator: typing.Optional["IAuthenticator"] = None,
        communication_adapter: typing.Optional["ICommunicationAdapter"] = None,
        context_strategy: typing.Optional["IContextStrategy"] = None,
        hosting_adapter: typing.Optional["IHostingAdapter"] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        message_history_limit: typing.Optional[jsii.Number] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        session_bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"] = None,
        session_store: typing.Optional["ISessionStore"] = None,
        session_ttl: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param architecture: (experimental) Lambda function architecture. Default: Architecture.X86_64
        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: CognitoAuthenticator
        :param communication_adapter: (experimental) Communication adapter for client-agent interaction. Default: StreamingHttpAdapter with CognitoAuthenticator
        :param context_strategy: (deprecated) Context strategy for conversation history management. Default: SlidingWindowConversationManager with 20 messages
        :param hosting_adapter: (experimental) Hosting adapter for deploying the agent runtime. Use ``LambdaHostingAdapter`` for Lambda + API Gateway (default) or ``AgentCoreRuntimeHostingAdapter`` for AgentCore Runtime hosting. When provided, ``communicationAdapter``, ``authenticator``, ``memorySize``, ``timeout``, ``architecture``, and ``reservedConcurrentExecutions`` props are ignored (configure them on the adapter directly). Default: LambdaHostingAdapter
        :param memory_size: (experimental) Lambda function memory size in MB. Default: 1024
        :param message_history_limit: (deprecated) Maximum number of messages to keep in conversation history. Shorthand for SlidingWindowConversationManager windowSize. Ignored if contextStrategy is provided. Default: 20
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions for the Lambda function. Default: No reserved concurrency
        :param session_bucket: (experimental) S3 bucket for session storage (shorthand for S3SessionManager). Ignored if sessionStore is provided. Default: Auto-created bucket
        :param session_store: (deprecated) Session store for persisting conversation state. Set to undefined to disable session persistence (stateless mode). Default: S3SessionManager with 24-hour TTL
        :param session_ttl: (experimental) Time-to-live for sessions. Default: Duration.hours(24)
        :param timeout: (experimental) Lambda function timeout. Default: Duration.minutes(15)
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8c5ceb128f06013736509b04ecbcde0f14a2fe9c071515e2ed9489d35960e92a)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = InteractiveAgentProps(
            architecture=architecture,
            authenticator=authenticator,
            communication_adapter=communication_adapter,
            context_strategy=context_strategy,
            hosting_adapter=hosting_adapter,
            memory_size=memory_size,
            message_history_limit=message_history_limit,
            reserved_concurrent_executions=reserved_concurrent_executions,
            session_bucket=session_bucket,
            session_store=session_store,
            session_ttl=session_ttl,
            timeout=timeout,
            agent_definition=agent_definition,
            agent_name=agent_name,
            agent_architecture=agent_architecture,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            network=network,
            removal_policy=removal_policy,
            service_principal=service_principal,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @builtins.property
    @jsii.member(jsii_name="apiEndpoint")
    def api_endpoint(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "apiEndpoint"))

    @builtins.property
    @jsii.member(jsii_name="adapter")
    def adapter(self) -> typing.Optional["ICommunicationAdapter"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["ICommunicationAdapter"], jsii.get(self, "adapter"))

    @builtins.property
    @jsii.member(jsii_name="agentFunction")
    def agent_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"]:
        '''(experimental) The Lambda function for the agent (when using Lambda hosting).

        May be undefined for non-Lambda hosting backends (e.g. AgentCore Runtime).

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.IFunction"], jsii.get(self, "agentFunction"))

    @builtins.property
    @jsii.member(jsii_name="authenticator")
    def authenticator(self) -> typing.Optional["IAuthenticator"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["IAuthenticator"], jsii.get(self, "authenticator"))

    @builtins.property
    @jsii.member(jsii_name="cfnRuntime")
    def cfn_runtime(
        self,
    ) -> typing.Optional["_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime"], jsii.get(self, "cfnRuntime"))

    @builtins.property
    @jsii.member(jsii_name="contextStrategy")
    def context_strategy(self) -> typing.Optional["IContextStrategy"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["IContextStrategy"], jsii.get(self, "contextStrategy"))

    @builtins.property
    @jsii.member(jsii_name="sessionBucket")
    def session_bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"], jsii.get(self, "sessionBucket"))

    @builtins.property
    @jsii.member(jsii_name="sessionStore")
    def session_store(self) -> typing.Optional["ISessionStore"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.Optional["ISessionStore"], jsii.get(self, "sessionStore"))


@jsii.enum(jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.InvokeType")
class InvokeType(enum.Enum):
    '''(experimental) Agent invocation type enumeration.

    Defines the processing mode for the agent.
    Must match the Python InvokeType enum in batch.py.

    :stability: experimental
    '''

    BATCH = "BATCH"
    '''(experimental) Batch processing mode - processes one document at a time.

    Default mode for most agent operations.

    :stability: experimental
    '''
    INTERACTIVE = "INTERACTIVE"
    '''(experimental) Interactive conversation mode (future).

    For real-time chat and conversational interfaces.

    :stability: experimental
    '''
    ATTACH_DIRECTLY = "ATTACH_DIRECTLY"
    '''(experimental) Direct invocation mode.

    Used for RAG applications, API endpoints, and direct agent calls.

    :stability: experimental
    '''
    CLASSIFICATION = "CLASSIFICATION"
    '''(experimental) Document classification step.

    Used in document processing workflows for classification phase.

    :stability: experimental
    '''
    PROCESSING = "PROCESSING"
    '''(experimental) Document processing step.

    Used in document processing workflows for extraction/processing phase.

    :stability: experimental
    '''
    AGGREGATION = "AGGREGATION"
    '''(experimental) Document aggregation step.

    Used in document processing workflows for aggregating chunked results.

    :stability: experimental
    '''


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.KnowledgeBaseRuntimeConfig",
    jsii_struct_bases=[],
    name_mapping={
        "description": "description",
        "name": "name",
        "retrieval": "retrieval",
        "acl": "acl",
        "guardrail": "guardrail",
        "knowledge_base_arn": "knowledgeBaseArn",
        "knowledge_base_id": "knowledgeBaseId",
        "type": "type",
        "vector_store": "vectorStore",
    },
)
class KnowledgeBaseRuntimeConfig:
    def __init__(
        self,
        *,
        description: builtins.str,
        name: builtins.str,
        retrieval: typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]],
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        knowledge_base_arn: typing.Optional[builtins.str] = None,
        knowledge_base_id: typing.Optional[builtins.str] = None,
        type: typing.Optional[builtins.str] = None,
        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Runtime configuration exported for the retrieval tool.

        This interface defines the structure of the configuration object
        that is serialized and passed to the retrieval tool via environment
        variables. It contains all information needed to query the knowledge
        base at runtime.

        :param description: (experimental) Description of what this knowledge base contains.
        :param name: (experimental) Human-readable name for this knowledge base.
        :param retrieval: (experimental) Retrieval configuration.
        :param acl: (experimental) ACL configuration for identity-aware retrieval.
        :param guardrail: (experimental) Guardrail configuration (for Bedrock implementations).
        :param knowledge_base_arn: (experimental) Bedrock Knowledge Base ARN (for Bedrock implementations).
        :param knowledge_base_id: (experimental) Bedrock Knowledge Base ID (for Bedrock implementations).
        :param type: (experimental) Type of knowledge base implementation. Used by the retrieval tool to determine how to query the KB.
        :param vector_store: (experimental) Vector store configuration (for Bedrock implementations).

        :stability: experimental
        '''
        if isinstance(retrieval, dict):
            retrieval = RetrievalConfiguration(**retrieval)
        if isinstance(acl, dict):
            acl = AclConfiguration(**acl)
        if isinstance(guardrail, dict):
            guardrail = GuardrailConfiguration(**guardrail)
        if isinstance(vector_store, dict):
            vector_store = VectorStoreConfiguration(**vector_store)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__eba4c5624b16f91d89be2a09eeaf9e99f078cde0dfdfdaa2d50e663d366ce5a1)
            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
            check_type(argname="argument retrieval", value=retrieval, expected_type=type_hints["retrieval"])
            check_type(argname="argument acl", value=acl, expected_type=type_hints["acl"])
            check_type(argname="argument guardrail", value=guardrail, expected_type=type_hints["guardrail"])
            check_type(argname="argument knowledge_base_arn", value=knowledge_base_arn, expected_type=type_hints["knowledge_base_arn"])
            check_type(argname="argument knowledge_base_id", value=knowledge_base_id, expected_type=type_hints["knowledge_base_id"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
            check_type(argname="argument vector_store", value=vector_store, expected_type=type_hints["vector_store"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "description": description,
            "name": name,
            "retrieval": retrieval,
        }
        if acl is not None:
            self._values["acl"] = acl
        if guardrail is not None:
            self._values["guardrail"] = guardrail
        if knowledge_base_arn is not None:
            self._values["knowledge_base_arn"] = knowledge_base_arn
        if knowledge_base_id is not None:
            self._values["knowledge_base_id"] = knowledge_base_id
        if type is not None:
            self._values["type"] = type
        if vector_store is not None:
            self._values["vector_store"] = vector_store

    @builtins.property
    def description(self) -> builtins.str:
        '''(experimental) Description of what this knowledge base contains.

        :stability: experimental
        '''
        result = self._values.get("description")
        assert result is not None, "Required property 'description' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name for this knowledge base.

        :stability: experimental
        '''
        result = self._values.get("name")
        assert result is not None, "Required property 'name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def retrieval(self) -> "RetrievalConfiguration":
        '''(experimental) Retrieval configuration.

        :stability: experimental
        '''
        result = self._values.get("retrieval")
        assert result is not None, "Required property 'retrieval' is missing"
        return typing.cast("RetrievalConfiguration", result)

    @builtins.property
    def acl(self) -> typing.Optional["AclConfiguration"]:
        '''(experimental) ACL configuration for identity-aware retrieval.

        :stability: experimental
        '''
        result = self._values.get("acl")
        return typing.cast(typing.Optional["AclConfiguration"], result)

    @builtins.property
    def guardrail(self) -> typing.Optional["GuardrailConfiguration"]:
        '''(experimental) Guardrail configuration (for Bedrock implementations).

        :stability: experimental
        '''
        result = self._values.get("guardrail")
        return typing.cast(typing.Optional["GuardrailConfiguration"], result)

    @builtins.property
    def knowledge_base_arn(self) -> typing.Optional[builtins.str]:
        '''(experimental) Bedrock Knowledge Base ARN (for Bedrock implementations).

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_arn")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def knowledge_base_id(self) -> typing.Optional[builtins.str]:
        '''(experimental) Bedrock Knowledge Base ID (for Bedrock implementations).

        :stability: experimental
        '''
        result = self._values.get("knowledge_base_id")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def type(self) -> typing.Optional[builtins.str]:
        '''(experimental) Type of knowledge base implementation.

        Used by the retrieval tool to determine how to query the KB.

        :stability: experimental

        Example::

            'bedrock'
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def vector_store(self) -> typing.Optional["VectorStoreConfiguration"]:
        '''(experimental) Vector store configuration (for Bedrock implementations).

        :stability: experimental
        '''
        result = self._values.get("vector_store")
        return typing.cast(typing.Optional["VectorStoreConfiguration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "KnowledgeBaseRuntimeConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IHostingAdapter)
class LambdaHostingAdapter(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaHostingAdapter",
):
    '''(experimental) Lambda hosting adapter for InteractiveAgent.

    Deploys the agent as a Lambda function behind Lambda Web Adapter and API Gateway
    REST API with response streaming. This is the default hosting backend.


    Architecture

    Example::

       Client → POST /chat → API Gateway REST API (STREAM) → Lambda (FastAPI + LWA) → Bedrock
       Client ← SSE stream ← API Gateway ← Lambda response streaming ← Agent tokens

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        authenticator: typing.Optional["IAuthenticator"] = None,
        communication_adapter: typing.Optional["ICommunicationAdapter"] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''
        :param architecture: (experimental) Lambda function architecture. Default: Architecture.X86_64
        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: CognitoAuthenticator
        :param communication_adapter: (experimental) Communication adapter for client-agent interaction. Default: StreamingHttpAdapter
        :param memory_size: (experimental) Lambda function memory size in MB. Default: 1024
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions for the Lambda function. Default: No reserved concurrency
        :param timeout: (experimental) Lambda function timeout. Default: Duration.minutes(15)

        :stability: experimental
        '''
        props = LambdaHostingAdapterProps(
            architecture=architecture,
            authenticator=authenticator,
            communication_adapter=communication_adapter,
            memory_size=memory_size,
            reserved_concurrent_executions=reserved_concurrent_executions,
            timeout=timeout,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="deploy")
    def deploy(
        self,
        *,
        agent_name: builtins.str,
        agent_role: "_aws_cdk_aws_iam_ceddda9d.Role",
        encryption_key: "_aws_cdk_aws_kms_ceddda9d.Key",
        environment: typing.Mapping[builtins.str, builtins.str],
        scope: "_constructs_77d1e7e8.Construct",
        system_prompt_bucket: builtins.str,
        system_prompt_key: builtins.str,
        tools_config: builtins.str,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        knowledge_base_configs: typing.Optional[builtins.str] = None,
        knowledge_base_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> "AgentHostingResult":
        '''(experimental) Deploy Lambda + LWA + API Gateway hosting infrastructure.

        :param agent_name: (experimental) Agent name identifier.
        :param agent_role: (experimental) IAM role for the agent runtime.
        :param encryption_key: (experimental) KMS encryption key.
        :param environment: (experimental) Environment variables to set on the runtime.
        :param scope: (experimental) CDK scope for creating resources.
        :param system_prompt_bucket: (experimental) System prompt S3 bucket name.
        :param system_prompt_key: (experimental) System prompt S3 key.
        :param tools_config: (experimental) Agent tools location definitions (JSON serialized).
        :param architecture: (experimental) Lambda architecture (Lambda hosting only).
        :param enable_observability: (experimental) Whether observability is enabled.
        :param knowledge_base_configs: (experimental) Knowledge base configs (JSON serialized).
        :param knowledge_base_layers: (experimental) Lambda layers from knowledge bases (Lambda hosting only).
        :param knowledge_base_system_prompt_addition: (experimental) Knowledge base system prompt addition.
        :param lambda_layers: (experimental) Lambda layers from agent definition (Lambda hosting only).
        :param memory_size: (experimental) Lambda memory size in MB (Lambda hosting only).
        :param network: (experimental) Optional VPC network configuration.
        :param removal_policy: (experimental) Removal policy for resources.
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions (Lambda hosting only).
        :param timeout: (experimental) Lambda timeout (Lambda hosting only).

        :stability: experimental
        '''
        config = AgentHostingConfig(
            agent_name=agent_name,
            agent_role=agent_role,
            encryption_key=encryption_key,
            environment=environment,
            scope=scope,
            system_prompt_bucket=system_prompt_bucket,
            system_prompt_key=system_prompt_key,
            tools_config=tools_config,
            architecture=architecture,
            enable_observability=enable_observability,
            knowledge_base_configs=knowledge_base_configs,
            knowledge_base_layers=knowledge_base_layers,
            knowledge_base_system_prompt_addition=knowledge_base_system_prompt_addition,
            lambda_layers=lambda_layers,
            memory_size=memory_size,
            network=network,
            removal_policy=removal_policy,
            reserved_concurrent_executions=reserved_concurrent_executions,
            timeout=timeout,
        )

        return typing.cast("AgentHostingResult", jsii.invoke(self, "deploy", [config]))

    @builtins.property
    @jsii.member(jsii_name="servicePrincipal")
    def service_principal(self) -> "_aws_cdk_aws_iam_ceddda9d.ServicePrincipal":
        '''(experimental) The IAM service principal that this hosting backend requires.

        BaseAgent uses this to create the agent role with the correct trust policy.
        For example, Lambda hosting requires ``lambda.amazonaws.com`` while AgentCore
        hosting requires ``bedrock-agentcore.amazonaws.com``.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.ServicePrincipal", jsii.get(self, "servicePrincipal"))

    @builtins.property
    @jsii.member(jsii_name="authenticator")
    def authenticator(self) -> typing.Optional["IAuthenticator"]:
        '''(experimental) The authenticator.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["IAuthenticator"], jsii.get(self, "authenticator"))

    @builtins.property
    @jsii.member(jsii_name="communicationAdapter")
    def communication_adapter(self) -> typing.Optional["ICommunicationAdapter"]:
        '''(experimental) The communication adapter.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["ICommunicationAdapter"], jsii.get(self, "communicationAdapter"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaHostingAdapterProps",
    jsii_struct_bases=[],
    name_mapping={
        "architecture": "architecture",
        "authenticator": "authenticator",
        "communication_adapter": "communicationAdapter",
        "memory_size": "memorySize",
        "reserved_concurrent_executions": "reservedConcurrentExecutions",
        "timeout": "timeout",
    },
)
class LambdaHostingAdapterProps:
    def __init__(
        self,
        *,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        authenticator: typing.Optional["IAuthenticator"] = None,
        communication_adapter: typing.Optional["ICommunicationAdapter"] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Configuration properties for LambdaHostingAdapter.

        :param architecture: (experimental) Lambda function architecture. Default: Architecture.X86_64
        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: CognitoAuthenticator
        :param communication_adapter: (experimental) Communication adapter for client-agent interaction. Default: StreamingHttpAdapter
        :param memory_size: (experimental) Lambda function memory size in MB. Default: 1024
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions for the Lambda function. Default: No reserved concurrency
        :param timeout: (experimental) Lambda function timeout. Default: Duration.minutes(15)

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__96940ead4b065d7e4d6589f754fa6f39078d700f1938bb78866805fe4c09c540)
            check_type(argname="argument architecture", value=architecture, expected_type=type_hints["architecture"])
            check_type(argname="argument authenticator", value=authenticator, expected_type=type_hints["authenticator"])
            check_type(argname="argument communication_adapter", value=communication_adapter, expected_type=type_hints["communication_adapter"])
            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
            check_type(argname="argument reserved_concurrent_executions", value=reserved_concurrent_executions, expected_type=type_hints["reserved_concurrent_executions"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if architecture is not None:
            self._values["architecture"] = architecture
        if authenticator is not None:
            self._values["authenticator"] = authenticator
        if communication_adapter is not None:
            self._values["communication_adapter"] = communication_adapter
        if memory_size is not None:
            self._values["memory_size"] = memory_size
        if reserved_concurrent_executions is not None:
            self._values["reserved_concurrent_executions"] = reserved_concurrent_executions
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) Lambda function architecture.

        :default: Architecture.X86_64

        :stability: experimental
        '''
        result = self._values.get("architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def authenticator(self) -> typing.Optional["IAuthenticator"]:
        '''(experimental) Authenticator for securing API endpoints.

        :default: CognitoAuthenticator

        :stability: experimental
        '''
        result = self._values.get("authenticator")
        return typing.cast(typing.Optional["IAuthenticator"], result)

    @builtins.property
    def communication_adapter(self) -> typing.Optional["ICommunicationAdapter"]:
        '''(experimental) Communication adapter for client-agent interaction.

        :default: StreamingHttpAdapter

        :stability: experimental
        '''
        result = self._values.get("communication_adapter")
        return typing.cast(typing.Optional["ICommunicationAdapter"], result)

    @builtins.property
    def memory_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Lambda function memory size in MB.

        :default: 1024

        :stability: experimental
        '''
        result = self._values.get("memory_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def reserved_concurrent_executions(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Reserved concurrent executions for the Lambda function.

        :default: No reserved concurrency

        :stability: experimental
        '''
        result = self._values.get("reserved_concurrent_executions")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Lambda function timeout.

        :default: Duration.minutes(15)

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaHostingAdapterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LambdaIamUtils(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaIamUtils",
):
    '''(experimental) Utility class for creating secure Lambda IAM policy statements with minimal permissions.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="createDynamoDbPolicyStatement")
    @builtins.classmethod
    def create_dynamo_db_policy_statement(
        cls,
        table_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for DynamoDB table access.

        :param table_arn: The ARN of the DynamoDB table.
        :param actions: The DynamoDB actions to allow.

        :return: PolicyStatement for DynamoDB access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8fea74c9846ad0c5bdddcbfe10063247cb7bcf58aac91e0be80d1226246784e4)
            check_type(argname="argument table_arn", value=table_arn, expected_type=type_hints["table_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createDynamoDbPolicyStatement", [table_arn, actions]))

    @jsii.member(jsii_name="createKmsPolicyStatement")
    @builtins.classmethod
    def create_kms_policy_statement(
        cls,
        key_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for KMS key access.

        :param key_arn: The ARN of the KMS key.
        :param actions: The KMS actions to allow.

        :return: PolicyStatement for KMS access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__ef86294be8c776ba98bebc269fab82304f75649efab35cf030d999168ba5d690)
            check_type(argname="argument key_arn", value=key_arn, expected_type=type_hints["key_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createKmsPolicyStatement", [key_arn, actions]))

    @jsii.member(jsii_name="createLogsPermissions")
    @builtins.classmethod
    def create_logs_permissions(
        cls,
        *,
        account: builtins.str,
        function_name: builtins.str,
        region: builtins.str,
        scope: "_constructs_77d1e7e8.Construct",
        enable_observability: typing.Optional[builtins.bool] = None,
        log_group_name: typing.Optional[builtins.str] = None,
    ) -> "LambdaLogsPermissionsResult":
        '''(experimental) Creates CloudWatch Logs policy statements for Lambda execution.

        :param account: (experimental) AWS account ID for the log group ARN.
        :param function_name: (experimental) The base name of the Lambda function.
        :param region: (experimental) AWS region for the log group ARN.
        :param scope: (experimental) The construct scope (used to generate unique names).
        :param enable_observability: (experimental) Whether observability is enabled or not. This would have an impact on the result IAM policy for the LogGroup for the Lambda function Default: false
        :param log_group_name: (experimental) Custom log group name pattern. Default: '/aws/lambda/{uniqueFunctionName}'

        :return: Object containing policy statements and the unique function name

        :stability: experimental
        '''
        props = LambdaLogsPermissionsProps(
            account=account,
            function_name=function_name,
            region=region,
            scope=scope,
            enable_observability=enable_observability,
            log_group_name=log_group_name,
        )

        return typing.cast("LambdaLogsPermissionsResult", jsii.sinvoke(cls, "createLogsPermissions", [props]))

    @jsii.member(jsii_name="createS3PolicyStatement")
    @builtins.classmethod
    def create_s3_policy_statement(
        cls,
        bucket_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
        include_objects: typing.Optional[builtins.bool] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for S3 bucket access.

        :param bucket_arn: The ARN of the S3 bucket.
        :param actions: The S3 actions to allow.
        :param include_objects: Whether to include object-level permissions.

        :return: PolicyStatement for S3 access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7762a976633c1cec438c3058cfc410cab5cdbf541350c2fdcb64bcfd9599e7fb)
            check_type(argname="argument bucket_arn", value=bucket_arn, expected_type=type_hints["bucket_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
            check_type(argname="argument include_objects", value=include_objects, expected_type=type_hints["include_objects"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createS3PolicyStatement", [bucket_arn, actions, include_objects]))

    @jsii.member(jsii_name="createSecretsManagerPolicyStatement")
    @builtins.classmethod
    def create_secrets_manager_policy_statement(
        cls,
        secret_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for Secrets Manager access.

        :param secret_arn: The ARN of the secret.
        :param actions: The Secrets Manager actions to allow.

        :return: PolicyStatement for Secrets Manager access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cb1398e35974542f1ff1f03b7872981aa0ef2bb90eed20673a20914f5c7e567c)
            check_type(argname="argument secret_arn", value=secret_arn, expected_type=type_hints["secret_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createSecretsManagerPolicyStatement", [secret_arn, actions]))

    @jsii.member(jsii_name="createSnsPolicyStatement")
    @builtins.classmethod
    def create_sns_policy_statement(
        cls,
        topic_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for SNS topic access.

        :param topic_arn: The ARN of the SNS topic.
        :param actions: The SNS actions to allow.

        :return: PolicyStatement for SNS access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8aa3558a2d320688189fd59ffa216e00f3b66d4b1a02026a2dc9bd5fd61c5f36)
            check_type(argname="argument topic_arn", value=topic_arn, expected_type=type_hints["topic_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createSnsPolicyStatement", [topic_arn, actions]))

    @jsii.member(jsii_name="createSqsPolicyStatement")
    @builtins.classmethod
    def create_sqs_policy_statement(
        cls,
        queue_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for SQS queue access.

        :param queue_arn: The ARN of the SQS queue.
        :param actions: The SQS actions to allow.

        :return: PolicyStatement for SQS access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5ed421dddfcb3e375ee01a9efb4d503dd54b5351b630f200cd829438bb6c9c89)
            check_type(argname="argument queue_arn", value=queue_arn, expected_type=type_hints["queue_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createSqsPolicyStatement", [queue_arn, actions]))

    @jsii.member(jsii_name="createStepFunctionsPolicyStatement")
    @builtins.classmethod
    def create_step_functions_policy_statement(
        cls,
        state_machine_arn: builtins.str,
        actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''(experimental) Creates a policy statement for Step Functions execution.

        :param state_machine_arn: The ARN of the Step Functions state machine.
        :param actions: The Step Functions actions to allow.

        :return: PolicyStatement for Step Functions access

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__cbdc1926ad0aa5c4b79aa48c962c929c8e50b7236860f58373b511defa1fca97)
            check_type(argname="argument state_machine_arn", value=state_machine_arn, expected_type=type_hints["state_machine_arn"])
            check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "createStepFunctionsPolicyStatement", [state_machine_arn, actions]))

    @jsii.member(jsii_name="createVpcPermissions")
    @builtins.classmethod
    def create_vpc_permissions(
        cls,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Creates VPC permissions for Lambda functions running in VPC.

        :return: Array of IAM PolicyStatements for VPC access

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.sinvoke(cls, "createVpcPermissions", []))

    @jsii.member(jsii_name="createXRayPermissions")
    @builtins.classmethod
    def create_x_ray_permissions(
        cls,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Creates X-Ray tracing permissions for Lambda functions.

        :return: Array of IAM PolicyStatements for X-Ray tracing

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.sinvoke(cls, "createXRayPermissions", []))

    @jsii.member(jsii_name="generateLambdaVPCPermissions")
    @builtins.classmethod
    def generate_lambda_vpc_permissions(
        cls,
    ) -> "_aws_cdk_aws_iam_ceddda9d.PolicyStatement":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.PolicyStatement", jsii.sinvoke(cls, "generateLambdaVPCPermissions", []))

    @jsii.member(jsii_name="generateUniqueFunctionName")
    @builtins.classmethod
    def generate_unique_function_name(
        cls,
        scope: "_constructs_77d1e7e8.Construct",
        base_name: builtins.str,
    ) -> builtins.str:
        '''(experimental) Generates a unique function name using CDK's built-in functionality.

        :param scope: The construct scope.
        :param base_name: The base name for the function.

        :return: Unique function name

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__56aa9ee6986a4b2052d36311105a3c43214029d77a8db5f3ca96f5b23dd95f36)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument base_name", value=base_name, expected_type=type_hints["base_name"])
        return typing.cast(builtins.str, jsii.sinvoke(cls, "generateUniqueFunctionName", [scope, base_name]))

    @jsii.member(jsii_name="getStackInfo")
    @builtins.classmethod
    def get_stack_info(
        cls,
        scope: "_constructs_77d1e7e8.Construct",
    ) -> "LambdaIamUtilsStackInfo":
        '''(experimental) Helper method to get region and account from a construct.

        :param scope: The construct scope.

        :return: LambdaIamUtilsStackInfo

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__555f78633564658fa9ba3d47cbfcf9615db101bbba832804f67bcce2b828f673)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        return typing.cast("LambdaIamUtilsStackInfo", jsii.sinvoke(cls, "getStackInfo", [scope]))

    @jsii.python.classproperty
    @jsii.member(jsii_name="OBSERVABILITY_SUFFIX")
    def OBSERVABILITY_SUFFIX(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "OBSERVABILITY_SUFFIX"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaIamUtilsStackInfo",
    jsii_struct_bases=[],
    name_mapping={"account": "account", "region": "region"},
)
class LambdaIamUtilsStackInfo:
    def __init__(self, *, account: builtins.str, region: builtins.str) -> None:
        '''(experimental) Stack information.

        :param account: 
        :param region: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1dcdad24849926b01541cd5e3a49b2718bca23f70268629b13a2467789ce6acc)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "account": account,
            "region": region,
        }

    @builtins.property
    def account(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("account")
        assert result is not None, "Required property 'account' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def region(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("region")
        assert result is not None, "Required property 'region' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaIamUtilsStackInfo(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaLogsPermissionsProps",
    jsii_struct_bases=[],
    name_mapping={
        "account": "account",
        "function_name": "functionName",
        "region": "region",
        "scope": "scope",
        "enable_observability": "enableObservability",
        "log_group_name": "logGroupName",
    },
)
class LambdaLogsPermissionsProps:
    def __init__(
        self,
        *,
        account: builtins.str,
        function_name: builtins.str,
        region: builtins.str,
        scope: "_constructs_77d1e7e8.Construct",
        enable_observability: typing.Optional[builtins.bool] = None,
        log_group_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Configuration options for Lambda CloudWatch Logs permissions.

        :param account: (experimental) AWS account ID for the log group ARN.
        :param function_name: (experimental) The base name of the Lambda function.
        :param region: (experimental) AWS region for the log group ARN.
        :param scope: (experimental) The construct scope (used to generate unique names).
        :param enable_observability: (experimental) Whether observability is enabled or not. This would have an impact on the result IAM policy for the LogGroup for the Lambda function Default: false
        :param log_group_name: (experimental) Custom log group name pattern. Default: '/aws/lambda/{uniqueFunctionName}'

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__47564dc2777638ca33ba53983ac385b2dd8b03133d66569da912ae1ce7e55503)
            check_type(argname="argument account", value=account, expected_type=type_hints["account"])
            check_type(argname="argument function_name", value=function_name, expected_type=type_hints["function_name"])
            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument log_group_name", value=log_group_name, expected_type=type_hints["log_group_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "account": account,
            "function_name": function_name,
            "region": region,
            "scope": scope,
        }
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if log_group_name is not None:
            self._values["log_group_name"] = log_group_name

    @builtins.property
    def account(self) -> builtins.str:
        '''(experimental) AWS account ID for the log group ARN.

        :stability: experimental
        '''
        result = self._values.get("account")
        assert result is not None, "Required property 'account' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def function_name(self) -> builtins.str:
        '''(experimental) The base name of the Lambda function.

        :stability: experimental
        '''
        result = self._values.get("function_name")
        assert result is not None, "Required property 'function_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def region(self) -> builtins.str:
        '''(experimental) AWS region for the log group ARN.

        :stability: experimental
        '''
        result = self._values.get("region")
        assert result is not None, "Required property 'region' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def scope(self) -> "_constructs_77d1e7e8.Construct":
        '''(experimental) The construct scope (used to generate unique names).

        :stability: experimental
        '''
        result = self._values.get("scope")
        assert result is not None, "Required property 'scope' is missing"
        return typing.cast("_constructs_77d1e7e8.Construct", result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Whether observability is enabled or not.

        This would have an impact
        on the result IAM policy for the LogGroup for the Lambda function

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def log_group_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom log group name pattern.

        :default: '/aws/lambda/{uniqueFunctionName}'

        :stability: experimental
        '''
        result = self._values.get("log_group_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaLogsPermissionsProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaLogsPermissionsResult",
    jsii_struct_bases=[],
    name_mapping={
        "policy_statements": "policyStatements",
        "unique_function_name": "uniqueFunctionName",
    },
)
class LambdaLogsPermissionsResult:
    def __init__(
        self,
        *,
        policy_statements: typing.Sequence["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"],
        unique_function_name: builtins.str,
    ) -> None:
        '''(experimental) Result of creating Lambda logs permissions.

        :param policy_statements: (experimental) The policy statements for CloudWatch Logs.
        :param unique_function_name: (experimental) The unique function name that was generated.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__2180e53f0ba520cfa92d16443491985db8ed304d09797b9d758ad70b55d7b617)
            check_type(argname="argument policy_statements", value=policy_statements, expected_type=type_hints["policy_statements"])
            check_type(argname="argument unique_function_name", value=unique_function_name, expected_type=type_hints["unique_function_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "policy_statements": policy_statements,
            "unique_function_name": unique_function_name,
        }

    @builtins.property
    def policy_statements(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) The policy statements for CloudWatch Logs.

        :stability: experimental
        '''
        result = self._values.get("policy_statements")
        assert result is not None, "Required property 'policy_statements' is missing"
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], result)

    @builtins.property
    def unique_function_name(self) -> builtins.str:
        '''(experimental) The unique function name that was generated.

        :stability: experimental
        '''
        result = self._values.get("unique_function_name")
        assert result is not None, "Required property 'unique_function_name' is missing"
        return typing.cast(builtins.str, result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LambdaLogsPermissionsResult(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_aws_cdk_ceddda9d.IPropertyInjector)
class LambdaObservabilityPropertyInjector(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LambdaObservabilityPropertyInjector",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        data_protection_identifiers: typing.Optional[typing.Sequence["_aws_cdk_aws_logs_ceddda9d.DataIdentifier"]] = None,
        log_group_encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
    ) -> None:
        '''
        :param data_protection_identifiers: (experimental) List of DataIdentifiers that would be used as part of the Data Protection Policy that would be created for the log group. Default: Data Protection Policy won't be enabled
        :param log_group_encryption_key: (experimental) Encryption key that would be used to encrypt the relevant log group. Default: a new KMS key would automatically be created

        :stability: experimental
        '''
        log_group_data_protection = LogGroupDataProtectionProps(
            data_protection_identifiers=data_protection_identifiers,
            log_group_encryption_key=log_group_encryption_key,
        )

        jsii.create(self.__class__, self, [log_group_data_protection])

    @jsii.member(jsii_name="inject")
    def inject(
        self,
        original_props: typing.Any,
        *,
        id: builtins.str,
        scope: "_constructs_77d1e7e8.Construct",
    ) -> typing.Any:
        '''(experimental) The injector to be applied to the constructor properties of the Construct.

        :param original_props: -
        :param id: id from the Construct constructor.
        :param scope: scope from the constructor.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__97c5107ef8c7184168153144168438a4ff4ae054305d1a82db0a0514c98b6d0b)
            check_type(argname="argument original_props", value=original_props, expected_type=type_hints["original_props"])
        _context = _aws_cdk_ceddda9d.InjectionContext(id=id, scope=scope)

        return typing.cast(typing.Any, jsii.invoke(self, "inject", [original_props, _context]))

    @builtins.property
    @jsii.member(jsii_name="constructUniqueId")
    def construct_unique_id(self) -> builtins.str:
        '''(experimental) The unique Id of the Construct class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "constructUniqueId"))

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''
        :stability: experimental
        '''
        return typing.cast("LogGroupDataProtectionProps", jsii.get(self, "logGroupDataProtection"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LogGroupDataProtectionProps",
    jsii_struct_bases=[],
    name_mapping={
        "data_protection_identifiers": "dataProtectionIdentifiers",
        "log_group_encryption_key": "logGroupEncryptionKey",
    },
)
class LogGroupDataProtectionProps:
    def __init__(
        self,
        *,
        data_protection_identifiers: typing.Optional[typing.Sequence["_aws_cdk_aws_logs_ceddda9d.DataIdentifier"]] = None,
        log_group_encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
    ) -> None:
        '''(experimental) Props to enable various data protection configuration for CloudWatch Log Groups.

        :param data_protection_identifiers: (experimental) List of DataIdentifiers that would be used as part of the Data Protection Policy that would be created for the log group. Default: Data Protection Policy won't be enabled
        :param log_group_encryption_key: (experimental) Encryption key that would be used to encrypt the relevant log group. Default: a new KMS key would automatically be created

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__544372751dab1bedee4ed043bef50312abd2658c1142e4b4809c0617165dc597)
            check_type(argname="argument data_protection_identifiers", value=data_protection_identifiers, expected_type=type_hints["data_protection_identifiers"])
            check_type(argname="argument log_group_encryption_key", value=log_group_encryption_key, expected_type=type_hints["log_group_encryption_key"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if data_protection_identifiers is not None:
            self._values["data_protection_identifiers"] = data_protection_identifiers
        if log_group_encryption_key is not None:
            self._values["log_group_encryption_key"] = log_group_encryption_key

    @builtins.property
    def data_protection_identifiers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_logs_ceddda9d.DataIdentifier"]]:
        '''(experimental) List of DataIdentifiers that would be used as part of the Data Protection Policy that would be created for the log group.

        :default: Data Protection Policy won't be enabled

        :stability: experimental
        '''
        result = self._values.get("data_protection_identifiers")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_logs_ceddda9d.DataIdentifier"]], result)

    @builtins.property
    def log_group_encryption_key(
        self,
    ) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) Encryption key that would be used to encrypt the relevant log group.

        :default: a new KMS key would automatically be created

        :stability: experimental
        '''
        result = self._values.get("log_group_encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "LogGroupDataProtectionProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class LogGroupDataProtectionUtils(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.LogGroupDataProtectionUtils",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="handleDefault")
    @builtins.classmethod
    def handle_default(
        cls,
        scope: "_constructs_77d1e7e8.Construct",
        props: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
    ) -> "LogGroupDataProtectionProps":
        '''
        :param scope: -
        :param props: -
        :param removal_policy: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e3a45e54ca44da7f036d13ce54f925e2a16d4e1ae6f2df04d64a1f10ca0133f0)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
        return typing.cast("LogGroupDataProtectionProps", jsii.sinvoke(cls, "handleDefault", [scope, props, removal_policy]))


class Network(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.Network",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        existing_vpc: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IVpc"] = None,
        ip_addresses: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IIpAddresses"] = None,
        max_azs: typing.Optional[jsii.Number] = None,
        nat_gateway_provider: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.NatProvider"] = None,
        nat_gateways: typing.Optional[jsii.Number] = None,
        nat_gateway_subnets: typing.Optional[typing.Union["_aws_cdk_aws_ec2_ceddda9d.SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
        private: typing.Optional[builtins.bool] = None,
        subnet_configuration: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param existing_vpc: 
        :param ip_addresses: 
        :param max_azs: 
        :param nat_gateway_provider: 
        :param nat_gateways: 
        :param nat_gateway_subnets: 
        :param private: 
        :param subnet_configuration: 
        :param vpc_name: 

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6ad9a3df68ffea56f493c494b7c642fca53d11a7de99864bb5e94dffe00ed330)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = NetworkProps(
            existing_vpc=existing_vpc,
            ip_addresses=ip_addresses,
            max_azs=max_azs,
            nat_gateway_provider=nat_gateway_provider,
            nat_gateways=nat_gateways,
            nat_gateway_subnets=nat_gateway_subnets,
            private=private,
            subnet_configuration=subnet_configuration,
            vpc_name=vpc_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="useExistingVPCFromLookup")
    @builtins.classmethod
    def use_existing_vpc_from_lookup(
        cls,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        is_default: typing.Optional[builtins.bool] = None,
        owner_account_id: typing.Optional[builtins.str] = None,
        region: typing.Optional[builtins.str] = None,
        return_vpn_gateways: typing.Optional[builtins.bool] = None,
        subnet_group_name_tag: typing.Optional[builtins.str] = None,
        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
        vpc_id: typing.Optional[builtins.str] = None,
        vpc_name: typing.Optional[builtins.str] = None,
    ) -> "Network":
        '''
        :param scope: -
        :param id: -
        :param is_default: Whether to match the default VPC. Default: Don't care whether we return the default VPC
        :param owner_account_id: The ID of the AWS account that owns the VPC. Default: the account id of the parent stack
        :param region: Optional to override inferred region. Default: Current stack's environment region
        :param return_vpn_gateways: Whether to look up whether a VPN Gateway is attached to the looked up VPC. You can set this to ``false`` if you know the VPC does not have a VPN Gateway attached, in order to avoid an API call. If you change this property from ``false`` to ``true`` or undefined, you may need to clear the corresponding context entry in ``cdk.context.json`` in order to trigger a new lookup. Default: true
        :param subnet_group_name_tag: Optional tag for subnet group name. If not provided, we'll look at the aws-cdk:subnet-name tag. If the subnet does not have the specified tag, we'll use its type as the name. Default: aws-cdk:subnet-name
        :param tags: Tags on the VPC. The VPC must have all of these tags Default: Don't filter on tags
        :param vpc_id: The ID of the VPC. If given, will import exactly this VPC. Default: Don't filter on vpcId
        :param vpc_name: The name of the VPC. If given, will import the VPC with this name. Default: Don't filter on vpcName

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8ef7c59482181ed4f28e171f52faec6a945cf35a038a8cc79fda7c3b5e028c5e)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        options = _aws_cdk_aws_ec2_ceddda9d.VpcLookupOptions(
            is_default=is_default,
            owner_account_id=owner_account_id,
            region=region,
            return_vpn_gateways=return_vpn_gateways,
            subnet_group_name_tag=subnet_group_name_tag,
            tags=tags,
            vpc_id=vpc_id,
            vpc_name=vpc_name,
        )

        return typing.cast("Network", jsii.sinvoke(cls, "useExistingVPCFromLookup", [scope, id, options]))

    @jsii.member(jsii_name="applicationSubnetSelection")
    def application_subnet_selection(
        self,
    ) -> "_aws_cdk_aws_ec2_ceddda9d.SubnetSelection":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_ec2_ceddda9d.SubnetSelection", jsii.invoke(self, "applicationSubnetSelection", []))

    @jsii.member(jsii_name="createServiceEndpoint")
    def create_service_endpoint(
        self,
        id: builtins.str,
        service: "_aws_cdk_aws_ec2_ceddda9d.InterfaceVpcEndpointService",
        peer: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IPeer"] = None,
    ) -> "_aws_cdk_aws_ec2_ceddda9d.InterfaceVpcEndpoint":
        '''
        :param id: -
        :param service: -
        :param peer: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__014347d1e11f93271eb3a6b34bc02d137814401023f915adcd8e379b691810e9)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
            check_type(argname="argument service", value=service, expected_type=type_hints["service"])
            check_type(argname="argument peer", value=peer, expected_type=type_hints["peer"])
        return typing.cast("_aws_cdk_aws_ec2_ceddda9d.InterfaceVpcEndpoint", jsii.invoke(self, "createServiceEndpoint", [id, service, peer]))

    @builtins.property
    @jsii.member(jsii_name="vpc")
    def vpc(self) -> "_aws_cdk_aws_ec2_ceddda9d.IVpc":
        '''
        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_ec2_ceddda9d.IVpc", jsii.get(self, "vpc"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.NetworkProps",
    jsii_struct_bases=[],
    name_mapping={
        "existing_vpc": "existingVpc",
        "ip_addresses": "ipAddresses",
        "max_azs": "maxAzs",
        "nat_gateway_provider": "natGatewayProvider",
        "nat_gateways": "natGateways",
        "nat_gateway_subnets": "natGatewaySubnets",
        "private": "private",
        "subnet_configuration": "subnetConfiguration",
        "vpc_name": "vpcName",
    },
)
class NetworkProps:
    def __init__(
        self,
        *,
        existing_vpc: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IVpc"] = None,
        ip_addresses: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IIpAddresses"] = None,
        max_azs: typing.Optional[jsii.Number] = None,
        nat_gateway_provider: typing.Optional["_aws_cdk_aws_ec2_ceddda9d.NatProvider"] = None,
        nat_gateways: typing.Optional[jsii.Number] = None,
        nat_gateway_subnets: typing.Optional[typing.Union["_aws_cdk_aws_ec2_ceddda9d.SubnetSelection", typing.Dict[builtins.str, typing.Any]]] = None,
        private: typing.Optional[builtins.bool] = None,
        subnet_configuration: typing.Optional[typing.Sequence[typing.Union["_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration", typing.Dict[builtins.str, typing.Any]]]] = None,
        vpc_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param existing_vpc: 
        :param ip_addresses: 
        :param max_azs: 
        :param nat_gateway_provider: 
        :param nat_gateways: 
        :param nat_gateway_subnets: 
        :param private: 
        :param subnet_configuration: 
        :param vpc_name: 

        :stability: experimental
        '''
        if isinstance(nat_gateway_subnets, dict):
            nat_gateway_subnets = _aws_cdk_aws_ec2_ceddda9d.SubnetSelection(**nat_gateway_subnets)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0c7413b984143840b4fc2e4fe5dd9854fed611c52a71931a04773289b6f1fdde)
            check_type(argname="argument existing_vpc", value=existing_vpc, expected_type=type_hints["existing_vpc"])
            check_type(argname="argument ip_addresses", value=ip_addresses, expected_type=type_hints["ip_addresses"])
            check_type(argname="argument max_azs", value=max_azs, expected_type=type_hints["max_azs"])
            check_type(argname="argument nat_gateway_provider", value=nat_gateway_provider, expected_type=type_hints["nat_gateway_provider"])
            check_type(argname="argument nat_gateways", value=nat_gateways, expected_type=type_hints["nat_gateways"])
            check_type(argname="argument nat_gateway_subnets", value=nat_gateway_subnets, expected_type=type_hints["nat_gateway_subnets"])
            check_type(argname="argument private", value=private, expected_type=type_hints["private"])
            check_type(argname="argument subnet_configuration", value=subnet_configuration, expected_type=type_hints["subnet_configuration"])
            check_type(argname="argument vpc_name", value=vpc_name, expected_type=type_hints["vpc_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if existing_vpc is not None:
            self._values["existing_vpc"] = existing_vpc
        if ip_addresses is not None:
            self._values["ip_addresses"] = ip_addresses
        if max_azs is not None:
            self._values["max_azs"] = max_azs
        if nat_gateway_provider is not None:
            self._values["nat_gateway_provider"] = nat_gateway_provider
        if nat_gateways is not None:
            self._values["nat_gateways"] = nat_gateways
        if nat_gateway_subnets is not None:
            self._values["nat_gateway_subnets"] = nat_gateway_subnets
        if private is not None:
            self._values["private"] = private
        if subnet_configuration is not None:
            self._values["subnet_configuration"] = subnet_configuration
        if vpc_name is not None:
            self._values["vpc_name"] = vpc_name

    @builtins.property
    def existing_vpc(self) -> typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IVpc"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("existing_vpc")
        return typing.cast(typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IVpc"], result)

    @builtins.property
    def ip_addresses(self) -> typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IIpAddresses"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("ip_addresses")
        return typing.cast(typing.Optional["_aws_cdk_aws_ec2_ceddda9d.IIpAddresses"], result)

    @builtins.property
    def max_azs(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("max_azs")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def nat_gateway_provider(
        self,
    ) -> typing.Optional["_aws_cdk_aws_ec2_ceddda9d.NatProvider"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("nat_gateway_provider")
        return typing.cast(typing.Optional["_aws_cdk_aws_ec2_ceddda9d.NatProvider"], result)

    @builtins.property
    def nat_gateways(self) -> typing.Optional[jsii.Number]:
        '''
        :stability: experimental
        '''
        result = self._values.get("nat_gateways")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def nat_gateway_subnets(
        self,
    ) -> typing.Optional["_aws_cdk_aws_ec2_ceddda9d.SubnetSelection"]:
        '''
        :stability: experimental
        '''
        result = self._values.get("nat_gateway_subnets")
        return typing.cast(typing.Optional["_aws_cdk_aws_ec2_ceddda9d.SubnetSelection"], result)

    @builtins.property
    def private(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        result = self._values.get("private")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def subnet_configuration(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration"]]:
        '''
        :stability: experimental
        '''
        result = self._values.get("subnet_configuration")
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration"]], result)

    @builtins.property
    def vpc_name(self) -> typing.Optional[builtins.str]:
        '''
        :stability: experimental
        '''
        result = self._values.get("vpc_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NetworkProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IAuthenticator)
class NoAuthenticator(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.NoAuthenticator",
):
    '''(experimental) No-authentication authenticator for development and testing.

    Disables authentication entirely, allowing any client to connect
    without credentials. This should ONLY be used for development
    and testing environments.


    Security Warning

    This authenticator provides NO security. Never use in production.

    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Get environment variables for Lambda configuration.

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))

    @jsii.member(jsii_name="grantAuthenticate")
    def grant_authenticate(
        self,
        _lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) No-op for NoAuthenticator since no authentication is performed.

        :param _lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__80db949f200ae959bca982905d50ae2ab0f53027aa891dd6a0900de4c7ae5fa0)
            check_type(argname="argument _lambda_function", value=_lambda_function, expected_type=type_hints["_lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantAuthenticate", [_lambda_function]))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.NoChunkingResponse",
    jsii_struct_bases=[],
    name_mapping={
        "document_id": "documentId",
        "reason": "reason",
        "requires_chunking": "requiresChunking",
        "token_analysis": "tokenAnalysis",
    },
)
class NoChunkingResponse:
    def __init__(
        self,
        *,
        document_id: builtins.str,
        reason: builtins.str,
        requires_chunking: builtins.bool,
        token_analysis: typing.Union["TokenAnalysis", typing.Dict[builtins.str, typing.Any]],
    ) -> None:
        '''(experimental) Response when chunking is NOT required.

        Document is below thresholds and will be processed without chunking.

        :param document_id: (experimental) Document identifier.
        :param reason: (experimental) Human-readable reason why chunking was not applied. Example: "Document has 50 pages, below threshold of 100"
        :param requires_chunking: (experimental) Indicates chunking is not required.
        :param token_analysis: (experimental) Token analysis results.

        :stability: experimental
        '''
        if isinstance(token_analysis, dict):
            token_analysis = TokenAnalysis(**token_analysis)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__8f396031ae0cfeeab7a84faee503bde8ba3dca087c9bb20bc0a3ea6d2b433ac6)
            check_type(argname="argument document_id", value=document_id, expected_type=type_hints["document_id"])
            check_type(argname="argument reason", value=reason, expected_type=type_hints["reason"])
            check_type(argname="argument requires_chunking", value=requires_chunking, expected_type=type_hints["requires_chunking"])
            check_type(argname="argument token_analysis", value=token_analysis, expected_type=type_hints["token_analysis"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "document_id": document_id,
            "reason": reason,
            "requires_chunking": requires_chunking,
            "token_analysis": token_analysis,
        }

    @builtins.property
    def document_id(self) -> builtins.str:
        '''(experimental) Document identifier.

        :stability: experimental
        '''
        result = self._values.get("document_id")
        assert result is not None, "Required property 'document_id' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def reason(self) -> builtins.str:
        '''(experimental) Human-readable reason why chunking was not applied.

        Example: "Document has 50 pages, below threshold of 100"

        :stability: experimental
        '''
        result = self._values.get("reason")
        assert result is not None, "Required property 'reason' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def requires_chunking(self) -> builtins.bool:
        '''(experimental) Indicates chunking is not required.

        :stability: experimental
        '''
        result = self._values.get("requires_chunking")
        assert result is not None, "Required property 'requires_chunking' is missing"
        return typing.cast(builtins.bool, result)

    @builtins.property
    def token_analysis(self) -> "TokenAnalysis":
        '''(experimental) Token analysis results.

        :stability: experimental
        '''
        result = self._values.get("token_analysis")
        assert result is not None, "Required property 'token_analysis' is missing"
        return typing.cast("TokenAnalysis", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "NoChunkingResponse(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IContextStrategy)
class NullConversationManager(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.NullConversationManager",
):
    '''(deprecated) Null conversation manager for stateless interactions.

    Disables conversation history, treating each message as independent.
    Useful for stateless use cases where context is not needed.

    :deprecated:

    The Python handler now uses Strands-native conversation management.
    To disable conversation history, omit the session bucket configuration.

    :stability: deprecated
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(deprecated) Get environment variables for Lambda configuration.

        :stability: deprecated
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ObservableProps",
    jsii_struct_bases=[],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
    },
)
class ObservableProps:
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Additional properties that constructs implementing the IObservable interface should extend as part of their input props.

        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__31fd1e05df7b558405e183d7153d9217ec52b5d7deb1bd88be445a2930061329)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ObservableProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class PowertoolsConfig(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.PowertoolsConfig",
):
    '''
    :stability: experimental
    '''

    def __init__(self) -> None:
        '''
        :stability: experimental
        '''
        jsii.create(self.__class__, self, [])

    @jsii.member(jsii_name="generateDefaultLambdaConfig")
    @builtins.classmethod
    def generate_default_lambda_config(
        cls,
        enable_observability: typing.Optional[builtins.bool] = None,
        metrics_namespace: typing.Optional[builtins.str] = None,
        service_name: typing.Optional[builtins.str] = None,
        log_level: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Generate default Lambda configuration for Powertools.

        :param enable_observability: - Whether observability is enabled.
        :param metrics_namespace: - CloudWatch metrics namespace.
        :param service_name: - Service name for logging and metrics.
        :param log_level: - Log level (INFO, ERROR, DEBUG, WARNING). Defaults to INFO.

        :return: Record of environment variables for Lambda configuration

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__e065c545d4fce5c4fc2579c3efea8203f50b6d3c8b39aa1595ea3577d04bc025)
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument metrics_namespace", value=metrics_namespace, expected_type=type_hints["metrics_namespace"])
            check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
            check_type(argname="argument log_level", value=log_level, expected_type=type_hints["log_level"])
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.sinvoke(cls, "generateDefaultLambdaConfig", [enable_observability, metrics_namespace, service_name, log_level]))


@jsii.implements(IAdapter)
class QueuedS3Adapter(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.QueuedS3Adapter",
):
    '''(experimental) This adapter allows the intelligent document processing workflow to be triggered by files that are uploaded into a S3 Bucket.

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.Bucket"] = None,
        dlq_max_receive_count: typing.Optional[jsii.Number] = None,
        failed_prefix: typing.Optional[builtins.str] = None,
        processed_prefix: typing.Optional[builtins.str] = None,
        queue_visibility_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        raw_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param bucket: (experimental) S3 bucket for document storage with organized prefixes (raw/, processed/, failed/). If not provided, a new bucket will be created with auto-delete enabled based on removalPolicy. Default: create a new bucket
        :param dlq_max_receive_count: (experimental) The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue. Default: 5
        :param failed_prefix: (experimental) S3 prefix where the files that failed processing would be stored. Default: "failed/"
        :param processed_prefix: (experimental) S3 prefix where the processed files would be stored. Default: "processed/"
        :param queue_visibility_timeout: (experimental) SQS queue visibility timeout for processing messages. Should be longer than expected processing time to prevent duplicate processing. Default: Duration.seconds(300)
        :param raw_prefix: (experimental) S3 prefix where the raw files would be stored. This serves as the trigger point for processing Default: "raw/"

        :stability: experimental
        '''
        adapter_props = QueuedS3AdapterProps(
            bucket=bucket,
            dlq_max_receive_count=dlq_max_receive_count,
            failed_prefix=failed_prefix,
            processed_prefix=processed_prefix,
            queue_visibility_timeout=queue_visibility_timeout,
            raw_prefix=raw_prefix,
        )

        jsii.create(self.__class__, self, [adapter_props])

    @jsii.member(jsii_name="createFailedChain")
    def create_failed_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for failed processing.

        :param scope: -
        :param id_prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b95daf862a9819daa9b25cecfc08214dc429ef07ac6de3920b5dea59e01616eb)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id_prefix", value=id_prefix, expected_type=type_hints["id_prefix"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.Chain", jsii.invoke(self, "createFailedChain", [scope, id_prefix]))

    @jsii.member(jsii_name="createIngressTrigger")
    def create_ingress_trigger(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        state_machine: "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> typing.Mapping[builtins.str, typing.Any]:
        '''(experimental) Create resources that would receive the data and trigger the workflow.

        Important: resource created should trigger the state machine

        :param scope: -
        :param state_machine: -
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fb0e9adf74054c1b0a1974cab45642af57cb1651ef8052310a0229dae1eac178)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
        props = BaseDocumentProcessingProps(
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "createIngressTrigger", [scope, state_machine, props]))

    @jsii.member(jsii_name="createSuccessChain")
    def create_success_chain(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.Chain":
        '''(experimental) Create the adapter specific handler for successful processing.

        :param scope: -
        :param id_prefix: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__76aa2fd577ace3b2507bf11a33f4d039ae5ac0af0d5d3edede30c4515a1a0986)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id_prefix", value=id_prefix, expected_type=type_hints["id_prefix"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.Chain", jsii.invoke(self, "createSuccessChain", [scope, id_prefix]))

    @jsii.member(jsii_name="generateAdapterIAMPolicies")
    def generate_adapter_iam_policies(
        self,
        additional_iam_actions: typing.Optional[typing.Sequence[builtins.str]] = None,
        narrow_actions: typing.Optional[builtins.bool] = None,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM statements that can be used by other resources to access the storage.

        :param additional_iam_actions: -
        :param narrow_actions: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__308867c51abfbbc08d0fba9125db9b86eddda969dc95de8546e6f8cb242ee8a9)
            check_type(argname="argument additional_iam_actions", value=additional_iam_actions, expected_type=type_hints["additional_iam_actions"])
            check_type(argname="argument narrow_actions", value=narrow_actions, expected_type=type_hints["narrow_actions"])
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateAdapterIAMPolicies", [additional_iam_actions, narrow_actions]))

    @jsii.member(jsii_name="init")
    def init(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Initializes the adapter.

        :param scope: -
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__3fe79d0c4a3a771012bc95cea6a690155ea89fa70073f87564e65aad5cdfdb64)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
        props = BaseDocumentProcessingProps(
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        return typing.cast(None, jsii.invoke(self, "init", [scope, props]))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.QueuedS3AdapterProps",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "dlq_max_receive_count": "dlqMaxReceiveCount",
        "failed_prefix": "failedPrefix",
        "processed_prefix": "processedPrefix",
        "queue_visibility_timeout": "queueVisibilityTimeout",
        "raw_prefix": "rawPrefix",
    },
)
class QueuedS3AdapterProps:
    def __init__(
        self,
        *,
        bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.Bucket"] = None,
        dlq_max_receive_count: typing.Optional[jsii.Number] = None,
        failed_prefix: typing.Optional[builtins.str] = None,
        processed_prefix: typing.Optional[builtins.str] = None,
        queue_visibility_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        raw_prefix: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Props for the Queued S3 Adapter.

        :param bucket: (experimental) S3 bucket for document storage with organized prefixes (raw/, processed/, failed/). If not provided, a new bucket will be created with auto-delete enabled based on removalPolicy. Default: create a new bucket
        :param dlq_max_receive_count: (experimental) The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue. Default: 5
        :param failed_prefix: (experimental) S3 prefix where the files that failed processing would be stored. Default: "failed/"
        :param processed_prefix: (experimental) S3 prefix where the processed files would be stored. Default: "processed/"
        :param queue_visibility_timeout: (experimental) SQS queue visibility timeout for processing messages. Should be longer than expected processing time to prevent duplicate processing. Default: Duration.seconds(300)
        :param raw_prefix: (experimental) S3 prefix where the raw files would be stored. This serves as the trigger point for processing Default: "raw/"

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__c2db7ec0d4b3e93062e1f20f29f9821e5a0fd526ecf05f9ccaa6db663fb1e8de)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument dlq_max_receive_count", value=dlq_max_receive_count, expected_type=type_hints["dlq_max_receive_count"])
            check_type(argname="argument failed_prefix", value=failed_prefix, expected_type=type_hints["failed_prefix"])
            check_type(argname="argument processed_prefix", value=processed_prefix, expected_type=type_hints["processed_prefix"])
            check_type(argname="argument queue_visibility_timeout", value=queue_visibility_timeout, expected_type=type_hints["queue_visibility_timeout"])
            check_type(argname="argument raw_prefix", value=raw_prefix, expected_type=type_hints["raw_prefix"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if bucket is not None:
            self._values["bucket"] = bucket
        if dlq_max_receive_count is not None:
            self._values["dlq_max_receive_count"] = dlq_max_receive_count
        if failed_prefix is not None:
            self._values["failed_prefix"] = failed_prefix
        if processed_prefix is not None:
            self._values["processed_prefix"] = processed_prefix
        if queue_visibility_timeout is not None:
            self._values["queue_visibility_timeout"] = queue_visibility_timeout
        if raw_prefix is not None:
            self._values["raw_prefix"] = raw_prefix

    @builtins.property
    def bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.Bucket"]:
        '''(experimental) S3 bucket for document storage with organized prefixes (raw/, processed/, failed/).

        If not provided, a new bucket will be created with auto-delete enabled based on removalPolicy.

        :default: create a new bucket

        :stability: experimental
        '''
        result = self._values.get("bucket")
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.Bucket"], result)

    @builtins.property
    def dlq_max_receive_count(self) -> typing.Optional[jsii.Number]:
        '''(experimental) The number of times a message can be unsuccessfully dequeued before being moved to the dead-letter queue.

        :default: 5

        :stability: experimental
        '''
        result = self._values.get("dlq_max_receive_count")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def failed_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 prefix where the files that failed processing would be stored.

        :default: "failed/"

        :stability: experimental
        '''
        result = self._values.get("failed_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def processed_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 prefix where the processed files would be stored.

        :default: "processed/"

        :stability: experimental
        '''
        result = self._values.get("processed_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def queue_visibility_timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) SQS queue visibility timeout for processing messages.

        Should be longer than expected processing time to prevent duplicate processing.

        :default: Duration.seconds(300)

        :stability: experimental
        '''
        result = self._values.get("queue_visibility_timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    @builtins.property
    def raw_prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 prefix where the raw files would be stored.

        This serves as the trigger point for processing

        :default: "raw/"

        :stability: experimental
        '''
        result = self._values.get("raw_prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "QueuedS3AdapterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.RetrievalConfiguration",
    jsii_struct_bases=[],
    name_mapping={
        "number_of_results": "numberOfResults",
        "retrieval_filter": "retrievalFilter",
    },
)
class RetrievalConfiguration:
    def __init__(
        self,
        *,
        number_of_results: typing.Optional[jsii.Number] = None,
        retrieval_filter: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
    ) -> None:
        '''(experimental) Configuration for retrieval operations.

        Controls how many results are returned and optional metadata filtering
        applied to all queries against the knowledge base.

        :param number_of_results: (experimental) Number of results to return per query. Higher values provide more context but increase token usage. Lower values are faster but may miss relevant information. Default: 5
        :param retrieval_filter: (experimental) Metadata filter to apply to all queries. This filter is applied in addition to any ACL filters. Use this for static filtering based on document metadata (e.g., document type, category, or date range). Default: - No filter applied

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__0389e881defd6b748c16712149b25f1d6a9c2415742f6287f9424ffee6d97ac9)
            check_type(argname="argument number_of_results", value=number_of_results, expected_type=type_hints["number_of_results"])
            check_type(argname="argument retrieval_filter", value=retrieval_filter, expected_type=type_hints["retrieval_filter"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if number_of_results is not None:
            self._values["number_of_results"] = number_of_results
        if retrieval_filter is not None:
            self._values["retrieval_filter"] = retrieval_filter

    @builtins.property
    def number_of_results(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of results to return per query.

        Higher values provide more context but increase token usage.
        Lower values are faster but may miss relevant information.

        :default: 5

        :stability: experimental
        '''
        result = self._values.get("number_of_results")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def retrieval_filter(
        self,
    ) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
        '''(experimental) Metadata filter to apply to all queries.

        This filter is applied in addition to any ACL filters. Use this
        for static filtering based on document metadata (e.g., document type,
        category, or date range).

        :default: - No filter applied

        :stability: experimental
        '''
        result = self._values.get("retrieval_filter")
        return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "RetrievalConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(ISessionStore)
class S3SessionManager(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.S3SessionManager",
):
    '''(deprecated) S3-based session manager for persisting conversation state.

    Uses S3 for durable storage of session data with automatic expiration
    via lifecycle policies. Each HTTP request loads/saves session state,
    enabling multi-turn conversations over stateless HTTP.


    Features

    - **Durable Storage**: Sessions persisted to S3 survive Lambda restarts
    - **Automatic Expiration**: Lifecycle policy removes old sessions
    - **Encryption**: KMS encryption at rest
    - **Cost Optimization**: S3 Standard storage with lifecycle management



    Usage

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { InteractiveAgent, S3SessionManager } from '@cdklabs/cdk-appmod-catalog-blueprints';
       import { Duration } from 'aws-cdk-lib';

       const myPrompt = new Asset(this, 'Prompt', { path: './prompt.txt' });
       const sessionManager = new S3SessionManager(this, 'SessionManager', {
         sessionTTL: Duration.hours(48)
       });

       const agent = new InteractiveAgent(this, 'Agent', {
         agentName: 'ChatAgent',
         agentDefinition: { bedrockModel: {}, systemPrompt: myPrompt },
         sessionStore: sessionManager
       });

    :deprecated:

    Use Strands-native ``S3SessionManager`` from ``strands.session.s3_session_manager`` instead.
    The Python handler now uses Strands-native session management automatically.
    An S3 bucket is still created for the Strands session manager; this CDK class
    is no longer needed to configure session persistence.

    :stability: deprecated
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.IKey"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        session_ttl: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param bucket: (deprecated) S3 bucket for session storage. Default: Auto-created bucket with KMS encryption
        :param encryption_key: (deprecated) KMS encryption key for the session bucket. Default: Auto-created KMS key with rotation enabled
        :param removal_policy: (deprecated) Removal policy for the session bucket. Default: RemovalPolicy.DESTROY
        :param session_ttl: (deprecated) Time-to-live for sessions. Sessions older than this duration will be automatically deleted. Default: Duration.hours(24)

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__d45521f97bfb1a1163912d233a2c8da0cbcd4b353375612380395214a57c68dc)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = S3SessionManagerProps(
            bucket=bucket,
            encryption_key=encryption_key,
            removal_policy=removal_policy,
            session_ttl=session_ttl,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="grantReadWrite")
    def grant_read_write(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(deprecated) Grant read/write permissions to a Lambda function.

        :param lambda_function: -

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__28715db6e8895cddffe1f3dd80fd586296e2531b435166f5df3ebdf499e1d6fa)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantReadWrite", [lambda_function]))

    @builtins.property
    @jsii.member(jsii_name="bucket")
    def bucket(self) -> "_aws_cdk_aws_s3_ceddda9d.IBucket":
        '''(deprecated) The S3 bucket used for session storage.

        :stability: deprecated
        '''
        return typing.cast("_aws_cdk_aws_s3_ceddda9d.IBucket", jsii.get(self, "bucket"))

    @builtins.property
    @jsii.member(jsii_name="sessionTTL")
    def session_ttl(self) -> "_aws_cdk_ceddda9d.Duration":
        '''(deprecated) The session TTL duration.

        :stability: deprecated
        '''
        return typing.cast("_aws_cdk_ceddda9d.Duration", jsii.get(self, "sessionTTL"))

    @builtins.property
    @jsii.member(jsii_name="sessionBucket")
    def session_bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''(deprecated) The S3 bucket used for session storage (ISessionStore interface).

        :stability: deprecated
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"], jsii.get(self, "sessionBucket"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.S3SessionManagerProps",
    jsii_struct_bases=[],
    name_mapping={
        "bucket": "bucket",
        "encryption_key": "encryptionKey",
        "removal_policy": "removalPolicy",
        "session_ttl": "sessionTTL",
    },
)
class S3SessionManagerProps:
    def __init__(
        self,
        *,
        bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.IKey"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        session_ttl: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(deprecated) Configuration properties for S3SessionManager.

        :param bucket: (deprecated) S3 bucket for session storage. Default: Auto-created bucket with KMS encryption
        :param encryption_key: (deprecated) KMS encryption key for the session bucket. Default: Auto-created KMS key with rotation enabled
        :param removal_policy: (deprecated) Removal policy for the session bucket. Default: RemovalPolicy.DESTROY
        :param session_ttl: (deprecated) Time-to-live for sessions. Sessions older than this duration will be automatically deleted. Default: Duration.hours(24)

        :deprecated: Use Strands-native ``S3SessionManager`` from ``strands.session.s3_session_manager`` instead.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__fd8b93fe769e4781778c4a9af36af20fbb18949cc82d2ee47d36bd31e3c3419b)
            check_type(argname="argument bucket", value=bucket, expected_type=type_hints["bucket"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument session_ttl", value=session_ttl, expected_type=type_hints["session_ttl"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if bucket is not None:
            self._values["bucket"] = bucket
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if session_ttl is not None:
            self._values["session_ttl"] = session_ttl

    @builtins.property
    def bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''(deprecated) S3 bucket for session storage.

        :default: Auto-created bucket with KMS encryption

        :stability: deprecated
        '''
        result = self._values.get("bucket")
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.IKey"]:
        '''(deprecated) KMS encryption key for the session bucket.

        :default: Auto-created KMS key with rotation enabled

        :stability: deprecated
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.IKey"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(deprecated) Removal policy for the session bucket.

        :default: RemovalPolicy.DESTROY

        :stability: deprecated
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def session_ttl(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(deprecated) Time-to-live for sessions.

        Sessions older than this duration will be automatically deleted.

        :default: Duration.hours(24)

        :stability: deprecated
        '''
        result = self._values.get("session_ttl")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "S3SessionManagerProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IContextStrategy)
class SlidingWindowConversationManager(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.SlidingWindowConversationManager",
):
    '''(deprecated) Sliding window conversation manager for maintaining recent conversation history.

    Keeps a fixed-size window of recent messages, automatically discarding older
    messages as new ones arrive. Provides consistent context size for the agent.


    Usage

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { InteractiveAgent, SlidingWindowConversationManager } from '@cdklabs/cdk-appmod-catalog-blueprints';

       const myPrompt = new Asset(this, 'Prompt', { path: './prompt.txt' });
       const contextManager = new SlidingWindowConversationManager({ windowSize: 30 });

       const agent = new InteractiveAgent(this, 'Agent', {
         agentName: 'ChatAgent',
         agentDefinition: { bedrockModel: {}, systemPrompt: myPrompt },
         contextStrategy: contextManager
       });

    :deprecated:

    Use Strands-native ``SlidingWindowConversationManager`` from
    ``strands.agent.conversation_manager`` instead. The Python handler now handles
    conversation windowing natively.

    :stability: deprecated
    '''

    def __init__(self, *, window_size: typing.Optional[jsii.Number] = None) -> None:
        '''
        :param window_size: (deprecated) Maximum number of messages to keep in conversation history. Default: 20 messages

        :stability: deprecated
        '''
        props = SlidingWindowConversationManagerProps(window_size=window_size)

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(deprecated) Get environment variables for Lambda configuration.

        :stability: deprecated
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))

    @builtins.property
    @jsii.member(jsii_name="windowSize")
    def window_size(self) -> jsii.Number:
        '''(deprecated) The window size (number of messages to keep).

        :stability: deprecated
        '''
        return typing.cast(jsii.Number, jsii.get(self, "windowSize"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.SlidingWindowConversationManagerProps",
    jsii_struct_bases=[],
    name_mapping={"window_size": "windowSize"},
)
class SlidingWindowConversationManagerProps:
    def __init__(self, *, window_size: typing.Optional[jsii.Number] = None) -> None:
        '''(deprecated) Configuration properties for SlidingWindowConversationManager.

        :param window_size: (deprecated) Maximum number of messages to keep in conversation history. Default: 20 messages

        :deprecated:

        Use Strands-native ``SlidingWindowConversationManager`` from
        ``strands.agent.conversation_manager`` instead.

        :stability: deprecated
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__4280ae99ea0f9116e703fc270a5be763aad71feb49471c69d3345d92d77965e5)
            check_type(argname="argument window_size", value=window_size, expected_type=type_hints["window_size"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if window_size is not None:
            self._values["window_size"] = window_size

    @builtins.property
    def window_size(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Maximum number of messages to keep in conversation history.

        :default: 20 messages

        :stability: deprecated
        '''
        result = self._values.get("window_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "SlidingWindowConversationManagerProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(_aws_cdk_ceddda9d.IPropertyInjector)
class StateMachineObservabilityPropertyInjector(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.StateMachineObservabilityPropertyInjector",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        *,
        data_protection_identifiers: typing.Optional[typing.Sequence["_aws_cdk_aws_logs_ceddda9d.DataIdentifier"]] = None,
        log_group_encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
    ) -> None:
        '''
        :param data_protection_identifiers: (experimental) List of DataIdentifiers that would be used as part of the Data Protection Policy that would be created for the log group. Default: Data Protection Policy won't be enabled
        :param log_group_encryption_key: (experimental) Encryption key that would be used to encrypt the relevant log group. Default: a new KMS key would automatically be created

        :stability: experimental
        '''
        log_group_data_protection = LogGroupDataProtectionProps(
            data_protection_identifiers=data_protection_identifiers,
            log_group_encryption_key=log_group_encryption_key,
        )

        jsii.create(self.__class__, self, [log_group_data_protection])

    @jsii.member(jsii_name="inject")
    def inject(
        self,
        original_props: typing.Any,
        *,
        id: builtins.str,
        scope: "_constructs_77d1e7e8.Construct",
    ) -> typing.Any:
        '''(experimental) The injector to be applied to the constructor properties of the Construct.

        :param original_props: -
        :param id: id from the Construct constructor.
        :param scope: scope from the constructor.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__011b55520774139b52c951d9cc59273f686e377b5415ee42a57650da571d43e7)
            check_type(argname="argument original_props", value=original_props, expected_type=type_hints["original_props"])
        _context = _aws_cdk_ceddda9d.InjectionContext(id=id, scope=scope)

        return typing.cast(typing.Any, jsii.invoke(self, "inject", [original_props, _context]))

    @builtins.property
    @jsii.member(jsii_name="constructUniqueId")
    def construct_unique_id(self) -> builtins.str:
        '''(experimental) The unique Id of the Construct class.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "constructUniqueId"))

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''
        :stability: experimental
        '''
        return typing.cast("LogGroupDataProtectionProps", jsii.get(self, "logGroupDataProtection"))


@jsii.implements(ICommunicationAdapter)
class StreamingHttpAdapter(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.StreamingHttpAdapter",
):
    '''(experimental) Streaming HTTP adapter for real-time agent communication via SSE.

    This adapter creates an API Gateway REST API with response streaming enabled,
    allowing the Lambda function to stream SSE (Server-Sent Events) responses
    back to clients as the Strands Agent generates tokens.


    Architecture

    Example::

       Client → POST /chat → API Gateway REST API (STREAM mode) → Lambda (FastAPI + LWA) → Bedrock
       Client ← SSE stream ← API Gateway ← Lambda response streaming ← Agent tokens


    Features

    - **Response Streaming**: Progressive SSE delivery via API Gateway response streaming
    - **15-Minute Timeout**: Extended timeout for long-running agent conversations
    - **Cognito Auth**: Native COGNITO_USER_POOLS authorizer on REST API
    - **CORS**: Built-in CORS support for browser clients
    - **Throttling**: Configurable rate and burst limits



    Example

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { InteractiveAgent, StreamingHttpAdapter } from '@cdklabs/cdk-appmod-catalog-blueprints';

       const myPrompt = new Asset(this, 'Prompt', { path: './prompt.txt' });
       const adapter = new StreamingHttpAdapter({
         stageName: 'prod',
         throttle: { rateLimit: 100, burstLimit: 200 }
       });

       const agent = new InteractiveAgent(this, 'Agent', {
         agentName: 'ChatAgent',
         agentDefinition: { bedrockModel: {}, systemPrompt: myPrompt },
         communicationAdapter: adapter
       });

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        authenticator: typing.Optional["IAuthenticator"] = None,
        stage_name: typing.Optional[builtins.str] = None,
        throttle: typing.Optional[typing.Union["ThrottleSettings", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''
        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: Uses authenticator from InteractiveAgent
        :param stage_name: (experimental) REST API stage name. Default: 'prod'
        :param throttle: (experimental) Throttle settings for REST API. Default: No throttling

        :stability: experimental
        '''
        props = StreamingHttpAdapterProps(
            authenticator=authenticator, stage_name=stage_name, throttle=throttle
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="attachToFunction")
    def attach_to_function(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> builtins.str:
        '''(experimental) Attach the adapter to a Lambda function and create REST API infrastructure.

        Creates API Gateway REST API with POST /chat endpoint and response streaming.

        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a706d9b87b02e59f326e98799b9e8c13a9ca457ac5ec400ad2353135b5898e6c)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(builtins.str, jsii.invoke(self, "attachToFunction", [lambda_function]))

    @jsii.member(jsii_name="grantInvoke")
    def grant_invoke(
        self,
        _lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant the Lambda function permissions for API Gateway integration.

        For REST API streaming, no additional permissions are needed beyond the invoke permission.

        :param _lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__5fe65fde40d00feea5a114f7b66c391bd98a82bab15ae4f0e8c0efb5025cf1ef)
            check_type(argname="argument _lambda_function", value=_lambda_function, expected_type=type_hints["_lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantInvoke", [_lambda_function]))

    @builtins.property
    @jsii.member(jsii_name="apiEndpoint")
    def api_endpoint(self) -> typing.Optional[builtins.str]:
        '''(experimental) The API endpoint URL.

        :stability: experimental
        '''
        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "apiEndpoint"))

    @builtins.property
    @jsii.member(jsii_name="restApi")
    def rest_api(self) -> typing.Optional["_aws_cdk_aws_apigateway_ceddda9d.RestApi"]:
        '''(experimental) The REST API Gateway.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_apigateway_ceddda9d.RestApi"], jsii.get(self, "restApi"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.StreamingHttpAdapterProps",
    jsii_struct_bases=[],
    name_mapping={
        "authenticator": "authenticator",
        "stage_name": "stageName",
        "throttle": "throttle",
    },
)
class StreamingHttpAdapterProps:
    def __init__(
        self,
        *,
        authenticator: typing.Optional["IAuthenticator"] = None,
        stage_name: typing.Optional[builtins.str] = None,
        throttle: typing.Optional[typing.Union["ThrottleSettings", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Configuration properties for StreamingHttpAdapter.

        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: Uses authenticator from InteractiveAgent
        :param stage_name: (experimental) REST API stage name. Default: 'prod'
        :param throttle: (experimental) Throttle settings for REST API. Default: No throttling

        :stability: experimental
        '''
        if isinstance(throttle, dict):
            throttle = ThrottleSettings(**throttle)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a2225f15606d5ad891bca8b49ff734819cbaa0c0a63da3363df104a7926af720)
            check_type(argname="argument authenticator", value=authenticator, expected_type=type_hints["authenticator"])
            check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
            check_type(argname="argument throttle", value=throttle, expected_type=type_hints["throttle"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if authenticator is not None:
            self._values["authenticator"] = authenticator
        if stage_name is not None:
            self._values["stage_name"] = stage_name
        if throttle is not None:
            self._values["throttle"] = throttle

    @builtins.property
    def authenticator(self) -> typing.Optional["IAuthenticator"]:
        '''(experimental) Authenticator for securing API endpoints.

        :default: Uses authenticator from InteractiveAgent

        :stability: experimental
        '''
        result = self._values.get("authenticator")
        return typing.cast(typing.Optional["IAuthenticator"], result)

    @builtins.property
    def stage_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) REST API stage name.

        :default: 'prod'

        :stability: experimental
        '''
        result = self._values.get("stage_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def throttle(self) -> typing.Optional["ThrottleSettings"]:
        '''(experimental) Throttle settings for REST API.

        :default: No throttling

        :stability: experimental
        '''
        result = self._values.get("throttle")
        return typing.cast(typing.Optional["ThrottleSettings"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "StreamingHttpAdapterProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.ThrottleSettings",
    jsii_struct_bases=[],
    name_mapping={"burst_limit": "burstLimit", "rate_limit": "rateLimit"},
)
class ThrottleSettings:
    def __init__(
        self,
        *,
        burst_limit: typing.Optional[jsii.Number] = None,
        rate_limit: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Throttle settings for REST API.

        :param burst_limit: (experimental) Burst limit (maximum concurrent requests).
        :param rate_limit: (experimental) Rate limit (requests per second).

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9c51f8e9b793b3797ca9e2c8bd75c1a689276a04bee6d4924b27c32bef5f4749)
            check_type(argname="argument burst_limit", value=burst_limit, expected_type=type_hints["burst_limit"])
            check_type(argname="argument rate_limit", value=rate_limit, expected_type=type_hints["rate_limit"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if burst_limit is not None:
            self._values["burst_limit"] = burst_limit
        if rate_limit is not None:
            self._values["rate_limit"] = rate_limit

    @builtins.property
    def burst_limit(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Burst limit (maximum concurrent requests).

        :stability: experimental
        '''
        result = self._values.get("burst_limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def rate_limit(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Rate limit (requests per second).

        :stability: experimental
        '''
        result = self._values.get("rate_limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "ThrottleSettings(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.TokenAnalysis",
    jsii_struct_bases=[],
    name_mapping={
        "avg_tokens_per_page": "avgTokensPerPage",
        "total_pages": "totalPages",
        "total_tokens": "totalTokens",
        "tokens_per_page": "tokensPerPage",
    },
)
class TokenAnalysis:
    def __init__(
        self,
        *,
        avg_tokens_per_page: jsii.Number,
        total_pages: jsii.Number,
        total_tokens: jsii.Number,
        tokens_per_page: typing.Optional[typing.Sequence[jsii.Number]] = None,
    ) -> None:
        '''(experimental) Token analysis results from PDF analysis.

        Provides information about document size and token distribution.

        :param avg_tokens_per_page: (experimental) Average tokens per page across the document.
        :param total_pages: (experimental) Total number of pages in the document.
        :param total_tokens: (experimental) Total estimated tokens in the document.
        :param tokens_per_page: (experimental) Optional detailed token count for each page. Used for token-based and hybrid chunking strategies.

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__429b64dc2313f6bc3b05440f33465bc0b0db572fd4032aaaf24627d0864e68cd)
            check_type(argname="argument avg_tokens_per_page", value=avg_tokens_per_page, expected_type=type_hints["avg_tokens_per_page"])
            check_type(argname="argument total_pages", value=total_pages, expected_type=type_hints["total_pages"])
            check_type(argname="argument total_tokens", value=total_tokens, expected_type=type_hints["total_tokens"])
            check_type(argname="argument tokens_per_page", value=tokens_per_page, expected_type=type_hints["tokens_per_page"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "avg_tokens_per_page": avg_tokens_per_page,
            "total_pages": total_pages,
            "total_tokens": total_tokens,
        }
        if tokens_per_page is not None:
            self._values["tokens_per_page"] = tokens_per_page

    @builtins.property
    def avg_tokens_per_page(self) -> jsii.Number:
        '''(experimental) Average tokens per page across the document.

        :stability: experimental
        '''
        result = self._values.get("avg_tokens_per_page")
        assert result is not None, "Required property 'avg_tokens_per_page' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_pages(self) -> jsii.Number:
        '''(experimental) Total number of pages in the document.

        :stability: experimental
        '''
        result = self._values.get("total_pages")
        assert result is not None, "Required property 'total_pages' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def total_tokens(self) -> jsii.Number:
        '''(experimental) Total estimated tokens in the document.

        :stability: experimental
        '''
        result = self._values.get("total_tokens")
        assert result is not None, "Required property 'total_tokens' is missing"
        return typing.cast(jsii.Number, result)

    @builtins.property
    def tokens_per_page(self) -> typing.Optional[typing.List[jsii.Number]]:
        '''(experimental) Optional detailed token count for each page.

        Used for token-based and hybrid chunking strategies.

        :stability: experimental
        '''
        result = self._values.get("tokens_per_page")
        return typing.cast(typing.Optional[typing.List[jsii.Number]], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "TokenAnalysis(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.TokenBasedConfig",
    jsii_struct_bases=[],
    name_mapping={
        "max_tokens_per_chunk": "maxTokensPerChunk",
        "overlap_tokens": "overlapTokens",
        "token_threshold": "tokenThreshold",
    },
)
class TokenBasedConfig:
    def __init__(
        self,
        *,
        max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
        overlap_tokens: typing.Optional[jsii.Number] = None,
        token_threshold: typing.Optional[jsii.Number] = None,
    ) -> None:
        '''(experimental) Configuration for token-based chunking strategy.

        Splits documents based on estimated token count to respect model limits.

        :param max_tokens_per_chunk: (experimental) Maximum tokens per chunk. Ensures no chunk exceeds model token limits. Default: 100000
        :param overlap_tokens: (experimental) Number of overlapping tokens between consecutive chunks. Provides context continuity across chunks. Default: 5000
        :param token_threshold: (experimental) Threshold for triggering chunking based on token count. Documents with tokens > threshold will be chunked. Default: 150000

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__a334bfb54e6a69272a4fe5b2f56f0a97d104fadd629c1aeb6ce670eb35f363d9)
            check_type(argname="argument max_tokens_per_chunk", value=max_tokens_per_chunk, expected_type=type_hints["max_tokens_per_chunk"])
            check_type(argname="argument overlap_tokens", value=overlap_tokens, expected_type=type_hints["overlap_tokens"])
            check_type(argname="argument token_threshold", value=token_threshold, expected_type=type_hints["token_threshold"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if max_tokens_per_chunk is not None:
            self._values["max_tokens_per_chunk"] = max_tokens_per_chunk
        if overlap_tokens is not None:
            self._values["overlap_tokens"] = overlap_tokens
        if token_threshold is not None:
            self._values["token_threshold"] = token_threshold

    @builtins.property
    def max_tokens_per_chunk(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Maximum tokens per chunk.

        Ensures no chunk exceeds model token limits.

        :default: 100000

        :stability: experimental
        '''
        result = self._values.get("max_tokens_per_chunk")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def overlap_tokens(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Number of overlapping tokens between consecutive chunks.

        Provides context continuity across chunks.

        :default: 5000

        :stability: experimental
        '''
        result = self._values.get("overlap_tokens")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def token_threshold(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Threshold for triggering chunking based on token count.

        Documents with tokens > threshold will be chunked.

        :default: 150000

        :stability: experimental
        '''
        result = self._values.get("token_threshold")
        return typing.cast(typing.Optional[jsii.Number], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "TokenBasedConfig(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.VectorStoreConfiguration",
    jsii_struct_bases=[],
    name_mapping={"bucket_name": "bucketName", "prefix": "prefix", "type": "type"},
)
class VectorStoreConfiguration:
    def __init__(
        self,
        *,
        bucket_name: typing.Optional[builtins.str] = None,
        prefix: typing.Optional[builtins.str] = None,
        type: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Configuration for vector store used by the knowledge base.

        Defines the type of vector store and any type-specific configuration.
        S3 Vectors is the default and recommended option for most use cases.

        :param bucket_name: (experimental) S3 bucket name for S3 Vectors storage. Only used when type is 's3-vectors'. If not provided, the default bucket created by Bedrock will be used. Default: - Uses Bedrock's default bucket
        :param prefix: (experimental) S3 prefix for vectors within the bucket. Only used when type is 's3-vectors'. Default: 'vectors/'
        :param type: (experimental) Type of vector store. - 's3-vectors': Amazon S3 vector storage (default, recommended) - 'opensearch-serverless': Amazon OpenSearch Serverless - 'pinecone': Pinecone vector database - 'rds': Amazon RDS with pgvector Default: 's3-vectors'

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__98230924b191ba0192b7d818a592221249c2b38f4ddd572cfc62d08a37b84b42)
            check_type(argname="argument bucket_name", value=bucket_name, expected_type=type_hints["bucket_name"])
            check_type(argname="argument prefix", value=prefix, expected_type=type_hints["prefix"])
            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if bucket_name is not None:
            self._values["bucket_name"] = bucket_name
        if prefix is not None:
            self._values["prefix"] = prefix
        if type is not None:
            self._values["type"] = type

    @builtins.property
    def bucket_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 bucket name for S3 Vectors storage.

        Only used when type is 's3-vectors'. If not provided, the default
        bucket created by Bedrock will be used.

        :default: - Uses Bedrock's default bucket

        :stability: experimental
        '''
        result = self._values.get("bucket_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def prefix(self) -> typing.Optional[builtins.str]:
        '''(experimental) S3 prefix for vectors within the bucket.

        Only used when type is 's3-vectors'.

        :default: 'vectors/'

        :stability: experimental
        '''
        result = self._values.get("prefix")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def type(self) -> typing.Optional[builtins.str]:
        '''(experimental) Type of vector store.

        - 's3-vectors': Amazon S3 vector storage (default, recommended)
        - 'opensearch-serverless': Amazon OpenSearch Serverless
        - 'pinecone': Pinecone vector database
        - 'rds': Amazon RDS with pgvector

        :default: 's3-vectors'

        :stability: experimental
        '''
        result = self._values.get("type")
        return typing.cast(typing.Optional[builtins.str], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "VectorStoreConfiguration(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IHostingAdapter)
class AgentCoreRuntimeHostingAdapter(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgentCoreRuntimeHostingAdapter",
):
    '''(experimental) AgentCore Runtime hosting adapter for InteractiveAgent.

    Deploys the agent as a container running on AgentCore Runtime (microVM).
    Uses L1 constructs ``CfnRuntime`` and ``CfnRuntimeEndpoint`` from
    ``aws-cdk-lib/aws-bedrockagentcore``.


    Architecture

    Example::

       Client → AgentCore Runtime Endpoint → Container (FastAPI on port 8080) → Bedrock


    Features

    - **Session Isolation**: microVM provides per-session isolation (no S3 session bucket needed)
    - **Managed Infrastructure**: No Lambda cold starts or timeout limits
    - **Multiple Protocols**: HTTP, MCP, or A2A protocol support
    - **Container-Based**: Standard Docker image deployment



    Usage

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { InteractiveAgent, AgentCoreRuntimeHostingAdapter } from '@cdklabs/cdk-appmod-catalog-blueprints';

       declare const myPrompt: Asset;

       new InteractiveAgent(this, 'Agent', {
         agentName: 'MyChatbot',
         agentDefinition: { bedrockModel: {}, systemPrompt: myPrompt },
         hostingAdapter: new AgentCoreRuntimeHostingAdapter({
           networkMode: 'PUBLIC',
         }),
       });

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        container_image_uri: typing.Optional[builtins.str] = None,
        custom_jwt_authorizer: typing.Optional[typing.Union["AgentCoreJwtAuthorizerConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        endpoint_name: typing.Optional[builtins.str] = None,
        network_mode: typing.Optional[builtins.str] = None,
        protocol_configuration: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param container_image_uri: (experimental) ECR container image URI. If not provided, builds from the bundled handler source. Default: Builds from agentcore-agent-handler directory
        :param custom_jwt_authorizer: (experimental) Custom JWT authorizer configuration. Omit for IAM-only auth.
        :param endpoint_name: (experimental) Runtime endpoint name. Default: Auto-generated from agent name
        :param network_mode: (experimental) Network mode: 'PUBLIC' or 'VPC'. Default: 'PUBLIC'
        :param protocol_configuration: (experimental) Protocol configuration: 'HTTP' | 'MCP' | 'A2A'. Default: 'HTTP'

        :stability: experimental
        '''
        props = AgentCoreRuntimeHostingAdapterProps(
            container_image_uri=container_image_uri,
            custom_jwt_authorizer=custom_jwt_authorizer,
            endpoint_name=endpoint_name,
            network_mode=network_mode,
            protocol_configuration=protocol_configuration,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="deploy")
    def deploy(
        self,
        *,
        agent_name: builtins.str,
        agent_role: "_aws_cdk_aws_iam_ceddda9d.Role",
        encryption_key: "_aws_cdk_aws_kms_ceddda9d.Key",
        environment: typing.Mapping[builtins.str, builtins.str],
        scope: "_constructs_77d1e7e8.Construct",
        system_prompt_bucket: builtins.str,
        system_prompt_key: builtins.str,
        tools_config: builtins.str,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        knowledge_base_configs: typing.Optional[builtins.str] = None,
        knowledge_base_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
        lambda_layers: typing.Optional[typing.Sequence["_aws_cdk_aws_lambda_ceddda9d.ILayerVersion"]] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> "AgentHostingResult":
        '''(experimental) Deploy AgentCore Runtime hosting infrastructure.

        :param agent_name: (experimental) Agent name identifier.
        :param agent_role: (experimental) IAM role for the agent runtime.
        :param encryption_key: (experimental) KMS encryption key.
        :param environment: (experimental) Environment variables to set on the runtime.
        :param scope: (experimental) CDK scope for creating resources.
        :param system_prompt_bucket: (experimental) System prompt S3 bucket name.
        :param system_prompt_key: (experimental) System prompt S3 key.
        :param tools_config: (experimental) Agent tools location definitions (JSON serialized).
        :param architecture: (experimental) Lambda architecture (Lambda hosting only).
        :param enable_observability: (experimental) Whether observability is enabled.
        :param knowledge_base_configs: (experimental) Knowledge base configs (JSON serialized).
        :param knowledge_base_layers: (experimental) Lambda layers from knowledge bases (Lambda hosting only).
        :param knowledge_base_system_prompt_addition: (experimental) Knowledge base system prompt addition.
        :param lambda_layers: (experimental) Lambda layers from agent definition (Lambda hosting only).
        :param memory_size: (experimental) Lambda memory size in MB (Lambda hosting only).
        :param network: (experimental) Optional VPC network configuration.
        :param removal_policy: (experimental) Removal policy for resources.
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions (Lambda hosting only).
        :param timeout: (experimental) Lambda timeout (Lambda hosting only).

        :stability: experimental
        '''
        config = AgentHostingConfig(
            agent_name=agent_name,
            agent_role=agent_role,
            encryption_key=encryption_key,
            environment=environment,
            scope=scope,
            system_prompt_bucket=system_prompt_bucket,
            system_prompt_key=system_prompt_key,
            tools_config=tools_config,
            architecture=architecture,
            enable_observability=enable_observability,
            knowledge_base_configs=knowledge_base_configs,
            knowledge_base_layers=knowledge_base_layers,
            knowledge_base_system_prompt_addition=knowledge_base_system_prompt_addition,
            lambda_layers=lambda_layers,
            memory_size=memory_size,
            network=network,
            removal_policy=removal_policy,
            reserved_concurrent_executions=reserved_concurrent_executions,
            timeout=timeout,
        )

        return typing.cast("AgentHostingResult", jsii.invoke(self, "deploy", [config]))

    @builtins.property
    @jsii.member(jsii_name="servicePrincipal")
    def service_principal(self) -> "_aws_cdk_aws_iam_ceddda9d.ServicePrincipal":
        '''(experimental) The IAM service principal that this hosting backend requires.

        BaseAgent uses this to create the agent role with the correct trust policy.
        For example, Lambda hosting requires ``lambda.amazonaws.com`` while AgentCore
        hosting requires ``bedrock-agentcore.amazonaws.com``.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_iam_ceddda9d.ServicePrincipal", jsii.get(self, "servicePrincipal"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseAgentProps",
    jsii_struct_bases=[ObservableProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "agent_definition": "agentDefinition",
        "agent_name": "agentName",
        "agent_architecture": "agentArchitecture",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "network": "network",
        "removal_policy": "removalPolicy",
        "service_principal": "servicePrincipal",
    },
)
class BaseAgentProps(ObservableProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
    ) -> None:
        '''
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if isinstance(agent_definition, dict):
            agent_definition = AgentDefinitionProps(**agent_definition)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__feb650555d9014f75886d26d16787c0c2e83a042e7e61844bf4d21c890ce479c)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument agent_definition", value=agent_definition, expected_type=type_hints["agent_definition"])
            check_type(argname="argument agent_name", value=agent_name, expected_type=type_hints["agent_name"])
            check_type(argname="argument agent_architecture", value=agent_architecture, expected_type=type_hints["agent_architecture"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument service_principal", value=service_principal, expected_type=type_hints["service_principal"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "agent_definition": agent_definition,
            "agent_name": agent_name,
        }
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if agent_architecture is not None:
            self._values["agent_architecture"] = agent_architecture
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if service_principal is not None:
            self._values["service_principal"] = service_principal

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def agent_definition(self) -> "AgentDefinitionProps":
        '''(experimental) Agent related parameters.

        :stability: experimental
        '''
        result = self._values.get("agent_definition")
        assert result is not None, "Required property 'agent_definition' is missing"
        return typing.cast("AgentDefinitionProps", result)

    @builtins.property
    def agent_name(self) -> builtins.str:
        '''(experimental) Name of the agent.

        :stability: experimental
        '''
        result = self._values.get("agent_name")
        assert result is not None, "Required property 'agent_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent_architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) The architecture used by the Lambda function where the agent is hosted.

        :default: Architecture.ARM_64

        :stability: experimental
        '''
        result = self._values.get("agent_architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable observability for the agent.

        When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability:

        - **Lambda Powertools**: Provides function-level observability including structured logging,
          distributed tracing with X-Ray, and custom metrics
        - **AgentCore Observability**: Provides agent-specific observability including agent invocations,
          reasoning steps, tool usage, token consumption, and agent latency

        Both systems publish to Amazon CloudWatch and use the same service name and namespace
        for correlation. This provides complete visibility at both function and agent levels.

        **Environment Variables Set** (AgentCore):

        - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability
        - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry
        - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers
        - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation

        **IAM Permissions Granted** (AgentCore):

        - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents``
        - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords``

        **Additional Requirements**:

        - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer

        :default: false

        :see: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) Encryption key to encrypt agent environment variables.

        :default: new KMS Key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) If the Agent would be running inside a VPC.

        :default: Agent would not be in a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for resources created by this construct.

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def service_principal(
        self,
    ) -> typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"]:
        '''(experimental) The IAM service principal for the agent role's trust policy.

        This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com``
        for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore).

        :default: ServicePrincipal('lambda.amazonaws.com')

        :stability: experimental
        '''
        result = self._values.get("service_principal")
        return typing.cast(typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseAgentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IObservable)
class BaseDocumentProcessing(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseDocumentProcessing",
):
    '''(experimental) Abstract base class for serverless document processing workflows.

    Provides a complete document processing pipeline with:

    - **S3 Storage**: Organized with prefixes (raw/, processed/, failed/) for document lifecycle management
    - **SQS Queue**: Reliable message processing with configurable visibility timeout and dead letter queue
    - **DynamoDB Table**: Workflow metadata tracking with DocumentId as partition key
    - **Step Functions**: Orchestrated workflow with automatic file movement based on processing outcome
    - **Auto-triggering**: S3 event notifications automatically start processing when files are uploaded to raw/ prefix
    - **Error Handling**: Failed documents are moved to failed/ prefix with error details stored in DynamoDB
    - **EventBridge Integration**: Optional custom event publishing for workflow state changes



    Architecture Flow

    S3 Upload (raw/) → SQS → Lambda Consumer → Step Functions → Processing Steps → S3 (processed/failed/)


    Implementation Requirements

    Subclasses must implement four abstract methods to define the processing workflow:

    - ``classificationStep()``: Document type classification
    - ``extractionStep()``: Data extraction from documents
    - ``enrichmentStep()``: Optional data enrichment (return undefined to skip)
    - ``postProcessingStep()``: Optional post-processing (return undefined to skip)

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Creates a new BaseDocumentProcessing construct.

        Initializes the complete document processing infrastructure including S3 bucket,
        SQS queue, DynamoDB table, and sets up S3 event notifications to trigger processing.

        :param scope: - The scope in which to define this construct.
        :param id: - The scoped construct ID. Must be unique within the scope.
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__117c249a26f3e7532983afc9123fadff3e20effcc69408df0f45a03eb720ea8a)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BaseDocumentProcessingProps(
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="classificationStep")
    @abc.abstractmethod
    def _classification_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Defines the document classification step of the workflow.

        **CRITICAL**: Must set ``outputPath`` to preserve workflow state for subsequent steps.
        The classification result should be available at ``$.classificationResult`` for DynamoDB storage.

        :return: Step Functions task for document classification

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createProcessingWorkflow")
    @abc.abstractmethod
    def _create_processing_workflow(
        self,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.IChainable":
        '''(experimental) Creates the processing workflow after preprocessing and initialization.

        Concrete implementations can customize this to handle preprocessing results.
        For example, BedrockDocumentProcessing uses this to add conditional branching
        for chunked vs non-chunked documents.

        Implementations can call ``createStandardProcessingWorkflow()`` to reuse the
        standard processing flow (Classification → Processing → Enrichment → PostProcessing).

        :return: Step Functions chain for processing the document

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="createStandardProcessingWorkflow")
    def _create_standard_processing_workflow(
        self,
        id_prefix: typing.Optional[builtins.str] = None,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.IChainable":
        '''(experimental) Creates the standard processing workflow (no preprocessing customization).

        This is the existing workflow: Classification → Processing → Enrichment → PostProcessing
        Concrete classes can call this method to reuse the standard flow when they don't
        need custom workflow branching.

        :param id_prefix: Optional prefix for construct IDs to ensure uniqueness when called multiple times.

        :return: Step Functions chain for standard processing

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__60b2b6769cfd7191f20068a71856358b8c84328bb68ac994d8b9e2d135895f28)
            check_type(argname="argument id_prefix", value=id_prefix, expected_type=type_hints["id_prefix"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.IChainable", jsii.invoke(self, "createStandardProcessingWorkflow", [id_prefix]))

    @jsii.member(jsii_name="enrichmentStep")
    @abc.abstractmethod
    def _enrichment_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional document enrichment step of the workflow.

        **CRITICAL**: If implemented, must set ``outputPath`` to preserve workflow state.
        The enrichment result should be available at ``$.enrichedResult`` for DynamoDB storage.

        :return: Step Functions task for document enrichment, or undefined to skip this step

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="handleStateMachineCreation")
    def _handle_state_machine_creation(
        self,
        state_machine_id: builtins.str,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine":
        '''
        :param state_machine_id: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__900aa9de379313a2a9a3e24a2901f803dec0a30dde90b7255d9f180e263b020d)
            check_type(argname="argument state_machine_id", value=state_machine_id, expected_type=type_hints["state_machine_id"])
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine", jsii.invoke(self, "handleStateMachineCreation", [state_machine_id]))

    @jsii.member(jsii_name="metrics")
    def metrics(self) -> typing.List["_aws_cdk_aws_cloudwatch_ceddda9d.IMetric"]:
        '''
        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_cloudwatch_ceddda9d.IMetric"], jsii.invoke(self, "metrics", []))

    @jsii.member(jsii_name="postProcessingStep")
    @abc.abstractmethod
    def _post_processing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional post-processing step of the workflow.

        **CRITICAL**: If implemented, must set ``outputPath`` to preserve workflow state.
        The post-processing result should be available at ``$.postProcessedResult`` for DynamoDB storage.

        :return: Step Functions task for post-processing, or undefined to skip this step

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="preprocessingMetadata")
    def _preprocessing_metadata(
        self,
    ) -> typing.Mapping[builtins.str, "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.DynamoAttributeValue"]:
        '''(experimental) Hook for concrete implementations to add preprocessing-specific metadata to DynamoDB.

        This method is called during InitMetadata creation and allows subclasses to extend
        the DynamoDB schema with their own fields without the base class knowing the details.

        The base class provides the core document fields (DocumentId, ContentType, etc.),
        and subclasses can add their own fields (e.g., chunking metadata) by overriding this method.

        :default: {} (no additional metadata)

        :return: Record of additional DynamoDB attribute values to include in InitMetadata

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.DynamoAttributeValue"], jsii.invoke(self, "preprocessingMetadata", []))

    @jsii.member(jsii_name="preprocessingStep")
    @abc.abstractmethod
    def _preprocessing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional preprocessing step of the workflow.

        This step runs BEFORE Init Metadata and can be used for:

        - Document chunking for large files
        - Document validation
        - Format conversion
        - Any other preprocessing needed before classification

        Concrete implementations can return undefined to skip preprocessing,
        maintaining backward compatibility with existing workflows.

        :return: Step Functions task for preprocessing, or undefined to skip this step

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="processingStep")
    @abc.abstractmethod
    def _processing_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Defines the document processing step of the workflow.

        **CRITICAL**: Must set ``outputPath`` to preserve workflow state for subsequent steps.
        The extraction result should be available at ``$.processingResult`` for DynamoDB storage.

        :return: Step Functions task for document extraction

        :stability: experimental
        '''
        ...

    @builtins.property
    @jsii.member(jsii_name="documentProcessingTable")
    def document_processing_table(self) -> "_aws_cdk_aws_dynamodb_ceddda9d.Table":
        '''(experimental) DynamoDB table for storing document processing metadata and workflow state.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_dynamodb_ceddda9d.Table", jsii.get(self, "documentProcessingTable"))

    @builtins.property
    @jsii.member(jsii_name="encryptionKey")
    def encryption_key(self) -> "_aws_cdk_aws_kms_ceddda9d.Key":
        '''(experimental) KMS key.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_kms_ceddda9d.Key", jsii.get(self, "encryptionKey"))

    @builtins.property
    @jsii.member(jsii_name="ingressAdapter")
    def ingress_adapter(self) -> "IAdapter":
        '''(experimental) Ingress adapter, responsible for triggering workflow.

        :stability: experimental
        '''
        return typing.cast("IAdapter", jsii.get(self, "ingressAdapter"))

    @builtins.property
    @jsii.member(jsii_name="logGroupDataProtection")
    def log_group_data_protection(self) -> "LogGroupDataProtectionProps":
        '''(experimental) log group data protection configuration.

        :stability: experimental
        '''
        return typing.cast("LogGroupDataProtectionProps", jsii.get(self, "logGroupDataProtection"))

    @builtins.property
    @jsii.member(jsii_name="metricNamespace")
    def metric_namespace(self) -> builtins.str:
        '''(experimental) Business metric namespace.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "metricNamespace"))

    @builtins.property
    @jsii.member(jsii_name="metricServiceName")
    def metric_service_name(self) -> builtins.str:
        '''(experimental) Business metric service name.

        This is part of the initial service dimension

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "metricServiceName"))


class _BaseDocumentProcessingProxy(BaseDocumentProcessing):
    @jsii.member(jsii_name="classificationStep")
    def _classification_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Defines the document classification step of the workflow.

        **CRITICAL**: Must set ``outputPath`` to preserve workflow state for subsequent steps.
        The classification result should be available at ``$.classificationResult`` for DynamoDB storage.

        :return: Step Functions task for document classification

        :stability: experimental
        '''
        return typing.cast(typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"], jsii.invoke(self, "classificationStep", []))

    @jsii.member(jsii_name="createProcessingWorkflow")
    def _create_processing_workflow(
        self,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.IChainable":
        '''(experimental) Creates the processing workflow after preprocessing and initialization.

        Concrete implementations can customize this to handle preprocessing results.
        For example, BedrockDocumentProcessing uses this to add conditional branching
        for chunked vs non-chunked documents.

        Implementations can call ``createStandardProcessingWorkflow()`` to reuse the
        standard processing flow (Classification → Processing → Enrichment → PostProcessing).

        :return: Step Functions chain for processing the document

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.IChainable", jsii.invoke(self, "createProcessingWorkflow", []))

    @jsii.member(jsii_name="enrichmentStep")
    def _enrichment_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional document enrichment step of the workflow.

        **CRITICAL**: If implemented, must set ``outputPath`` to preserve workflow state.
        The enrichment result should be available at ``$.enrichedResult`` for DynamoDB storage.

        :return: Step Functions task for document enrichment, or undefined to skip this step

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "enrichmentStep", []))

    @jsii.member(jsii_name="postProcessingStep")
    def _post_processing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional post-processing step of the workflow.

        **CRITICAL**: If implemented, must set ``outputPath`` to preserve workflow state.
        The post-processing result should be available at ``$.postProcessedResult`` for DynamoDB storage.

        :return: Step Functions task for post-processing, or undefined to skip this step

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "postProcessingStep", []))

    @jsii.member(jsii_name="preprocessingStep")
    def _preprocessing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Defines the optional preprocessing step of the workflow.

        This step runs BEFORE Init Metadata and can be used for:

        - Document chunking for large files
        - Document validation
        - Format conversion
        - Any other preprocessing needed before classification

        Concrete implementations can return undefined to skip preprocessing,
        maintaining backward compatibility with existing workflows.

        :return: Step Functions task for preprocessing, or undefined to skip this step

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "preprocessingStep", []))

    @jsii.member(jsii_name="processingStep")
    def _processing_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Defines the document processing step of the workflow.

        **CRITICAL**: Must set ``outputPath`` to preserve workflow state for subsequent steps.
        The extraction result should be available at ``$.processingResult`` for DynamoDB storage.

        :return: Step Functions task for document extraction

        :stability: experimental
        '''
        return typing.cast(typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"], jsii.invoke(self, "processingStep", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, BaseDocumentProcessing).__jsii_proxy_class__ = lambda : _BaseDocumentProcessingProxy


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseDocumentProcessingProps",
    jsii_struct_bases=[ObservableProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "document_processing_table": "documentProcessingTable",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "eventbridge_broker": "eventbridgeBroker",
        "ingress_adapter": "ingressAdapter",
        "network": "network",
        "removal_policy": "removalPolicy",
        "workflow_timeout": "workflowTimeout",
    },
)
class BaseDocumentProcessingProps(ObservableProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Configuration properties for BaseDocumentProcessing construct.

        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__75e07bce24d48571be58cad69f751b10a17a738fdb9db601acdc689ff1e6da22)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument document_processing_table", value=document_processing_table, expected_type=type_hints["document_processing_table"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument eventbridge_broker", value=eventbridge_broker, expected_type=type_hints["eventbridge_broker"])
            check_type(argname="argument ingress_adapter", value=ingress_adapter, expected_type=type_hints["ingress_adapter"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument workflow_timeout", value=workflow_timeout, expected_type=type_hints["workflow_timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if document_processing_table is not None:
            self._values["document_processing_table"] = document_processing_table
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if eventbridge_broker is not None:
            self._values["eventbridge_broker"] = eventbridge_broker
        if ingress_adapter is not None:
            self._values["ingress_adapter"] = ingress_adapter
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if workflow_timeout is not None:
            self._values["workflow_timeout"] = workflow_timeout

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def document_processing_table(
        self,
    ) -> typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"]:
        '''(experimental) DynamoDB table for storing document processing metadata and workflow state.

        If not provided, a new table will be created with DocumentId as partition key.

        :stability: experimental
        '''
        result = self._values.get("document_processing_table")
        return typing.cast(typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable logging and tracing for all supporting resource.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) KMS key to be used.

        :default: A new key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def eventbridge_broker(self) -> typing.Optional["EventbridgeBroker"]:
        '''(experimental) Optional EventBridge broker for publishing custom events during processing.

        If not provided, no custom events will be sent out.

        :stability: experimental
        '''
        result = self._values.get("eventbridge_broker")
        return typing.cast(typing.Optional["EventbridgeBroker"], result)

    @builtins.property
    def ingress_adapter(self) -> typing.Optional["IAdapter"]:
        '''(experimental) Adapter that defines how the document processing workflow is triggered.

        :default: QueuedS3Adapter

        :stability: experimental
        '''
        result = self._values.get("ingress_adapter")
        return typing.cast(typing.Optional["IAdapter"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) Resources that can run inside a VPC will follow the provided network configuration.

        :default: resources will run outside of a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for created resources (bucket, table, queue).

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def workflow_timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Maximum execution time for the Step Functions workflow.

        :default: Duration.minutes(30)

        :stability: experimental
        '''
        result = self._values.get("workflow_timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BaseDocumentProcessingProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


@jsii.implements(IKnowledgeBase)
class BaseKnowledgeBase(
    _constructs_77d1e7e8.Construct,
    metaclass=jsii.JSIIAbstractClass,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BaseKnowledgeBase",
):
    '''(experimental) Abstract base class for knowledge base implementations.

    This class provides common functionality for all knowledge base implementations,
    including configuration management, validation, and default behaviors. Concrete
    implementations (like BedrockKnowledgeBase) extend this class and implement
    the abstract methods.

    The base class handles:

    - Props validation (name and description are required)
    - Default retrieval configuration (numberOfResults defaults to 5)
    - ACL configuration storage
    - Base runtime configuration export

    Subclasses must implement:

    - ``generateIamPermissions()``: Return IAM permissions specific to the KB type

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        description: builtins.str,
        name: builtins.str,
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Creates a new BaseKnowledgeBase instance.

        :param scope: - The scope in which to define this construct.
        :param id: - The scoped construct ID.
        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }

        :stability: experimental
        :throws: Error if description is empty or not provided
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__1ffdc1300a392d74aedab074831b812725fc7d9f0b3c025e42cefd06be3e3273)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BaseKnowledgeBaseProps(
            description=description, name=name, acl=acl, retrieval=retrieval
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="exportConfiguration")
    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
        '''(experimental) Export configuration for runtime use by the retrieval tool.

        Returns a configuration object containing the base knowledge base
        settings. Subclasses should override this method to add implementation-
        specific configuration, calling super.exportConfiguration() to include
        the base configuration.

        :return: Runtime configuration object for the retrieval tool

        :stability: experimental
        '''
        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))

    @jsii.member(jsii_name="generateIamPermissions")
    @abc.abstractmethod
    def generate_iam_permissions(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.

        This abstract method must be implemented by subclasses to return the
        specific IAM permissions needed for their knowledge base type.

        :return: Array of IAM PolicyStatement objects granting necessary permissions

        :stability: experimental
        '''
        ...

    @jsii.member(jsii_name="retrievalToolAsset")
    def retrieval_tool_asset(
        self,
    ) -> typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"]:
        '''(experimental) Provide the retrieval tool asset for this knowledge base type.

        By default, returns undefined to use the framework's default retrieval
        tool. Subclasses can override this method to provide a custom retrieval
        tool implementation.

        :return: undefined to use the default retrieval tool

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_assets_ceddda9d.Asset"], jsii.invoke(self, "retrievalToolAsset", []))

    @jsii.member(jsii_name="retrievalToolLayers")
    def retrieval_tool_layers(
        self,
    ) -> typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]]:
        '''(experimental) Provide Lambda layers required by the retrieval tool.

        By default, returns undefined indicating no additional layers are needed.
        Subclasses can override this method to provide Lambda layers containing
        dependencies required by their retrieval tool.

        :return: undefined indicating no additional layers needed

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.List["_aws_cdk_aws_lambda_ceddda9d.LayerVersion"]], jsii.invoke(self, "retrievalToolLayers", []))

    @jsii.member(jsii_name="validateProps")
    def _validate_props(
        self,
        *,
        description: builtins.str,
        name: builtins.str,
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Validates the provided props at construction time.

        Ensures that required fields (name and description) are provided
        and not empty. Subclasses can override this method to add additional
        validation, but should call super.validateProps() first.

        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }

        :stability: experimental
        :throws: Error if description is empty or not provided
        '''
        props = BaseKnowledgeBaseProps(
            description=description, name=name, acl=acl, retrieval=retrieval
        )

        return typing.cast(None, jsii.invoke(self, "validateProps", [props]))

    @builtins.property
    @jsii.member(jsii_name="description")
    def description(self) -> builtins.str:
        '''(experimental) Human-readable description of what this knowledge base contains.

        This description is included in the agent's system prompt to help
        the agent decide when to query this knowledge base.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "description"))

    @builtins.property
    @jsii.member(jsii_name="name")
    def name(self) -> builtins.str:
        '''(experimental) Human-readable name for this knowledge base.

        This name is used for logging, display purposes, and to help the agent
        identify which knowledge base to query.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "name"))

    @builtins.property
    @jsii.member(jsii_name="retrievalConfig")
    def _retrieval_config(self) -> "RetrievalConfiguration":
        '''(experimental) Retrieval configuration for this knowledge base.

        Contains settings like numberOfResults and optional metadata filters.
        Defaults to { numberOfResults: 5 } if not provided.

        :stability: experimental
        '''
        return typing.cast("RetrievalConfiguration", jsii.get(self, "retrievalConfig"))

    @builtins.property
    @jsii.member(jsii_name="aclConfig")
    def _acl_config(self) -> typing.Optional["AclConfiguration"]:
        '''(experimental) ACL configuration for identity-aware retrieval.

        When enabled, retrieval queries will be filtered based on user
        identity context.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["AclConfiguration"], jsii.get(self, "aclConfig"))


class _BaseKnowledgeBaseProxy(BaseKnowledgeBase):
    @jsii.member(jsii_name="generateIamPermissions")
    def generate_iam_permissions(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM policy statements required for accessing this knowledge base.

        This abstract method must be implemented by subclasses to return the
        specific IAM permissions needed for their knowledge base type.

        :return: Array of IAM PolicyStatement objects granting necessary permissions

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))

# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, BaseKnowledgeBase).__jsii_proxy_class__ = lambda : _BaseKnowledgeBaseProxy


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BatchAgentProps",
    jsii_struct_bases=[BaseAgentProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "agent_definition": "agentDefinition",
        "agent_name": "agentName",
        "agent_architecture": "agentArchitecture",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "network": "network",
        "removal_policy": "removalPolicy",
        "service_principal": "servicePrincipal",
        "prompt": "prompt",
        "expect_json": "expectJson",
        "invoke_type": "invokeType",
    },
)
class BatchAgentProps(BaseAgentProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
        prompt: builtins.str,
        expect_json: typing.Optional[builtins.bool] = None,
        invoke_type: typing.Optional["InvokeType"] = None,
    ) -> None:
        '''
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')
        :param prompt: 
        :param expect_json: 
        :param invoke_type: (experimental) Agent invocation type. Defines how the agent is invoked and what processing mode to use. Default: InvokeType.BATCH

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if isinstance(agent_definition, dict):
            agent_definition = AgentDefinitionProps(**agent_definition)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__30511d5990f52f2808903d144bad5a5c502c00b0b8c98b4fd52a3df61c18b19d)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument agent_definition", value=agent_definition, expected_type=type_hints["agent_definition"])
            check_type(argname="argument agent_name", value=agent_name, expected_type=type_hints["agent_name"])
            check_type(argname="argument agent_architecture", value=agent_architecture, expected_type=type_hints["agent_architecture"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument service_principal", value=service_principal, expected_type=type_hints["service_principal"])
            check_type(argname="argument prompt", value=prompt, expected_type=type_hints["prompt"])
            check_type(argname="argument expect_json", value=expect_json, expected_type=type_hints["expect_json"])
            check_type(argname="argument invoke_type", value=invoke_type, expected_type=type_hints["invoke_type"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "agent_definition": agent_definition,
            "agent_name": agent_name,
            "prompt": prompt,
        }
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if agent_architecture is not None:
            self._values["agent_architecture"] = agent_architecture
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if service_principal is not None:
            self._values["service_principal"] = service_principal
        if expect_json is not None:
            self._values["expect_json"] = expect_json
        if invoke_type is not None:
            self._values["invoke_type"] = invoke_type

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def agent_definition(self) -> "AgentDefinitionProps":
        '''(experimental) Agent related parameters.

        :stability: experimental
        '''
        result = self._values.get("agent_definition")
        assert result is not None, "Required property 'agent_definition' is missing"
        return typing.cast("AgentDefinitionProps", result)

    @builtins.property
    def agent_name(self) -> builtins.str:
        '''(experimental) Name of the agent.

        :stability: experimental
        '''
        result = self._values.get("agent_name")
        assert result is not None, "Required property 'agent_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent_architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) The architecture used by the Lambda function where the agent is hosted.

        :default: Architecture.ARM_64

        :stability: experimental
        '''
        result = self._values.get("agent_architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable observability for the agent.

        When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability:

        - **Lambda Powertools**: Provides function-level observability including structured logging,
          distributed tracing with X-Ray, and custom metrics
        - **AgentCore Observability**: Provides agent-specific observability including agent invocations,
          reasoning steps, tool usage, token consumption, and agent latency

        Both systems publish to Amazon CloudWatch and use the same service name and namespace
        for correlation. This provides complete visibility at both function and agent levels.

        **Environment Variables Set** (AgentCore):

        - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability
        - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry
        - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers
        - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation

        **IAM Permissions Granted** (AgentCore):

        - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents``
        - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords``

        **Additional Requirements**:

        - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer

        :default: false

        :see: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) Encryption key to encrypt agent environment variables.

        :default: new KMS Key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) If the Agent would be running inside a VPC.

        :default: Agent would not be in a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for resources created by this construct.

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def service_principal(
        self,
    ) -> typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"]:
        '''(experimental) The IAM service principal for the agent role's trust policy.

        This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com``
        for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore).

        :default: ServicePrincipal('lambda.amazonaws.com')

        :stability: experimental
        '''
        result = self._values.get("service_principal")
        return typing.cast(typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"], result)

    @builtins.property
    def prompt(self) -> builtins.str:
        '''
        :stability: experimental
        '''
        result = self._values.get("prompt")
        assert result is not None, "Required property 'prompt' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def expect_json(self) -> typing.Optional[builtins.bool]:
        '''
        :stability: experimental
        '''
        result = self._values.get("expect_json")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def invoke_type(self) -> typing.Optional["InvokeType"]:
        '''(experimental) Agent invocation type.

        Defines how the agent is invoked and what processing mode to use.

        :default: InvokeType.BATCH

        :stability: experimental
        '''
        result = self._values.get("invoke_type")
        return typing.cast(typing.Optional["InvokeType"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BatchAgentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BedrockDocumentProcessing(
    BaseDocumentProcessing,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockDocumentProcessing",
):
    '''(experimental) Document processing workflow powered by Amazon Bedrock foundation models.

    Extends BaseDocumentProcessing to provide AI-powered document classification and extraction
    using Amazon Bedrock foundation models. This implementation offers:


    Key Features

    - **AI-Powered Classification**: Uses Claude 3.7 Sonnet (configurable) to classify document types
    - **Intelligent Extraction**: Extracts structured data from documents using foundation models
    - **Cross-Region Inference**: Optional support for improved availability via inference profiles
    - **Flexible Processing**: Optional enrichment and post-processing Lambda functions
    - **Cost Optimized**: Configurable timeouts and model selection for cost control



    Processing Workflow

    S3 Upload → Classification (Bedrock) → Extraction (Bedrock) → [Enrichment] → [Post-Processing] → Results


    Default Models

    - Classification: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)
    - Extraction: Claude 3.7 Sonnet (anthropic.claude-3-7-sonnet-20250219-v1:0)



    Prompt Templates

    The construct uses default prompts that can be customized:

    - **Classification**: Analyzes document and returns JSON with documentClassification field
    - **Extraction**: Uses classification result to extract entities in structured JSON format



    Cross-Region Inference

    When enabled, uses Bedrock inference profiles for improved availability:

    - US prefix: Routes to US-based regions for lower latency
    - EU prefix: Routes to EU-based regions for data residency compliance

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        aggregation_prompt: typing.Optional[builtins.str] = None,
        chunking_config: typing.Optional[typing.Union["ChunkingConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_prompt: typing.Optional[builtins.str] = None,
        enable_chunking: typing.Optional[builtins.bool] = None,
        enrichment_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        post_processing_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        processing_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        processing_prompt: typing.Optional[builtins.str] = None,
        step_timeouts: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''(experimental) Creates a new BedrockDocumentProcessing construct.

        Initializes the Bedrock-powered document processing pipeline with AI classification
        and extraction capabilities. Creates Lambda functions with appropriate IAM roles
        for Bedrock model invocation and S3 access.

        :param scope: - The scope in which to define this construct.
        :param id: - The scoped construct ID. Must be unique within the scope.
        :param aggregation_prompt: (experimental) Custom prompt template for aggregating results from multiple chunks. Used when chunking is enabled to merge processing results from all chunks into a single coherent result. The prompt receives the concatenated processing results from all chunks and should instruct the model to synthesize them into a unified output. Default: DEFAULT_AGGREGATION_PROMPT
        :param chunking_config: (experimental) Configuration for PDF chunking behavior. Only applies when ``enableChunking`` is true. Allows customization of: - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid) - **Thresholds**: When to trigger chunking based on page count or token count - **Chunk size and overlap**: Control chunk boundaries and context preservation - **Processing mode**: Parallel (faster) or sequential (cost-optimized) - **Aggregation strategy**: How to combine results from multiple chunks Default Configuration If not provided, uses sensible defaults optimized for most use cases: - Strategy: ``'hybrid'`` (recommended - balances token and page limits) - Page threshold: 100 pages - Token threshold: 150,000 tokens - Processing mode: ``'parallel'`` - Max concurrency: 10 - Aggregation strategy: ``'majority-vote'`` Strategy Comparison | Strategy | Best For | Pros | Cons | |----------|----------|------|------| | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex | | ``token-based`` | Variable density | Respects model limits | Slower analysis | | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits | Default: undefined (uses default configuration when enableChunking is true)
        :param classification_bedrock_model: (experimental) Bedrock foundation model for document classification step.
        :param classification_prompt: (experimental) Custom prompt template for document classification. Must include placeholder for document content. Default: DEFAULT_CLASSIFICATION_PROMPT
        :param enable_chunking: (experimental) Enable PDF chunking for large documents. When enabled, documents exceeding configured thresholds will be automatically split into chunks, processed in parallel or sequentially, and results aggregated. This feature is useful for: - Processing large PDFs (>100 pages) - Handling documents that exceed Bedrock token limits (~200K tokens) - Improving processing reliability for complex documents - Processing documents with variable content density The chunking workflow: 1. Analyzes PDF to determine page count and estimate token count 2. Decides if chunking is needed based on configured thresholds 3. If chunking is needed, splits PDF into chunks and uploads to S3 4. Processes each chunk through classification and extraction 5. Aggregates results using majority voting for classification 6. Deduplicates entities across chunks 7. Cleans up temporary chunk files from S3 Default: false
        :param enrichment_lambda_function: (experimental) Optional Lambda function for document enrichment step. If provided, will be invoked after extraction with workflow state.
        :param post_processing_lambda_function: (experimental) Optional Lambda function for post-processing step. If provided, will be invoked after enrichment with workflow state.
        :param processing_bedrock_model: (experimental) Bedrock foundation model for document extraction step.
        :param processing_prompt: (experimental) Custom prompt template for document extraction. Must include placeholder for document content and classification result. Default: DEFAULT_EXTRACTION_PROMPT
        :param step_timeouts: (experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.). Default: Duration.minutes(5)
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        :throws: Error if chunking configuration is invalid
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__7393f9c6b2af93f7d8668b32cec54ba8c77259644ab01f57b3fbd50c78923134)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BedrockDocumentProcessingProps(
            aggregation_prompt=aggregation_prompt,
            chunking_config=chunking_config,
            classification_bedrock_model=classification_bedrock_model,
            classification_prompt=classification_prompt,
            enable_chunking=enable_chunking,
            enrichment_lambda_function=enrichment_lambda_function,
            post_processing_lambda_function=post_processing_lambda_function,
            processing_bedrock_model=processing_bedrock_model,
            processing_prompt=processing_prompt,
            step_timeouts=step_timeouts,
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="classificationStep")
    def _classification_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Implements the document classification step using Amazon Bedrock.

        Creates a Lambda function that invokes the configured Bedrock model to classify
        the document type. The function reads the document from S3 and sends it to
        Bedrock with the classification prompt.

        This method caches the Lambda function to avoid creating duplicate resources,
        but creates a new LambdaInvoke task each time to allow proper state chaining.

        :return: LambdaInvoke task configured for document classification

        :stability: experimental
        '''
        return typing.cast(typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"], jsii.invoke(self, "classificationStep", []))

    @jsii.member(jsii_name="createProcessingWorkflow")
    def _create_processing_workflow(
        self,
    ) -> "_aws_cdk_aws_stepfunctions_ceddda9d.IChainable":
        '''(experimental) Creates the processing workflow with conditional branching for chunked documents.

        When chunking is enabled, creates a Choice State that:

        - Routes to chunked processing flow if document was chunked
        - Routes to standard processing flow if document was not chunked

        When chunking is disabled, returns the standard processing workflow.

        :return: Step Functions chain for processing the document

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.IChainable", jsii.invoke(self, "createProcessingWorkflow", []))

    @jsii.member(jsii_name="enrichmentStep")
    def _enrichment_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Implements the optional document enrichment step.

        If an enrichment Lambda function is provided in the props, creates a LambdaInvoke
        task to perform additional processing on the extracted data. This step is useful
        for data validation, transformation, or integration with external systems.

        :return: LambdaInvoke task for enrichment, or undefined to skip this step

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "enrichmentStep", []))

    @jsii.member(jsii_name="generateLambdaRoleForBedrock")
    def _generate_lambda_role_for_bedrock(
        self,
        id: builtins.str,
        *,
        cross_region_inference_prefix: typing.Optional["BedrockCrossRegionInferencePrefix"] = None,
        fm_model_id: typing.Optional["_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier"] = None,
        use_cross_region_inference: typing.Optional[builtins.bool] = None,
    ) -> "_aws_cdk_aws_iam_ceddda9d.Role":
        '''
        :param id: -
        :param cross_region_inference_prefix: (experimental) Prefix for cross-region inference configuration. Only used when useCrossRegionInference is true. Default: BedrockCrossRegionInferencePrefix.US
        :param fm_model_id: (experimental) Foundation model to use. Default: FoundationModelIdentifier.ANTHROPIC_CLAUDE_SONNET_4_20250514_V1_0
        :param use_cross_region_inference: (experimental) Enable cross-region inference for Bedrock models to improve availability and performance. When enabled, uses inference profiles instead of direct model invocation. Default: false

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b765dc24cd888585470934e534f4d8e979ddebd46e42601cc8b50c73499e7d4e)
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        model = BedrockModelProps(
            cross_region_inference_prefix=cross_region_inference_prefix,
            fm_model_id=fm_model_id,
            use_cross_region_inference=use_cross_region_inference,
        )

        return typing.cast("_aws_cdk_aws_iam_ceddda9d.Role", jsii.invoke(self, "generateLambdaRoleForBedrock", [id, model]))

    @jsii.member(jsii_name="postProcessingStep")
    def _post_processing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Implements the optional post-processing step.

        If a post-processing Lambda function is provided in the props, creates a LambdaInvoke
        task to perform final processing on the workflow results. This step is useful for
        data formatting, notifications, or integration with downstream systems.

        :return: LambdaInvoke task for post-processing, or undefined to skip this step

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "postProcessingStep", []))

    @jsii.member(jsii_name="preprocessingMetadata")
    def _preprocessing_metadata(
        self,
    ) -> typing.Mapping[builtins.str, "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.DynamoAttributeValue"]:
        '''(experimental) Provides additional metadata fields for chunking to be stored in DynamoDB.

        When chunking is enabled, adds fields for:

        - ChunkingEnabled: string representation of boolean flag
        - ChunkingStrategy: strategy used (fixed-pages, token-based, hybrid)
        - TokenAnalysis: JSON string with token analysis results
        - ChunkMetadata: JSON string array with chunk information

        :return: Record of DynamoDB attribute values for chunking metadata

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.DynamoAttributeValue"], jsii.invoke(self, "preprocessingMetadata", []))

    @jsii.member(jsii_name="preprocessingStep")
    def _preprocessing_step(
        self,
    ) -> typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]]:
        '''(experimental) Implements the optional preprocessing step for PDF chunking.

        When chunking is enabled, creates a Lambda function that analyzes PDFs and
        splits large documents into manageable chunks. The function:

        1. Analyzes the PDF to determine page count and token estimates
        2. Decides if chunking is needed based on configured thresholds
        3. If chunking is needed, splits the PDF and uploads chunks to S3

        :return: LambdaInvoke task for PDF analysis and chunking, or undefined if chunking is disabled

        :stability: experimental
        '''
        return typing.cast(typing.Optional[typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]], jsii.invoke(self, "preprocessingStep", []))

    @jsii.member(jsii_name="processingStep")
    def _processing_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Implements the document extraction step using Amazon Bedrock.

        Creates a Lambda function that invokes the configured Bedrock model to extract
        structured data from the document. Uses the classification result from the
        previous step to provide context for more accurate extraction.

        This method caches the Lambda function to avoid creating duplicate resources,
        but creates a new LambdaInvoke task each time to allow proper state chaining.

        :return: LambdaInvoke task configured for document extraction

        :stability: experimental
        '''
        return typing.cast(typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"], jsii.invoke(self, "processingStep", []))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_AGGREGATION_PROMPT")
    def DEFAULT_AGGREGATION_PROMPT(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_AGGREGATION_PROMPT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_CLASSIFICATION_PROMPT")
    def DEFAULT_CLASSIFICATION_PROMPT(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_CLASSIFICATION_PROMPT"))

    @jsii.python.classproperty
    @jsii.member(jsii_name="DEFAULT_PROCESSING_PROMPT")
    def DEFAULT_PROCESSING_PROMPT(cls) -> builtins.str:
        '''
        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_PROCESSING_PROMPT"))

    @builtins.property
    @jsii.member(jsii_name="bedrockDocumentProcessingProps")
    def _bedrock_document_processing_props(self) -> "BedrockDocumentProcessingProps":
        '''(experimental) Configuration properties specific to Bedrock document processing.

        :stability: experimental
        '''
        return typing.cast("BedrockDocumentProcessingProps", jsii.get(self, "bedrockDocumentProcessingProps"))

    @builtins.property
    @jsii.member(jsii_name="stateMachine")
    def state_machine(self) -> "_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine":
        '''(experimental) The Step Functions state machine that orchestrates the document processing workflow.

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_stepfunctions_ceddda9d.StateMachine", jsii.get(self, "stateMachine"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockDocumentProcessingProps",
    jsii_struct_bases=[BaseDocumentProcessingProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "document_processing_table": "documentProcessingTable",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "eventbridge_broker": "eventbridgeBroker",
        "ingress_adapter": "ingressAdapter",
        "network": "network",
        "removal_policy": "removalPolicy",
        "workflow_timeout": "workflowTimeout",
        "aggregation_prompt": "aggregationPrompt",
        "chunking_config": "chunkingConfig",
        "classification_bedrock_model": "classificationBedrockModel",
        "classification_prompt": "classificationPrompt",
        "enable_chunking": "enableChunking",
        "enrichment_lambda_function": "enrichmentLambdaFunction",
        "post_processing_lambda_function": "postProcessingLambdaFunction",
        "processing_bedrock_model": "processingBedrockModel",
        "processing_prompt": "processingPrompt",
        "step_timeouts": "stepTimeouts",
    },
)
class BedrockDocumentProcessingProps(BaseDocumentProcessingProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        aggregation_prompt: typing.Optional[builtins.str] = None,
        chunking_config: typing.Optional[typing.Union["ChunkingConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_prompt: typing.Optional[builtins.str] = None,
        enable_chunking: typing.Optional[builtins.bool] = None,
        enrichment_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        post_processing_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        processing_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        processing_prompt: typing.Optional[builtins.str] = None,
        step_timeouts: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Configuration properties for BedrockDocumentProcessing construct.

        Extends BaseDocumentProcessingProps with Bedrock-specific options.

        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param aggregation_prompt: (experimental) Custom prompt template for aggregating results from multiple chunks. Used when chunking is enabled to merge processing results from all chunks into a single coherent result. The prompt receives the concatenated processing results from all chunks and should instruct the model to synthesize them into a unified output. Default: DEFAULT_AGGREGATION_PROMPT
        :param chunking_config: (experimental) Configuration for PDF chunking behavior. Only applies when ``enableChunking`` is true. Allows customization of: - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid) - **Thresholds**: When to trigger chunking based on page count or token count - **Chunk size and overlap**: Control chunk boundaries and context preservation - **Processing mode**: Parallel (faster) or sequential (cost-optimized) - **Aggregation strategy**: How to combine results from multiple chunks Default Configuration If not provided, uses sensible defaults optimized for most use cases: - Strategy: ``'hybrid'`` (recommended - balances token and page limits) - Page threshold: 100 pages - Token threshold: 150,000 tokens - Processing mode: ``'parallel'`` - Max concurrency: 10 - Aggregation strategy: ``'majority-vote'`` Strategy Comparison | Strategy | Best For | Pros | Cons | |----------|----------|------|------| | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex | | ``token-based`` | Variable density | Respects model limits | Slower analysis | | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits | Default: undefined (uses default configuration when enableChunking is true)
        :param classification_bedrock_model: (experimental) Bedrock foundation model for document classification step.
        :param classification_prompt: (experimental) Custom prompt template for document classification. Must include placeholder for document content. Default: DEFAULT_CLASSIFICATION_PROMPT
        :param enable_chunking: (experimental) Enable PDF chunking for large documents. When enabled, documents exceeding configured thresholds will be automatically split into chunks, processed in parallel or sequentially, and results aggregated. This feature is useful for: - Processing large PDFs (>100 pages) - Handling documents that exceed Bedrock token limits (~200K tokens) - Improving processing reliability for complex documents - Processing documents with variable content density The chunking workflow: 1. Analyzes PDF to determine page count and estimate token count 2. Decides if chunking is needed based on configured thresholds 3. If chunking is needed, splits PDF into chunks and uploads to S3 4. Processes each chunk through classification and extraction 5. Aggregates results using majority voting for classification 6. Deduplicates entities across chunks 7. Cleans up temporary chunk files from S3 Default: false
        :param enrichment_lambda_function: (experimental) Optional Lambda function for document enrichment step. If provided, will be invoked after extraction with workflow state.
        :param post_processing_lambda_function: (experimental) Optional Lambda function for post-processing step. If provided, will be invoked after enrichment with workflow state.
        :param processing_bedrock_model: (experimental) Bedrock foundation model for document extraction step.
        :param processing_prompt: (experimental) Custom prompt template for document extraction. Must include placeholder for document content and classification result. Default: DEFAULT_EXTRACTION_PROMPT
        :param step_timeouts: (experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.). Default: Duration.minutes(5)

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if isinstance(chunking_config, dict):
            chunking_config = ChunkingConfig(**chunking_config)
        if isinstance(classification_bedrock_model, dict):
            classification_bedrock_model = BedrockModelProps(**classification_bedrock_model)
        if isinstance(processing_bedrock_model, dict):
            processing_bedrock_model = BedrockModelProps(**processing_bedrock_model)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__9606a6418d69bde20176ec33b27eaa22c0e0cdb6b105d382e9d038566f7a29f3)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument document_processing_table", value=document_processing_table, expected_type=type_hints["document_processing_table"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument eventbridge_broker", value=eventbridge_broker, expected_type=type_hints["eventbridge_broker"])
            check_type(argname="argument ingress_adapter", value=ingress_adapter, expected_type=type_hints["ingress_adapter"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument workflow_timeout", value=workflow_timeout, expected_type=type_hints["workflow_timeout"])
            check_type(argname="argument aggregation_prompt", value=aggregation_prompt, expected_type=type_hints["aggregation_prompt"])
            check_type(argname="argument chunking_config", value=chunking_config, expected_type=type_hints["chunking_config"])
            check_type(argname="argument classification_bedrock_model", value=classification_bedrock_model, expected_type=type_hints["classification_bedrock_model"])
            check_type(argname="argument classification_prompt", value=classification_prompt, expected_type=type_hints["classification_prompt"])
            check_type(argname="argument enable_chunking", value=enable_chunking, expected_type=type_hints["enable_chunking"])
            check_type(argname="argument enrichment_lambda_function", value=enrichment_lambda_function, expected_type=type_hints["enrichment_lambda_function"])
            check_type(argname="argument post_processing_lambda_function", value=post_processing_lambda_function, expected_type=type_hints["post_processing_lambda_function"])
            check_type(argname="argument processing_bedrock_model", value=processing_bedrock_model, expected_type=type_hints["processing_bedrock_model"])
            check_type(argname="argument processing_prompt", value=processing_prompt, expected_type=type_hints["processing_prompt"])
            check_type(argname="argument step_timeouts", value=step_timeouts, expected_type=type_hints["step_timeouts"])
        self._values: typing.Dict[builtins.str, typing.Any] = {}
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if document_processing_table is not None:
            self._values["document_processing_table"] = document_processing_table
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if eventbridge_broker is not None:
            self._values["eventbridge_broker"] = eventbridge_broker
        if ingress_adapter is not None:
            self._values["ingress_adapter"] = ingress_adapter
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if workflow_timeout is not None:
            self._values["workflow_timeout"] = workflow_timeout
        if aggregation_prompt is not None:
            self._values["aggregation_prompt"] = aggregation_prompt
        if chunking_config is not None:
            self._values["chunking_config"] = chunking_config
        if classification_bedrock_model is not None:
            self._values["classification_bedrock_model"] = classification_bedrock_model
        if classification_prompt is not None:
            self._values["classification_prompt"] = classification_prompt
        if enable_chunking is not None:
            self._values["enable_chunking"] = enable_chunking
        if enrichment_lambda_function is not None:
            self._values["enrichment_lambda_function"] = enrichment_lambda_function
        if post_processing_lambda_function is not None:
            self._values["post_processing_lambda_function"] = post_processing_lambda_function
        if processing_bedrock_model is not None:
            self._values["processing_bedrock_model"] = processing_bedrock_model
        if processing_prompt is not None:
            self._values["processing_prompt"] = processing_prompt
        if step_timeouts is not None:
            self._values["step_timeouts"] = step_timeouts

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def document_processing_table(
        self,
    ) -> typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"]:
        '''(experimental) DynamoDB table for storing document processing metadata and workflow state.

        If not provided, a new table will be created with DocumentId as partition key.

        :stability: experimental
        '''
        result = self._values.get("document_processing_table")
        return typing.cast(typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable logging and tracing for all supporting resource.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) KMS key to be used.

        :default: A new key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def eventbridge_broker(self) -> typing.Optional["EventbridgeBroker"]:
        '''(experimental) Optional EventBridge broker for publishing custom events during processing.

        If not provided, no custom events will be sent out.

        :stability: experimental
        '''
        result = self._values.get("eventbridge_broker")
        return typing.cast(typing.Optional["EventbridgeBroker"], result)

    @builtins.property
    def ingress_adapter(self) -> typing.Optional["IAdapter"]:
        '''(experimental) Adapter that defines how the document processing workflow is triggered.

        :default: QueuedS3Adapter

        :stability: experimental
        '''
        result = self._values.get("ingress_adapter")
        return typing.cast(typing.Optional["IAdapter"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) Resources that can run inside a VPC will follow the provided network configuration.

        :default: resources will run outside of a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for created resources (bucket, table, queue).

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def workflow_timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Maximum execution time for the Step Functions workflow.

        :default: Duration.minutes(30)

        :stability: experimental
        '''
        result = self._values.get("workflow_timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    @builtins.property
    def aggregation_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for aggregating results from multiple chunks.

        Used when chunking is enabled to merge processing results from all chunks
        into a single coherent result.

        The prompt receives the concatenated processing results from all chunks
        and should instruct the model to synthesize them into a unified output.

        :default: DEFAULT_AGGREGATION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("aggregation_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def chunking_config(self) -> typing.Optional["ChunkingConfig"]:
        '''(experimental) Configuration for PDF chunking behavior.

        Only applies when ``enableChunking`` is true. Allows customization of:

        - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid)
        - **Thresholds**: When to trigger chunking based on page count or token count
        - **Chunk size and overlap**: Control chunk boundaries and context preservation
        - **Processing mode**: Parallel (faster) or sequential (cost-optimized)
        - **Aggregation strategy**: How to combine results from multiple chunks



        Default Configuration

        If not provided, uses sensible defaults optimized for most use cases:

        - Strategy: ``'hybrid'`` (recommended - balances token and page limits)
        - Page threshold: 100 pages
        - Token threshold: 150,000 tokens
        - Processing mode: ``'parallel'``
        - Max concurrency: 10
        - Aggregation strategy: ``'majority-vote'``



        Strategy Comparison

        | Strategy | Best For | Pros | Cons |
        |----------|----------|------|------|
        | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex |
        | ``token-based`` | Variable density | Respects model limits | Slower analysis |
        | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits |

        :default: undefined (uses default configuration when enableChunking is true)

        :see: {@link ChunkingConfig } for detailed configuration options
        :stability: experimental
        '''
        result = self._values.get("chunking_config")
        return typing.cast(typing.Optional["ChunkingConfig"], result)

    @builtins.property
    def classification_bedrock_model(self) -> typing.Optional["BedrockModelProps"]:
        '''(experimental) Bedrock foundation model for document classification step.

        :stability: experimental
        '''
        result = self._values.get("classification_bedrock_model")
        return typing.cast(typing.Optional["BedrockModelProps"], result)

    @builtins.property
    def classification_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for document classification.

        Must include placeholder for document content.

        :default: DEFAULT_CLASSIFICATION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("classification_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enable_chunking(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable PDF chunking for large documents.

        When enabled, documents exceeding configured thresholds will be automatically
        split into chunks, processed in parallel or sequentially, and results aggregated.

        This feature is useful for:

        - Processing large PDFs (>100 pages)
        - Handling documents that exceed Bedrock token limits (~200K tokens)
        - Improving processing reliability for complex documents
        - Processing documents with variable content density

        The chunking workflow:

        1. Analyzes PDF to determine page count and estimate token count
        2. Decides if chunking is needed based on configured thresholds
        3. If chunking is needed, splits PDF into chunks and uploads to S3
        4. Processes each chunk through classification and extraction
        5. Aggregates results using majority voting for classification
        6. Deduplicates entities across chunks
        7. Cleans up temporary chunk files from S3

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_chunking")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def enrichment_lambda_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"]:
        '''(experimental) Optional Lambda function for document enrichment step.

        If provided, will be invoked after extraction with workflow state.

        :stability: experimental
        '''
        result = self._values.get("enrichment_lambda_function")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"], result)

    @builtins.property
    def post_processing_lambda_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"]:
        '''(experimental) Optional Lambda function for post-processing step.

        If provided, will be invoked after enrichment with workflow state.

        :stability: experimental
        '''
        result = self._values.get("post_processing_lambda_function")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"], result)

    @builtins.property
    def processing_bedrock_model(self) -> typing.Optional["BedrockModelProps"]:
        '''(experimental) Bedrock foundation model for document extraction step.

        :stability: experimental
        '''
        result = self._values.get("processing_bedrock_model")
        return typing.cast(typing.Optional["BedrockModelProps"], result)

    @builtins.property
    def processing_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for document extraction.

        Must include placeholder for document content and classification result.

        :default: DEFAULT_EXTRACTION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("processing_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def step_timeouts(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.).

        :default: Duration.minutes(5)

        :stability: experimental
        '''
        result = self._values.get("step_timeouts")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "BedrockDocumentProcessingProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class BedrockKnowledgeBase(
    BaseKnowledgeBase,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.BedrockKnowledgeBase",
):
    '''(experimental) Amazon Bedrock Knowledge Base implementation.

    This class provides integration with Amazon Bedrock Knowledge Bases,
    which use vector stores (S3 Vectors by default) for semantic search.
    It is the default knowledge base implementation when none is specified.

    The implementation handles:

    - ARN construction from knowledge base ID (if ARN not provided)
    - IAM permission generation for Bedrock Retrieve and RetrieveAndGenerate APIs
    - Optional guardrail configuration for content filtering
    - Runtime configuration export for the retrieval tool

    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        knowledge_base_id: builtins.str,
        create: typing.Optional[typing.Union["CreateKnowledgeBaseConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        guardrail: typing.Optional[typing.Union["GuardrailConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        knowledge_base_arn: typing.Optional[builtins.str] = None,
        vector_store: typing.Optional[typing.Union["VectorStoreConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        description: builtins.str,
        name: builtins.str,
        acl: typing.Optional[typing.Union["AclConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
        retrieval: typing.Optional[typing.Union["RetrievalConfiguration", typing.Dict[builtins.str, typing.Any]]] = None,
    ) -> None:
        '''(experimental) Creates a new BedrockKnowledgeBase instance.

        :param scope: - The scope in which to define this construct.
        :param id: - The scoped construct ID.
        :param knowledge_base_id: (experimental) Unique identifier for the Bedrock Knowledge Base. This is the ID assigned by Bedrock when the knowledge base was created. You can find this in the Bedrock console or via the AWS CLI. Required when referencing an existing knowledge base. Not required when using the ``create`` property to create a new KB.
        :param create: (experimental) Configuration for creating a new knowledge base. When provided, a new Bedrock Knowledge Base will be created with the specified data source and embedding configuration. Note: This is an advanced feature that creates AWS resources. For most use cases, referencing an existing knowledge base by ID is recommended. Default: - Reference existing KB only (no creation)
        :param guardrail: (experimental) Guardrail configuration for content filtering. When configured, the guardrail will be applied during retrieval operations to filter inappropriate or sensitive content. Default: - No guardrail applied
        :param knowledge_base_arn: (experimental) ARN of the Bedrock Knowledge Base. If not provided, the ARN will be constructed from the knowledgeBaseId using the current region and account. Default: - Constructed from knowledgeBaseId
        :param vector_store: (experimental) Vector store configuration. Defines the type of vector store used by this knowledge base. This is informational and used for generating appropriate IAM permissions when needed. Default: - S3 Vectors (type: 's3-vectors')
        :param description: (experimental) Description of what this knowledge base contains and when to use it. This description is shown to the agent in its system prompt to help it decide when to query this knowledge base. Be specific about the type of information contained and appropriate use cases.
        :param name: (experimental) Human-readable name/identifier for this knowledge base. Used for logging, display purposes, and to help the agent identify which knowledge base to query. Should be unique within the set of knowledge bases configured for an agent.
        :param acl: (experimental) Access control configuration for identity-aware retrieval. When enabled, retrieval queries will be filtered based on user identity context to ensure users only access permitted documents. Default: - ACL disabled
        :param retrieval: (experimental) Retrieval configuration options. Controls the number of results returned and optional metadata filtering. Default: { numberOfResults: 5 }

        :stability: experimental
        :throws: Error if knowledgeBaseId is empty or not provided
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__881273bf12c7a325cf85df5cec4c868a102b3e1454218addb9ce294190f2a295)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = BedrockKnowledgeBaseProps(
            knowledge_base_id=knowledge_base_id,
            create=create,
            guardrail=guardrail,
            knowledge_base_arn=knowledge_base_arn,
            vector_store=vector_store,
            description=description,
            name=name,
            acl=acl,
            retrieval=retrieval,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="exportConfiguration")
    def export_configuration(self) -> "KnowledgeBaseRuntimeConfig":
        '''(experimental) Export configuration for runtime use by the retrieval tool.

        Returns a configuration object containing all Bedrock-specific
        settings needed to query the knowledge base at runtime, including:

        - Base configuration (name, description, retrieval, acl)
        - Knowledge base type ('bedrock')
        - Knowledge base ID and ARN
        - Vector store configuration
        - Guardrail configuration (if present)

        :return: Runtime configuration object for the retrieval tool

        :stability: experimental
        '''
        return typing.cast("KnowledgeBaseRuntimeConfig", jsii.invoke(self, "exportConfiguration", []))

    @jsii.member(jsii_name="generateIamPermissions")
    def generate_iam_permissions(
        self,
    ) -> typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"]:
        '''(experimental) Generate IAM policy statements required for accessing this Bedrock Knowledge Base.

        Returns permissions for:

        - bedrock:Retrieve - Query the knowledge base
        - bedrock:RetrieveAndGenerate - Query and generate responses
        - bedrock:ApplyGuardrail - Apply guardrail (if configured)
        - s3:GetObject - Access S3 vectors (if using S3 Vectors with custom bucket)
        - s3:GetObject - Access data source bucket (if create config provided)

        All permissions are scoped to the specific knowledge base ARN
        following the principle of least privilege.

        :return: Array of IAM PolicyStatement objects granting necessary permissions

        :stability: experimental
        '''
        return typing.cast(typing.List["_aws_cdk_aws_iam_ceddda9d.PolicyStatement"], jsii.invoke(self, "generateIamPermissions", []))

    @jsii.member(jsii_name="retrievalToolAsset")
    def retrieval_tool_asset(self) -> "_aws_cdk_aws_s3_assets_ceddda9d.Asset":
        '''(experimental) Provide the Bedrock-specific retrieval tool asset.

        Returns an Asset containing the Python retrieval tool that uses
        the Amazon Bedrock Agent Runtime API to query knowledge bases.
        This tool is automatically added to agents that use Bedrock
        knowledge bases.

        :return: Asset containing the Bedrock retrieval tool

        :stability: experimental
        '''
        return typing.cast("_aws_cdk_aws_s3_assets_ceddda9d.Asset", jsii.invoke(self, "retrievalToolAsset", []))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseArn")
    def knowledge_base_arn(self) -> builtins.str:
        '''(experimental) The ARN of the Bedrock Knowledge Base.

        If not provided in props, this is constructed from the knowledgeBaseId
        using the current region and account.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "knowledgeBaseArn"))

    @builtins.property
    @jsii.member(jsii_name="knowledgeBaseId")
    def knowledge_base_id(self) -> builtins.str:
        '''(experimental) The unique identifier for the Bedrock Knowledge Base.

        This is the ID assigned by Bedrock when the knowledge base was created.

        :stability: experimental
        '''
        return typing.cast(builtins.str, jsii.get(self, "knowledgeBaseId"))


@jsii.implements(IAuthenticator)
class CognitoAuthenticator(
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.CognitoAuthenticator",
):
    '''(experimental) Cognito-based authenticator for securing REST API endpoints.

    Creates a Cognito User Pool and integrates with API Gateway REST API
    using the native COGNITO_USER_POOLS authorizer type. Clients send
    JWT tokens in the Authorization header.


    Features

    - **Native JWT Validation**: API Gateway validates tokens without custom Lambda
    - **User Management**: Built-in user registration and management
    - **Password Policies**: Enforces strong password requirements
    - **Account Recovery**: Email-based account recovery



    Usage

    Example::

       import { Asset } from 'aws-cdk-lib/aws-s3-assets';
       import { RemovalPolicy } from 'aws-cdk-lib';
       import { InteractiveAgent, CognitoAuthenticator } from '@cdklabs/cdk-appmod-catalog-blueprints';

       const myPrompt = new Asset(this, 'Prompt', { path: './prompt.txt' });
       const authenticator = new CognitoAuthenticator({
         removalPolicy: RemovalPolicy.RETAIN
       });

       const agent = new InteractiveAgent(this, 'Agent', {
         agentName: 'ChatAgent',
         agentDefinition: { bedrockModel: {}, systemPrompt: myPrompt },
         authenticator
       });

    :stability: experimental
    '''

    def __init__(
        self,
        *,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        user_pool: typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"] = None,
        user_pool_client: typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"] = None,
    ) -> None:
        '''
        :param removal_policy: (experimental) Removal policy for Cognito resources. Default: RemovalPolicy.DESTROY
        :param user_pool: (experimental) Cognito User Pool for authentication. Default: Auto-created User Pool with secure defaults
        :param user_pool_client: (experimental) Cognito User Pool Client. Default: Auto-created client with appropriate auth flows

        :stability: experimental
        '''
        props = CognitoAuthenticatorProps(
            removal_policy=removal_policy,
            user_pool=user_pool,
            user_pool_client=user_pool_client,
        )

        jsii.create(self.__class__, self, [props])

    @jsii.member(jsii_name="environmentVariables")
    def environment_variables(self) -> typing.Mapping[builtins.str, builtins.str]:
        '''(experimental) Get environment variables for Lambda configuration.

        :stability: experimental
        '''
        return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "environmentVariables", []))

    @jsii.member(jsii_name="grantAuthenticate")
    def grant_authenticate(
        self,
        lambda_function: "_aws_cdk_aws_lambda_ceddda9d.IFunction",
    ) -> None:
        '''(experimental) Grant authentication permissions to a Lambda function.

        Grants permissions to verify Cognito tokens.

        :param lambda_function: -

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__6cff1e3b59e2a9d06d2f540ea58ee953f1c1ce1d8e3d8246e78253a77fa04e07)
            check_type(argname="argument lambda_function", value=lambda_function, expected_type=type_hints["lambda_function"])
        return typing.cast(None, jsii.invoke(self, "grantAuthenticate", [lambda_function]))

    @builtins.property
    @jsii.member(jsii_name="userPool")
    def user_pool(self) -> typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"]:
        '''(experimental) The Cognito User Pool.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPool"], jsii.get(self, "userPool"))

    @builtins.property
    @jsii.member(jsii_name="userPoolClient")
    def user_pool_client(
        self,
    ) -> typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"]:
        '''(experimental) The Cognito User Pool Client.

        :stability: experimental
        '''
        return typing.cast(typing.Optional["_aws_cdk_aws_cognito_ceddda9d.UserPoolClient"], jsii.get(self, "userPoolClient"))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.InteractiveAgentProps",
    jsii_struct_bases=[BaseAgentProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "agent_definition": "agentDefinition",
        "agent_name": "agentName",
        "agent_architecture": "agentArchitecture",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "network": "network",
        "removal_policy": "removalPolicy",
        "service_principal": "servicePrincipal",
        "architecture": "architecture",
        "authenticator": "authenticator",
        "communication_adapter": "communicationAdapter",
        "context_strategy": "contextStrategy",
        "hosting_adapter": "hostingAdapter",
        "memory_size": "memorySize",
        "message_history_limit": "messageHistoryLimit",
        "reserved_concurrent_executions": "reservedConcurrentExecutions",
        "session_bucket": "sessionBucket",
        "session_store": "sessionStore",
        "session_ttl": "sessionTTL",
        "timeout": "timeout",
    },
)
class InteractiveAgentProps(BaseAgentProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        agent_definition: typing.Union["AgentDefinitionProps", typing.Dict[builtins.str, typing.Any]],
        agent_name: builtins.str,
        agent_architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        service_principal: typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"] = None,
        architecture: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"] = None,
        authenticator: typing.Optional["IAuthenticator"] = None,
        communication_adapter: typing.Optional["ICommunicationAdapter"] = None,
        context_strategy: typing.Optional["IContextStrategy"] = None,
        hosting_adapter: typing.Optional["IHostingAdapter"] = None,
        memory_size: typing.Optional[jsii.Number] = None,
        message_history_limit: typing.Optional[jsii.Number] = None,
        reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
        session_bucket: typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"] = None,
        session_store: typing.Optional["ISessionStore"] = None,
        session_ttl: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
    ) -> None:
        '''(experimental) Configuration properties for InteractiveAgent.

        Extends BaseAgentProps with communication, session, context, and authentication
        strategy interfaces for building real-time conversational AI agents.

        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param agent_definition: (experimental) Agent related parameters.
        :param agent_name: (experimental) Name of the agent.
        :param agent_architecture: (experimental) The architecture used by the Lambda function where the agent is hosted. Default: Architecture.ARM_64
        :param enable_observability: (experimental) Enable observability for the agent. When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability: - **Lambda Powertools**: Provides function-level observability including structured logging, distributed tracing with X-Ray, and custom metrics - **AgentCore Observability**: Provides agent-specific observability including agent invocations, reasoning steps, tool usage, token consumption, and agent latency Both systems publish to Amazon CloudWatch and use the same service name and namespace for correlation. This provides complete visibility at both function and agent levels. **Environment Variables Set** (AgentCore): - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation **IAM Permissions Granted** (AgentCore): - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents`` - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords`` **Additional Requirements**: - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer Default: false
        :param encryption_key: (experimental) Encryption key to encrypt agent environment variables. Default: new KMS Key would be created
        :param network: (experimental) If the Agent would be running inside a VPC. Default: Agent would not be in a VPC
        :param removal_policy: (experimental) Removal policy for resources created by this construct. Default: RemovalPolicy.DESTROY
        :param service_principal: (experimental) The IAM service principal for the agent role's trust policy. This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com`` for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore). Default: ServicePrincipal('lambda.amazonaws.com')
        :param architecture: (experimental) Lambda function architecture. Default: Architecture.X86_64
        :param authenticator: (experimental) Authenticator for securing API endpoints. Default: CognitoAuthenticator
        :param communication_adapter: (experimental) Communication adapter for client-agent interaction. Default: StreamingHttpAdapter with CognitoAuthenticator
        :param context_strategy: (deprecated) Context strategy for conversation history management. Default: SlidingWindowConversationManager with 20 messages
        :param hosting_adapter: (experimental) Hosting adapter for deploying the agent runtime. Use ``LambdaHostingAdapter`` for Lambda + API Gateway (default) or ``AgentCoreRuntimeHostingAdapter`` for AgentCore Runtime hosting. When provided, ``communicationAdapter``, ``authenticator``, ``memorySize``, ``timeout``, ``architecture``, and ``reservedConcurrentExecutions`` props are ignored (configure them on the adapter directly). Default: LambdaHostingAdapter
        :param memory_size: (experimental) Lambda function memory size in MB. Default: 1024
        :param message_history_limit: (deprecated) Maximum number of messages to keep in conversation history. Shorthand for SlidingWindowConversationManager windowSize. Ignored if contextStrategy is provided. Default: 20
        :param reserved_concurrent_executions: (experimental) Reserved concurrent executions for the Lambda function. Default: No reserved concurrency
        :param session_bucket: (experimental) S3 bucket for session storage (shorthand for S3SessionManager). Ignored if sessionStore is provided. Default: Auto-created bucket
        :param session_store: (deprecated) Session store for persisting conversation state. Set to undefined to disable session persistence (stateless mode). Default: S3SessionManager with 24-hour TTL
        :param session_ttl: (experimental) Time-to-live for sessions. Default: Duration.hours(24)
        :param timeout: (experimental) Lambda function timeout. Default: Duration.minutes(15)

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if isinstance(agent_definition, dict):
            agent_definition = AgentDefinitionProps(**agent_definition)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__f200e09b5bc954c48531f3974c2eb013ba36e16011b9b0e8026a38830687556a)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument agent_definition", value=agent_definition, expected_type=type_hints["agent_definition"])
            check_type(argname="argument agent_name", value=agent_name, expected_type=type_hints["agent_name"])
            check_type(argname="argument agent_architecture", value=agent_architecture, expected_type=type_hints["agent_architecture"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument service_principal", value=service_principal, expected_type=type_hints["service_principal"])
            check_type(argname="argument architecture", value=architecture, expected_type=type_hints["architecture"])
            check_type(argname="argument authenticator", value=authenticator, expected_type=type_hints["authenticator"])
            check_type(argname="argument communication_adapter", value=communication_adapter, expected_type=type_hints["communication_adapter"])
            check_type(argname="argument context_strategy", value=context_strategy, expected_type=type_hints["context_strategy"])
            check_type(argname="argument hosting_adapter", value=hosting_adapter, expected_type=type_hints["hosting_adapter"])
            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
            check_type(argname="argument message_history_limit", value=message_history_limit, expected_type=type_hints["message_history_limit"])
            check_type(argname="argument reserved_concurrent_executions", value=reserved_concurrent_executions, expected_type=type_hints["reserved_concurrent_executions"])
            check_type(argname="argument session_bucket", value=session_bucket, expected_type=type_hints["session_bucket"])
            check_type(argname="argument session_store", value=session_store, expected_type=type_hints["session_store"])
            check_type(argname="argument session_ttl", value=session_ttl, expected_type=type_hints["session_ttl"])
            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "agent_definition": agent_definition,
            "agent_name": agent_name,
        }
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if agent_architecture is not None:
            self._values["agent_architecture"] = agent_architecture
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if service_principal is not None:
            self._values["service_principal"] = service_principal
        if architecture is not None:
            self._values["architecture"] = architecture
        if authenticator is not None:
            self._values["authenticator"] = authenticator
        if communication_adapter is not None:
            self._values["communication_adapter"] = communication_adapter
        if context_strategy is not None:
            self._values["context_strategy"] = context_strategy
        if hosting_adapter is not None:
            self._values["hosting_adapter"] = hosting_adapter
        if memory_size is not None:
            self._values["memory_size"] = memory_size
        if message_history_limit is not None:
            self._values["message_history_limit"] = message_history_limit
        if reserved_concurrent_executions is not None:
            self._values["reserved_concurrent_executions"] = reserved_concurrent_executions
        if session_bucket is not None:
            self._values["session_bucket"] = session_bucket
        if session_store is not None:
            self._values["session_store"] = session_store
        if session_ttl is not None:
            self._values["session_ttl"] = session_ttl
        if timeout is not None:
            self._values["timeout"] = timeout

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def agent_definition(self) -> "AgentDefinitionProps":
        '''(experimental) Agent related parameters.

        :stability: experimental
        '''
        result = self._values.get("agent_definition")
        assert result is not None, "Required property 'agent_definition' is missing"
        return typing.cast("AgentDefinitionProps", result)

    @builtins.property
    def agent_name(self) -> builtins.str:
        '''(experimental) Name of the agent.

        :stability: experimental
        '''
        result = self._values.get("agent_name")
        assert result is not None, "Required property 'agent_name' is missing"
        return typing.cast(builtins.str, result)

    @builtins.property
    def agent_architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) The architecture used by the Lambda function where the agent is hosted.

        :default: Architecture.ARM_64

        :stability: experimental
        '''
        result = self._values.get("agent_architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable observability for the agent.

        When enabled, configures both Lambda Powertools and AWS Bedrock AgentCore observability:

        - **Lambda Powertools**: Provides function-level observability including structured logging,
          distributed tracing with X-Ray, and custom metrics
        - **AgentCore Observability**: Provides agent-specific observability including agent invocations,
          reasoning steps, tool usage, token consumption, and agent latency

        Both systems publish to Amazon CloudWatch and use the same service name and namespace
        for correlation. This provides complete visibility at both function and agent levels.

        **Environment Variables Set** (AgentCore):

        - ``AGENT_OBSERVABILITY_ENABLED``: Enables AgentCore observability
        - ``OTEL_RESOURCE_ATTRIBUTES``: Service identification for OpenTelemetry
        - ``OTEL_EXPORTER_OTLP_LOGS_HEADERS``: Agent identification headers
        - ``AWS_LAMBDA_EXEC_WRAPPER``: ADOT wrapper for automatic instrumentation

        **IAM Permissions Granted** (AgentCore):

        - CloudWatch Logs: ``logs:CreateLogGroup``, ``logs:CreateLogStream``, ``logs:PutLogEvents``
        - X-Ray: ``xray:PutTraceSegments``, ``xray:PutTelemetryRecords``

        **Additional Requirements**:

        - BatchAgent automatically adds ADOT (AWS Distro for OpenTelemetry) Lambda Layer

        :default: false

        :see: https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/observability-configure.html
        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) Encryption key to encrypt agent environment variables.

        :default: new KMS Key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) If the Agent would be running inside a VPC.

        :default: Agent would not be in a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for resources created by this construct.

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def service_principal(
        self,
    ) -> typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"]:
        '''(experimental) The IAM service principal for the agent role's trust policy.

        This is typically set by the hosting adapter (e.g., ``lambda.amazonaws.com``
        for Lambda hosting, ``bedrock-agentcore.amazonaws.com`` for AgentCore).

        :default: ServicePrincipal('lambda.amazonaws.com')

        :stability: experimental
        '''
        result = self._values.get("service_principal")
        return typing.cast(typing.Optional["_aws_cdk_aws_iam_ceddda9d.ServicePrincipal"], result)

    @builtins.property
    def architecture(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"]:
        '''(experimental) Lambda function architecture.

        :default: Architecture.X86_64

        :stability: experimental
        '''
        result = self._values.get("architecture")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Architecture"], result)

    @builtins.property
    def authenticator(self) -> typing.Optional["IAuthenticator"]:
        '''(experimental) Authenticator for securing API endpoints.

        :default: CognitoAuthenticator

        :stability: experimental
        '''
        result = self._values.get("authenticator")
        return typing.cast(typing.Optional["IAuthenticator"], result)

    @builtins.property
    def communication_adapter(self) -> typing.Optional["ICommunicationAdapter"]:
        '''(experimental) Communication adapter for client-agent interaction.

        :default: StreamingHttpAdapter with CognitoAuthenticator

        :stability: experimental
        '''
        result = self._values.get("communication_adapter")
        return typing.cast(typing.Optional["ICommunicationAdapter"], result)

    @builtins.property
    def context_strategy(self) -> typing.Optional["IContextStrategy"]:
        '''(deprecated) Context strategy for conversation history management.

        :default: SlidingWindowConversationManager with 20 messages

        :deprecated:

        Conversation management is now handled by Strands-native
        ``SlidingWindowConversationManager`` in the Python handler.

        :stability: deprecated
        '''
        result = self._values.get("context_strategy")
        return typing.cast(typing.Optional["IContextStrategy"], result)

    @builtins.property
    def hosting_adapter(self) -> typing.Optional["IHostingAdapter"]:
        '''(experimental) Hosting adapter for deploying the agent runtime.

        Use ``LambdaHostingAdapter`` for Lambda + API Gateway (default) or
        ``AgentCoreRuntimeHostingAdapter`` for AgentCore Runtime hosting.

        When provided, ``communicationAdapter``, ``authenticator``, ``memorySize``,
        ``timeout``, ``architecture``, and ``reservedConcurrentExecutions`` props
        are ignored (configure them on the adapter directly).

        :default: LambdaHostingAdapter

        :stability: experimental
        '''
        result = self._values.get("hosting_adapter")
        return typing.cast(typing.Optional["IHostingAdapter"], result)

    @builtins.property
    def memory_size(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Lambda function memory size in MB.

        :default: 1024

        :stability: experimental
        '''
        result = self._values.get("memory_size")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def message_history_limit(self) -> typing.Optional[jsii.Number]:
        '''(deprecated) Maximum number of messages to keep in conversation history.

        Shorthand for SlidingWindowConversationManager windowSize.
        Ignored if contextStrategy is provided.

        :default: 20

        :deprecated:

        Conversation windowing is now handled by Strands-native
        ``SlidingWindowConversationManager`` in the Python handler (default: 20).

        :stability: deprecated
        '''
        result = self._values.get("message_history_limit")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def reserved_concurrent_executions(self) -> typing.Optional[jsii.Number]:
        '''(experimental) Reserved concurrent executions for the Lambda function.

        :default: No reserved concurrency

        :stability: experimental
        '''
        result = self._values.get("reserved_concurrent_executions")
        return typing.cast(typing.Optional[jsii.Number], result)

    @builtins.property
    def session_bucket(self) -> typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"]:
        '''(experimental) S3 bucket for session storage (shorthand for S3SessionManager).

        Ignored if sessionStore is provided.

        :default: Auto-created bucket

        :stability: experimental
        '''
        result = self._values.get("session_bucket")
        return typing.cast(typing.Optional["_aws_cdk_aws_s3_ceddda9d.IBucket"], result)

    @builtins.property
    def session_store(self) -> typing.Optional["ISessionStore"]:
        '''(deprecated) Session store for persisting conversation state.

        Set to undefined to disable session persistence (stateless mode).

        :default: S3SessionManager with 24-hour TTL

        :deprecated:

        Session management is now handled by Strands-native ``S3SessionManager``.
        An S3 bucket is always created and passed as ``SESSION_BUCKET`` env var.

        :stability: deprecated
        '''
        result = self._values.get("session_store")
        return typing.cast(typing.Optional["ISessionStore"], result)

    @builtins.property
    def session_ttl(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Time-to-live for sessions.

        :default: Duration.hours(24)

        :stability: experimental
        '''
        result = self._values.get("session_ttl")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    @builtins.property
    def timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Lambda function timeout.

        :default: Duration.minutes(15)

        :stability: experimental
        '''
        result = self._values.get("timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "InteractiveAgentProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


class AgenticDocumentProcessing(
    BedrockDocumentProcessing,
    metaclass=jsii.JSIIMeta,
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgenticDocumentProcessing",
):
    '''
    :stability: experimental
    '''

    def __init__(
        self,
        scope: "_constructs_77d1e7e8.Construct",
        id: builtins.str,
        *,
        processing_agent_parameters: typing.Union["BatchAgentProps", typing.Dict[builtins.str, typing.Any]],
        aggregation_prompt: typing.Optional[builtins.str] = None,
        chunking_config: typing.Optional[typing.Union["ChunkingConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_prompt: typing.Optional[builtins.str] = None,
        enable_chunking: typing.Optional[builtins.bool] = None,
        enrichment_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        post_processing_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        processing_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        processing_prompt: typing.Optional[builtins.str] = None,
        step_timeouts: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
    ) -> None:
        '''
        :param scope: -
        :param id: -
        :param processing_agent_parameters: (experimental) This parameter takes precedence over the ``processingBedrockModel`` parameter.
        :param aggregation_prompt: (experimental) Custom prompt template for aggregating results from multiple chunks. Used when chunking is enabled to merge processing results from all chunks into a single coherent result. The prompt receives the concatenated processing results from all chunks and should instruct the model to synthesize them into a unified output. Default: DEFAULT_AGGREGATION_PROMPT
        :param chunking_config: (experimental) Configuration for PDF chunking behavior. Only applies when ``enableChunking`` is true. Allows customization of: - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid) - **Thresholds**: When to trigger chunking based on page count or token count - **Chunk size and overlap**: Control chunk boundaries and context preservation - **Processing mode**: Parallel (faster) or sequential (cost-optimized) - **Aggregation strategy**: How to combine results from multiple chunks Default Configuration If not provided, uses sensible defaults optimized for most use cases: - Strategy: ``'hybrid'`` (recommended - balances token and page limits) - Page threshold: 100 pages - Token threshold: 150,000 tokens - Processing mode: ``'parallel'`` - Max concurrency: 10 - Aggregation strategy: ``'majority-vote'`` Strategy Comparison | Strategy | Best For | Pros | Cons | |----------|----------|------|------| | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex | | ``token-based`` | Variable density | Respects model limits | Slower analysis | | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits | Default: undefined (uses default configuration when enableChunking is true)
        :param classification_bedrock_model: (experimental) Bedrock foundation model for document classification step.
        :param classification_prompt: (experimental) Custom prompt template for document classification. Must include placeholder for document content. Default: DEFAULT_CLASSIFICATION_PROMPT
        :param enable_chunking: (experimental) Enable PDF chunking for large documents. When enabled, documents exceeding configured thresholds will be automatically split into chunks, processed in parallel or sequentially, and results aggregated. This feature is useful for: - Processing large PDFs (>100 pages) - Handling documents that exceed Bedrock token limits (~200K tokens) - Improving processing reliability for complex documents - Processing documents with variable content density The chunking workflow: 1. Analyzes PDF to determine page count and estimate token count 2. Decides if chunking is needed based on configured thresholds 3. If chunking is needed, splits PDF into chunks and uploads to S3 4. Processes each chunk through classification and extraction 5. Aggregates results using majority voting for classification 6. Deduplicates entities across chunks 7. Cleans up temporary chunk files from S3 Default: false
        :param enrichment_lambda_function: (experimental) Optional Lambda function for document enrichment step. If provided, will be invoked after extraction with workflow state.
        :param post_processing_lambda_function: (experimental) Optional Lambda function for post-processing step. If provided, will be invoked after enrichment with workflow state.
        :param processing_bedrock_model: (experimental) Bedrock foundation model for document extraction step.
        :param processing_prompt: (experimental) Custom prompt template for document extraction. Must include placeholder for document content and classification result. Default: DEFAULT_EXTRACTION_PROMPT
        :param step_timeouts: (experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.). Default: Duration.minutes(5)
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case

        :stability: experimental
        '''
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__b7f396236f637ec7234d81b355cf773497392b537455f3d888c4b7170ceed70a)
            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
        props = AgenticDocumentProcessingProps(
            processing_agent_parameters=processing_agent_parameters,
            aggregation_prompt=aggregation_prompt,
            chunking_config=chunking_config,
            classification_bedrock_model=classification_bedrock_model,
            classification_prompt=classification_prompt,
            enable_chunking=enable_chunking,
            enrichment_lambda_function=enrichment_lambda_function,
            post_processing_lambda_function=post_processing_lambda_function,
            processing_bedrock_model=processing_bedrock_model,
            processing_prompt=processing_prompt,
            step_timeouts=step_timeouts,
            document_processing_table=document_processing_table,
            enable_observability=enable_observability,
            encryption_key=encryption_key,
            eventbridge_broker=eventbridge_broker,
            ingress_adapter=ingress_adapter,
            network=network,
            removal_policy=removal_policy,
            workflow_timeout=workflow_timeout,
            log_group_data_protection=log_group_data_protection,
            metric_namespace=metric_namespace,
            metric_service_name=metric_service_name,
        )

        jsii.create(self.__class__, self, [scope, id, props])

    @jsii.member(jsii_name="processingStep")
    def _processing_step(
        self,
    ) -> typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"]:
        '''(experimental) Implements the document extraction step using Amazon Bedrock.

        Creates a Lambda function that invokes the configured Bedrock model to extract
        structured data from the document. Uses the classification result from the
        previous step to provide context for more accurate extraction.

        This method caches the Lambda function to avoid creating duplicate resources,
        but creates a new LambdaInvoke task each time to allow proper state chaining.

        :stability: experimental
        '''
        return typing.cast(typing.Union["_aws_cdk_aws_stepfunctions_tasks_ceddda9d.LambdaInvoke", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.BedrockInvokeModel", "_aws_cdk_aws_stepfunctions_tasks_ceddda9d.StepFunctionsStartExecution"], jsii.invoke(self, "processingStep", []))


@jsii.data_type(
    jsii_type="@cdklabs/cdk-appmod-catalog-blueprints.AgenticDocumentProcessingProps",
    jsii_struct_bases=[BedrockDocumentProcessingProps],
    name_mapping={
        "log_group_data_protection": "logGroupDataProtection",
        "metric_namespace": "metricNamespace",
        "metric_service_name": "metricServiceName",
        "document_processing_table": "documentProcessingTable",
        "enable_observability": "enableObservability",
        "encryption_key": "encryptionKey",
        "eventbridge_broker": "eventbridgeBroker",
        "ingress_adapter": "ingressAdapter",
        "network": "network",
        "removal_policy": "removalPolicy",
        "workflow_timeout": "workflowTimeout",
        "aggregation_prompt": "aggregationPrompt",
        "chunking_config": "chunkingConfig",
        "classification_bedrock_model": "classificationBedrockModel",
        "classification_prompt": "classificationPrompt",
        "enable_chunking": "enableChunking",
        "enrichment_lambda_function": "enrichmentLambdaFunction",
        "post_processing_lambda_function": "postProcessingLambdaFunction",
        "processing_bedrock_model": "processingBedrockModel",
        "processing_prompt": "processingPrompt",
        "step_timeouts": "stepTimeouts",
        "processing_agent_parameters": "processingAgentParameters",
    },
)
class AgenticDocumentProcessingProps(BedrockDocumentProcessingProps):
    def __init__(
        self,
        *,
        log_group_data_protection: typing.Optional[typing.Union["LogGroupDataProtectionProps", typing.Dict[builtins.str, typing.Any]]] = None,
        metric_namespace: typing.Optional[builtins.str] = None,
        metric_service_name: typing.Optional[builtins.str] = None,
        document_processing_table: typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"] = None,
        enable_observability: typing.Optional[builtins.bool] = None,
        encryption_key: typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"] = None,
        eventbridge_broker: typing.Optional["EventbridgeBroker"] = None,
        ingress_adapter: typing.Optional["IAdapter"] = None,
        network: typing.Optional["Network"] = None,
        removal_policy: typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"] = None,
        workflow_timeout: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        aggregation_prompt: typing.Optional[builtins.str] = None,
        chunking_config: typing.Optional[typing.Union["ChunkingConfig", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        classification_prompt: typing.Optional[builtins.str] = None,
        enable_chunking: typing.Optional[builtins.bool] = None,
        enrichment_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        post_processing_lambda_function: typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"] = None,
        processing_bedrock_model: typing.Optional[typing.Union["BedrockModelProps", typing.Dict[builtins.str, typing.Any]]] = None,
        processing_prompt: typing.Optional[builtins.str] = None,
        step_timeouts: typing.Optional["_aws_cdk_ceddda9d.Duration"] = None,
        processing_agent_parameters: typing.Union["BatchAgentProps", typing.Dict[builtins.str, typing.Any]],
    ) -> None:
        '''
        :param log_group_data_protection: (experimental) Data protection related configuration. Default: a new KMS key would be generated
        :param metric_namespace: (experimental) Business metric namespace. Default: would be defined per use case
        :param metric_service_name: (experimental) Business metric service name dimension. Default: would be defined per use case
        :param document_processing_table: (experimental) DynamoDB table for storing document processing metadata and workflow state. If not provided, a new table will be created with DocumentId as partition key.
        :param enable_observability: (experimental) Enable logging and tracing for all supporting resource. Default: false
        :param encryption_key: (experimental) KMS key to be used. Default: A new key would be created
        :param eventbridge_broker: (experimental) Optional EventBridge broker for publishing custom events during processing. If not provided, no custom events will be sent out.
        :param ingress_adapter: (experimental) Adapter that defines how the document processing workflow is triggered. Default: QueuedS3Adapter
        :param network: (experimental) Resources that can run inside a VPC will follow the provided network configuration. Default: resources will run outside of a VPC
        :param removal_policy: (experimental) Removal policy for created resources (bucket, table, queue). Default: RemovalPolicy.DESTROY
        :param workflow_timeout: (experimental) Maximum execution time for the Step Functions workflow. Default: Duration.minutes(30)
        :param aggregation_prompt: (experimental) Custom prompt template for aggregating results from multiple chunks. Used when chunking is enabled to merge processing results from all chunks into a single coherent result. The prompt receives the concatenated processing results from all chunks and should instruct the model to synthesize them into a unified output. Default: DEFAULT_AGGREGATION_PROMPT
        :param chunking_config: (experimental) Configuration for PDF chunking behavior. Only applies when ``enableChunking`` is true. Allows customization of: - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid) - **Thresholds**: When to trigger chunking based on page count or token count - **Chunk size and overlap**: Control chunk boundaries and context preservation - **Processing mode**: Parallel (faster) or sequential (cost-optimized) - **Aggregation strategy**: How to combine results from multiple chunks Default Configuration If not provided, uses sensible defaults optimized for most use cases: - Strategy: ``'hybrid'`` (recommended - balances token and page limits) - Page threshold: 100 pages - Token threshold: 150,000 tokens - Processing mode: ``'parallel'`` - Max concurrency: 10 - Aggregation strategy: ``'majority-vote'`` Strategy Comparison | Strategy | Best For | Pros | Cons | |----------|----------|------|------| | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex | | ``token-based`` | Variable density | Respects model limits | Slower analysis | | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits | Default: undefined (uses default configuration when enableChunking is true)
        :param classification_bedrock_model: (experimental) Bedrock foundation model for document classification step.
        :param classification_prompt: (experimental) Custom prompt template for document classification. Must include placeholder for document content. Default: DEFAULT_CLASSIFICATION_PROMPT
        :param enable_chunking: (experimental) Enable PDF chunking for large documents. When enabled, documents exceeding configured thresholds will be automatically split into chunks, processed in parallel or sequentially, and results aggregated. This feature is useful for: - Processing large PDFs (>100 pages) - Handling documents that exceed Bedrock token limits (~200K tokens) - Improving processing reliability for complex documents - Processing documents with variable content density The chunking workflow: 1. Analyzes PDF to determine page count and estimate token count 2. Decides if chunking is needed based on configured thresholds 3. If chunking is needed, splits PDF into chunks and uploads to S3 4. Processes each chunk through classification and extraction 5. Aggregates results using majority voting for classification 6. Deduplicates entities across chunks 7. Cleans up temporary chunk files from S3 Default: false
        :param enrichment_lambda_function: (experimental) Optional Lambda function for document enrichment step. If provided, will be invoked after extraction with workflow state.
        :param post_processing_lambda_function: (experimental) Optional Lambda function for post-processing step. If provided, will be invoked after enrichment with workflow state.
        :param processing_bedrock_model: (experimental) Bedrock foundation model for document extraction step.
        :param processing_prompt: (experimental) Custom prompt template for document extraction. Must include placeholder for document content and classification result. Default: DEFAULT_EXTRACTION_PROMPT
        :param step_timeouts: (experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.). Default: Duration.minutes(5)
        :param processing_agent_parameters: (experimental) This parameter takes precedence over the ``processingBedrockModel`` parameter.

        :stability: experimental
        '''
        if isinstance(log_group_data_protection, dict):
            log_group_data_protection = LogGroupDataProtectionProps(**log_group_data_protection)
        if isinstance(chunking_config, dict):
            chunking_config = ChunkingConfig(**chunking_config)
        if isinstance(classification_bedrock_model, dict):
            classification_bedrock_model = BedrockModelProps(**classification_bedrock_model)
        if isinstance(processing_bedrock_model, dict):
            processing_bedrock_model = BedrockModelProps(**processing_bedrock_model)
        if isinstance(processing_agent_parameters, dict):
            processing_agent_parameters = BatchAgentProps(**processing_agent_parameters)
        if __debug__:
            type_hints = typing.get_type_hints(_typecheckingstub__da9ccab0035a06d18b5aa3f2de69201b3bbd6e30f7707a291977a0e4f83a72f4)
            check_type(argname="argument log_group_data_protection", value=log_group_data_protection, expected_type=type_hints["log_group_data_protection"])
            check_type(argname="argument metric_namespace", value=metric_namespace, expected_type=type_hints["metric_namespace"])
            check_type(argname="argument metric_service_name", value=metric_service_name, expected_type=type_hints["metric_service_name"])
            check_type(argname="argument document_processing_table", value=document_processing_table, expected_type=type_hints["document_processing_table"])
            check_type(argname="argument enable_observability", value=enable_observability, expected_type=type_hints["enable_observability"])
            check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
            check_type(argname="argument eventbridge_broker", value=eventbridge_broker, expected_type=type_hints["eventbridge_broker"])
            check_type(argname="argument ingress_adapter", value=ingress_adapter, expected_type=type_hints["ingress_adapter"])
            check_type(argname="argument network", value=network, expected_type=type_hints["network"])
            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
            check_type(argname="argument workflow_timeout", value=workflow_timeout, expected_type=type_hints["workflow_timeout"])
            check_type(argname="argument aggregation_prompt", value=aggregation_prompt, expected_type=type_hints["aggregation_prompt"])
            check_type(argname="argument chunking_config", value=chunking_config, expected_type=type_hints["chunking_config"])
            check_type(argname="argument classification_bedrock_model", value=classification_bedrock_model, expected_type=type_hints["classification_bedrock_model"])
            check_type(argname="argument classification_prompt", value=classification_prompt, expected_type=type_hints["classification_prompt"])
            check_type(argname="argument enable_chunking", value=enable_chunking, expected_type=type_hints["enable_chunking"])
            check_type(argname="argument enrichment_lambda_function", value=enrichment_lambda_function, expected_type=type_hints["enrichment_lambda_function"])
            check_type(argname="argument post_processing_lambda_function", value=post_processing_lambda_function, expected_type=type_hints["post_processing_lambda_function"])
            check_type(argname="argument processing_bedrock_model", value=processing_bedrock_model, expected_type=type_hints["processing_bedrock_model"])
            check_type(argname="argument processing_prompt", value=processing_prompt, expected_type=type_hints["processing_prompt"])
            check_type(argname="argument step_timeouts", value=step_timeouts, expected_type=type_hints["step_timeouts"])
            check_type(argname="argument processing_agent_parameters", value=processing_agent_parameters, expected_type=type_hints["processing_agent_parameters"])
        self._values: typing.Dict[builtins.str, typing.Any] = {
            "processing_agent_parameters": processing_agent_parameters,
        }
        if log_group_data_protection is not None:
            self._values["log_group_data_protection"] = log_group_data_protection
        if metric_namespace is not None:
            self._values["metric_namespace"] = metric_namespace
        if metric_service_name is not None:
            self._values["metric_service_name"] = metric_service_name
        if document_processing_table is not None:
            self._values["document_processing_table"] = document_processing_table
        if enable_observability is not None:
            self._values["enable_observability"] = enable_observability
        if encryption_key is not None:
            self._values["encryption_key"] = encryption_key
        if eventbridge_broker is not None:
            self._values["eventbridge_broker"] = eventbridge_broker
        if ingress_adapter is not None:
            self._values["ingress_adapter"] = ingress_adapter
        if network is not None:
            self._values["network"] = network
        if removal_policy is not None:
            self._values["removal_policy"] = removal_policy
        if workflow_timeout is not None:
            self._values["workflow_timeout"] = workflow_timeout
        if aggregation_prompt is not None:
            self._values["aggregation_prompt"] = aggregation_prompt
        if chunking_config is not None:
            self._values["chunking_config"] = chunking_config
        if classification_bedrock_model is not None:
            self._values["classification_bedrock_model"] = classification_bedrock_model
        if classification_prompt is not None:
            self._values["classification_prompt"] = classification_prompt
        if enable_chunking is not None:
            self._values["enable_chunking"] = enable_chunking
        if enrichment_lambda_function is not None:
            self._values["enrichment_lambda_function"] = enrichment_lambda_function
        if post_processing_lambda_function is not None:
            self._values["post_processing_lambda_function"] = post_processing_lambda_function
        if processing_bedrock_model is not None:
            self._values["processing_bedrock_model"] = processing_bedrock_model
        if processing_prompt is not None:
            self._values["processing_prompt"] = processing_prompt
        if step_timeouts is not None:
            self._values["step_timeouts"] = step_timeouts

    @builtins.property
    def log_group_data_protection(
        self,
    ) -> typing.Optional["LogGroupDataProtectionProps"]:
        '''(experimental) Data protection related configuration.

        :default: a new KMS key would be generated

        :stability: experimental
        '''
        result = self._values.get("log_group_data_protection")
        return typing.cast(typing.Optional["LogGroupDataProtectionProps"], result)

    @builtins.property
    def metric_namespace(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric namespace.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_namespace")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def metric_service_name(self) -> typing.Optional[builtins.str]:
        '''(experimental) Business metric service name dimension.

        :default: would be defined per use case

        :stability: experimental
        '''
        result = self._values.get("metric_service_name")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def document_processing_table(
        self,
    ) -> typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"]:
        '''(experimental) DynamoDB table for storing document processing metadata and workflow state.

        If not provided, a new table will be created with DocumentId as partition key.

        :stability: experimental
        '''
        result = self._values.get("document_processing_table")
        return typing.cast(typing.Optional["_aws_cdk_aws_dynamodb_ceddda9d.Table"], result)

    @builtins.property
    def enable_observability(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable logging and tracing for all supporting resource.

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_observability")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def encryption_key(self) -> typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"]:
        '''(experimental) KMS key to be used.

        :default: A new key would be created

        :stability: experimental
        '''
        result = self._values.get("encryption_key")
        return typing.cast(typing.Optional["_aws_cdk_aws_kms_ceddda9d.Key"], result)

    @builtins.property
    def eventbridge_broker(self) -> typing.Optional["EventbridgeBroker"]:
        '''(experimental) Optional EventBridge broker for publishing custom events during processing.

        If not provided, no custom events will be sent out.

        :stability: experimental
        '''
        result = self._values.get("eventbridge_broker")
        return typing.cast(typing.Optional["EventbridgeBroker"], result)

    @builtins.property
    def ingress_adapter(self) -> typing.Optional["IAdapter"]:
        '''(experimental) Adapter that defines how the document processing workflow is triggered.

        :default: QueuedS3Adapter

        :stability: experimental
        '''
        result = self._values.get("ingress_adapter")
        return typing.cast(typing.Optional["IAdapter"], result)

    @builtins.property
    def network(self) -> typing.Optional["Network"]:
        '''(experimental) Resources that can run inside a VPC will follow the provided network configuration.

        :default: resources will run outside of a VPC

        :stability: experimental
        '''
        result = self._values.get("network")
        return typing.cast(typing.Optional["Network"], result)

    @builtins.property
    def removal_policy(self) -> typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"]:
        '''(experimental) Removal policy for created resources (bucket, table, queue).

        :default: RemovalPolicy.DESTROY

        :stability: experimental
        '''
        result = self._values.get("removal_policy")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.RemovalPolicy"], result)

    @builtins.property
    def workflow_timeout(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Maximum execution time for the Step Functions workflow.

        :default: Duration.minutes(30)

        :stability: experimental
        '''
        result = self._values.get("workflow_timeout")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    @builtins.property
    def aggregation_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for aggregating results from multiple chunks.

        Used when chunking is enabled to merge processing results from all chunks
        into a single coherent result.

        The prompt receives the concatenated processing results from all chunks
        and should instruct the model to synthesize them into a unified output.

        :default: DEFAULT_AGGREGATION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("aggregation_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def chunking_config(self) -> typing.Optional["ChunkingConfig"]:
        '''(experimental) Configuration for PDF chunking behavior.

        Only applies when ``enableChunking`` is true. Allows customization of:

        - **Chunking strategy**: How documents are split (fixed-pages, token-based, or hybrid)
        - **Thresholds**: When to trigger chunking based on page count or token count
        - **Chunk size and overlap**: Control chunk boundaries and context preservation
        - **Processing mode**: Parallel (faster) or sequential (cost-optimized)
        - **Aggregation strategy**: How to combine results from multiple chunks



        Default Configuration

        If not provided, uses sensible defaults optimized for most use cases:

        - Strategy: ``'hybrid'`` (recommended - balances token and page limits)
        - Page threshold: 100 pages
        - Token threshold: 150,000 tokens
        - Processing mode: ``'parallel'``
        - Max concurrency: 10
        - Aggregation strategy: ``'majority-vote'``



        Strategy Comparison

        | Strategy | Best For | Pros | Cons |
        |----------|----------|------|------|
        | ``hybrid`` | Most documents | Balances token/page limits | Slightly more complex |
        | ``token-based`` | Variable density | Respects model limits | Slower analysis |
        | ``fixed-pages`` | Uniform density | Simple, fast | May exceed token limits |

        :default: undefined (uses default configuration when enableChunking is true)

        :see: {@link ChunkingConfig } for detailed configuration options
        :stability: experimental
        '''
        result = self._values.get("chunking_config")
        return typing.cast(typing.Optional["ChunkingConfig"], result)

    @builtins.property
    def classification_bedrock_model(self) -> typing.Optional["BedrockModelProps"]:
        '''(experimental) Bedrock foundation model for document classification step.

        :stability: experimental
        '''
        result = self._values.get("classification_bedrock_model")
        return typing.cast(typing.Optional["BedrockModelProps"], result)

    @builtins.property
    def classification_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for document classification.

        Must include placeholder for document content.

        :default: DEFAULT_CLASSIFICATION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("classification_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def enable_chunking(self) -> typing.Optional[builtins.bool]:
        '''(experimental) Enable PDF chunking for large documents.

        When enabled, documents exceeding configured thresholds will be automatically
        split into chunks, processed in parallel or sequentially, and results aggregated.

        This feature is useful for:

        - Processing large PDFs (>100 pages)
        - Handling documents that exceed Bedrock token limits (~200K tokens)
        - Improving processing reliability for complex documents
        - Processing documents with variable content density

        The chunking workflow:

        1. Analyzes PDF to determine page count and estimate token count
        2. Decides if chunking is needed based on configured thresholds
        3. If chunking is needed, splits PDF into chunks and uploads to S3
        4. Processes each chunk through classification and extraction
        5. Aggregates results using majority voting for classification
        6. Deduplicates entities across chunks
        7. Cleans up temporary chunk files from S3

        :default: false

        :stability: experimental
        '''
        result = self._values.get("enable_chunking")
        return typing.cast(typing.Optional[builtins.bool], result)

    @builtins.property
    def enrichment_lambda_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"]:
        '''(experimental) Optional Lambda function for document enrichment step.

        If provided, will be invoked after extraction with workflow state.

        :stability: experimental
        '''
        result = self._values.get("enrichment_lambda_function")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"], result)

    @builtins.property
    def post_processing_lambda_function(
        self,
    ) -> typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"]:
        '''(experimental) Optional Lambda function for post-processing step.

        If provided, will be invoked after enrichment with workflow state.

        :stability: experimental
        '''
        result = self._values.get("post_processing_lambda_function")
        return typing.cast(typing.Optional["_aws_cdk_aws_lambda_ceddda9d.Function"], result)

    @builtins.property
    def processing_bedrock_model(self) -> typing.Optional["BedrockModelProps"]:
        '''(experimental) Bedrock foundation model for document extraction step.

        :stability: experimental
        '''
        result = self._values.get("processing_bedrock_model")
        return typing.cast(typing.Optional["BedrockModelProps"], result)

    @builtins.property
    def processing_prompt(self) -> typing.Optional[builtins.str]:
        '''(experimental) Custom prompt template for document extraction.

        Must include placeholder for document content and classification result.

        :default: DEFAULT_EXTRACTION_PROMPT

        :stability: experimental
        '''
        result = self._values.get("processing_prompt")
        return typing.cast(typing.Optional[builtins.str], result)

    @builtins.property
    def step_timeouts(self) -> typing.Optional["_aws_cdk_ceddda9d.Duration"]:
        '''(experimental) Timeout for individual Step Functions tasks (classification, extraction, etc.).

        :default: Duration.minutes(5)

        :stability: experimental
        '''
        result = self._values.get("step_timeouts")
        return typing.cast(typing.Optional["_aws_cdk_ceddda9d.Duration"], result)

    @builtins.property
    def processing_agent_parameters(self) -> "BatchAgentProps":
        '''(experimental) This parameter takes precedence over the ``processingBedrockModel`` parameter.

        :stability: experimental
        '''
        result = self._values.get("processing_agent_parameters")
        assert result is not None, "Required property 'processing_agent_parameters' is missing"
        return typing.cast("BatchAgentProps", result)

    def __eq__(self, rhs: typing.Any) -> builtins.bool:
        return isinstance(rhs, self.__class__) and rhs._values == self._values

    def __ne__(self, rhs: typing.Any) -> builtins.bool:
        return not (rhs == self)

    def __repr__(self) -> str:
        return "AgenticDocumentProcessingProps(%s)" % ", ".join(
            k + "=" + repr(v) for k, v in self._values.items()
        )


__all__ = [
    "AccessLog",
    "AccessLogProps",
    "AclConfiguration",
    "AdditionalDistributionProps",
    "AgentCoreJwtAuthorizerConfig",
    "AgentCoreRuntimeHostingAdapter",
    "AgentCoreRuntimeHostingAdapterProps",
    "AgentDefinitionProps",
    "AgentHostingConfig",
    "AgentHostingResult",
    "AgentToolsLocationDefinition",
    "AgenticDocumentProcessing",
    "AgenticDocumentProcessingProps",
    "AggregatedResult",
    "AggregationRequest",
    "BaseAgent",
    "BaseAgentProps",
    "BaseDocumentProcessing",
    "BaseDocumentProcessingProps",
    "BaseKnowledgeBase",
    "BaseKnowledgeBaseProps",
    "BatchAgent",
    "BatchAgentProps",
    "BedrockCrossRegionInferencePrefix",
    "BedrockDocumentProcessing",
    "BedrockDocumentProcessingProps",
    "BedrockKnowledgeBase",
    "BedrockKnowledgeBaseProps",
    "BedrockModelProps",
    "BedrockModelUtils",
    "ChunkClassificationResult",
    "ChunkMetadata",
    "ChunkProcessingResult",
    "ChunkResult",
    "ChunkingConfig",
    "ChunkingConfigUsed",
    "ChunkingRequest",
    "ChunkingResponse",
    "ChunksSummary",
    "CleanupRequest",
    "CleanupResponse",
    "CloudWatchTransactionSearch",
    "CloudWatchTransactionSearchProps",
    "CloudfrontDistributionObservabilityPropertyInjector",
    "CognitoAuthenticator",
    "CognitoAuthenticatorProps",
    "CreateKnowledgeBaseConfiguration",
    "CustomDomainConfig",
    "DataLoader",
    "DataLoaderProps",
    "DatabaseConfig",
    "DatabaseEngine",
    "DefaultAgentConfig",
    "DefaultDocumentProcessingConfig",
    "DefaultObservabilityConfig",
    "DefaultRuntimes",
    "DocumentContent",
    "Entity",
    "EventbridgeBroker",
    "EventbridgeBrokerProps",
    "FileInput",
    "FileType",
    "FixedPagesConfig",
    "Frontend",
    "FrontendProps",
    "GuardrailConfiguration",
    "HybridConfig",
    "IAdapter",
    "IAuthenticator",
    "ICommunicationAdapter",
    "IContextStrategy",
    "IHostingAdapter",
    "IKnowledgeBase",
    "IObservable",
    "ISessionStore",
    "InteractiveAgent",
    "InteractiveAgentProps",
    "InvokeType",
    "KnowledgeBaseRuntimeConfig",
    "LambdaHostingAdapter",
    "LambdaHostingAdapterProps",
    "LambdaIamUtils",
    "LambdaIamUtilsStackInfo",
    "LambdaLogsPermissionsProps",
    "LambdaLogsPermissionsResult",
    "LambdaObservabilityPropertyInjector",
    "LogGroupDataProtectionProps",
    "LogGroupDataProtectionUtils",
    "Network",
    "NetworkProps",
    "NoAuthenticator",
    "NoChunkingResponse",
    "NullConversationManager",
    "ObservableProps",
    "PowertoolsConfig",
    "QueuedS3Adapter",
    "QueuedS3AdapterProps",
    "RetrievalConfiguration",
    "S3SessionManager",
    "S3SessionManagerProps",
    "SlidingWindowConversationManager",
    "SlidingWindowConversationManagerProps",
    "StateMachineObservabilityPropertyInjector",
    "StreamingHttpAdapter",
    "StreamingHttpAdapterProps",
    "ThrottleSettings",
    "TokenAnalysis",
    "TokenBasedConfig",
    "VectorStoreConfiguration",
]

publication.publish()

def _typecheckingstub__d0c79880c62971c0b94c27211aa57e94a14b8b594133479abb3588b22b301cf7(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    bucket_name: typing.Optional[builtins.str] = None,
    bucket_prefix: typing.Optional[builtins.str] = None,
    lifecycle_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.LifecycleRule, typing.Dict[builtins.str, typing.Any]]]] = None,
    versioned: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__bb3bab7dfdf58893d762b8a3579b2e248b758bf8db791e3986df9451e32ada3e(
    service_name: builtins.str,
    resource_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9988cc2b7efe7f7c7c17c94e465c36241770aa21cbe1b07c110b8e2dacedaf59(
    service_name: builtins.str,
    resource_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b0d5807bf69e9243b9fd452b7437cfe9f4102d78752673f223f3ae14073937e1(
    *,
    bucket_name: typing.Optional[builtins.str] = None,
    bucket_prefix: typing.Optional[builtins.str] = None,
    lifecycle_rules: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_s3_ceddda9d.LifecycleRule, typing.Dict[builtins.str, typing.Any]]]] = None,
    versioned: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__899807b7dca2d7be5f310df5984cd7a0c5fe3c612a8995f0927c15acbec703da(
    *,
    enabled: builtins.bool,
    metadata_field: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__14d3ed5928e5166082cd47a907ab754473c20bb045dc424135b4690811543601(
    *,
    comment: typing.Optional[builtins.str] = None,
    enabled: typing.Optional[builtins.bool] = None,
    price_class: typing.Optional[_aws_cdk_aws_cloudfront_ceddda9d.PriceClass] = None,
    web_acl_id: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f94f8a2948aa983ed72417fef6288dd7e6e44676ff9978b24bb098f0fdefe4c5(
    *,
    discovery_url: builtins.str,
    allowed_audience: typing.Optional[typing.Sequence[builtins.str]] = None,
    allowed_clients: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb25afac88d833c132fd50b3235b65ddb59595d392340b28edd6ba7744888884(
    *,
    container_image_uri: typing.Optional[builtins.str] = None,
    custom_jwt_authorizer: typing.Optional[typing.Union[AgentCoreJwtAuthorizerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    endpoint_name: typing.Optional[builtins.str] = None,
    network_mode: typing.Optional[builtins.str] = None,
    protocol_configuration: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4a2d1deab0cc9bf96473ffb32138a2c564c47ae7382fe5d2d1f0e43da3324272(
    *,
    bedrock_model: typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]],
    system_prompt: _aws_cdk_aws_s3_assets_ceddda9d.Asset,
    additional_policy_statements_for_knowledge_bases: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    additional_policy_statements_for_tools: typing.Optional[typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement]] = None,
    knowledge_bases: typing.Optional[typing.Sequence[IKnowledgeBase]] = None,
    lambda_layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.LayerVersion]] = None,
    tools: typing.Optional[typing.Sequence[_aws_cdk_aws_s3_assets_ceddda9d.Asset]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__813d39a5e98d744b41545d2dcb2ba7b3ff0536603077a6aa128c047f5b09da83(
    *,
    agent_name: builtins.str,
    agent_role: _aws_cdk_aws_iam_ceddda9d.Role,
    encryption_key: _aws_cdk_aws_kms_ceddda9d.Key,
    environment: typing.Mapping[builtins.str, builtins.str],
    scope: _constructs_77d1e7e8.Construct,
    system_prompt_bucket: builtins.str,
    system_prompt_key: builtins.str,
    tools_config: builtins.str,
    architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    knowledge_base_configs: typing.Optional[builtins.str] = None,
    knowledge_base_layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]] = None,
    knowledge_base_system_prompt_addition: typing.Optional[builtins.str] = None,
    lambda_layers: typing.Optional[typing.Sequence[_aws_cdk_aws_lambda_ceddda9d.ILayerVersion]] = None,
    memory_size: typing.Optional[jsii.Number] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6e7a193ab7503b5bc22ec5155a0096d212a3a31a90893b3fc9b006d21caf8619(
    *,
    endpoint: builtins.str,
    agent_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.IFunction] = None,
    cfn_runtime: typing.Optional[_aws_cdk_aws_bedrockagentcore_ceddda9d.CfnRuntime] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__127edbe188000e5bd850f207a22867fb37ca32772d05138c8caeec887b302f84(
    *,
    bucket_name: builtins.str,
    is_file: builtins.bool,
    is_zip_archive: builtins.bool,
    key: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a3d00e6593683f5dec7ec3c48b2f42490178605c9014ef127d0b29e509121357(
    *,
    chunks_summary: typing.Union[ChunksSummary, typing.Dict[builtins.str, typing.Any]],
    classification: builtins.str,
    classification_confidence: jsii.Number,
    document_id: builtins.str,
    entities: typing.Sequence[typing.Union[Entity, typing.Dict[builtins.str, typing.Any]]],
    partial_result: builtins.bool,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__500ce1d863484da9d361c48793d43ddb7af599b17ddd5d5bbe06cd62611c965f(
    *,
    chunk_results: typing.Sequence[typing.Union[ChunkResult, typing.Dict[builtins.str, typing.Any]]],
    document_id: builtins.str,
    aggregation_strategy: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71b734ed2750632299f59fd7513ccde0ee5f9974b68f8c52b53e2255cdee86ff(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__40fa4a59f1a0502756f07aba8d6cba5255e1743cbc160af92ff68cb3b17fef23(
    *,
    description: builtins.str,
    name: builtins.str,
    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2677306b18b77c5114d824ae734b83ac837c5ea4a5b8805948f0388f1dd7995(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    prompt: builtins.str,
    expect_json: typing.Optional[builtins.bool] = None,
    invoke_type: typing.Optional[InvokeType] = None,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fa5a5937a282e8ddfa91598805b072febd3483c7f6ad9ed8eed9f52e4f0912e9(
    *,
    description: builtins.str,
    name: builtins.str,
    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    knowledge_base_id: builtins.str,
    create: typing.Optional[typing.Union[CreateKnowledgeBaseConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    knowledge_base_arn: typing.Optional[builtins.str] = None,
    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e45242c855c6631d66b287b02966cc10c7006e63b282779a6fdb35ce0a2a7a67(
    *,
    cross_region_inference_prefix: typing.Optional[BedrockCrossRegionInferencePrefix] = None,
    fm_model_id: typing.Optional[_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier] = None,
    use_cross_region_inference: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2d6dd904193a96951d351d9b9f88371b9b85f9f44a00b0cbdbfba9f24849527(
    scope: _constructs_77d1e7e8.Construct,
    *,
    cross_region_inference_prefix: typing.Optional[BedrockCrossRegionInferencePrefix] = None,
    fm_model_id: typing.Optional[_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier] = None,
    use_cross_region_inference: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd9e20bf6521c15d5e5562ba4c6c68cd96f7bb6427af870a73ad163c3439483b(
    *,
    document_classification: builtins.str,
    confidence: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__dff34b4820a98b0388febbe964d8d3a5e892547b131e5dae54581ec4a2640cad(
    *,
    bucket: builtins.str,
    chunk_id: builtins.str,
    chunk_index: jsii.Number,
    end_page: jsii.Number,
    estimated_tokens: jsii.Number,
    key: builtins.str,
    page_count: jsii.Number,
    start_page: jsii.Number,
    total_chunks: jsii.Number,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__84bb0c085311676bc3e27ceca4b53069c592a7e70466cf418df2f50d6da4b126(
    *,
    entities: typing.Sequence[typing.Union[Entity, typing.Dict[builtins.str, typing.Any]]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__74cdd2c037c32a152c200fbc3680ef5c78fb6788f991311e1236992871f04ab8(
    *,
    chunk_id: builtins.str,
    chunk_index: jsii.Number,
    classification_result: typing.Optional[typing.Union[ChunkClassificationResult, typing.Dict[builtins.str, typing.Any]]] = None,
    error: typing.Optional[builtins.str] = None,
    processing_result: typing.Optional[typing.Union[ChunkProcessingResult, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__af1fff712e836fae5842106b6630cf29c804320a96e688f2f9522a85655cffcf(
    *,
    aggregation_strategy: typing.Optional[builtins.str] = None,
    chunk_size: typing.Optional[jsii.Number] = None,
    max_concurrency: typing.Optional[jsii.Number] = None,
    max_pages_per_chunk: typing.Optional[jsii.Number] = None,
    max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    min_success_threshold: typing.Optional[jsii.Number] = None,
    overlap_pages: typing.Optional[jsii.Number] = None,
    overlap_tokens: typing.Optional[jsii.Number] = None,
    page_threshold: typing.Optional[jsii.Number] = None,
    processing_mode: typing.Optional[builtins.str] = None,
    strategy: typing.Optional[builtins.str] = None,
    target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    token_threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__52f725ee23e9fd3affa617e37a2e0d10494eac3a12ba1d5fc39ac6dbd56def5f(
    *,
    strategy: builtins.str,
    total_pages: jsii.Number,
    total_tokens: jsii.Number,
    chunk_size: typing.Optional[jsii.Number] = None,
    max_pages_per_chunk: typing.Optional[jsii.Number] = None,
    max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    overlap_pages: typing.Optional[jsii.Number] = None,
    overlap_tokens: typing.Optional[jsii.Number] = None,
    processing_mode: typing.Optional[builtins.str] = None,
    target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__18556a2a972ec6282556c235c52399c48b90014067a995b2f0cb0cc47dd790f3(
    *,
    content: typing.Union[DocumentContent, typing.Dict[builtins.str, typing.Any]],
    content_type: builtins.str,
    document_id: builtins.str,
    config: typing.Optional[typing.Union[ChunkingConfig, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30392a0d7945b1a642c3ae79c76025695230f699b4688f6ed29e409a39f321f2(
    *,
    chunks: typing.Sequence[typing.Union[ChunkMetadata, typing.Dict[builtins.str, typing.Any]]],
    config: typing.Union[ChunkingConfigUsed, typing.Dict[builtins.str, typing.Any]],
    document_id: builtins.str,
    requires_chunking: builtins.bool,
    strategy: builtins.str,
    token_analysis: typing.Union[TokenAnalysis, typing.Dict[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9b7fa01f3556d4c74e9b1095a671fde30d6c5b5c71c294ca4412ce58dc15f535(
    *,
    failed_chunks: jsii.Number,
    successful_chunks: jsii.Number,
    total_chunks: jsii.Number,
    total_tokens_processed: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c4209557aad5933432f5d67ea04b9856c85e9fd94b4d488179516f51e1e41cc7(
    *,
    chunks: typing.Sequence[typing.Union[ChunkMetadata, typing.Dict[builtins.str, typing.Any]]],
    document_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c65b9a851a891fc5241b9fce5931c7b91903c7f335a932bec1803689cc2b3619(
    *,
    deleted_chunks: jsii.Number,
    document_id: builtins.str,
    errors: typing.Sequence[builtins.str],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f3c5a017e701e8d87469e4e204b145be1e398bb7f4bfa38aa21c16115939e71f(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    policy_name: typing.Optional[builtins.str] = None,
    sampling_percentage: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__516779ddac5a1226a9b564150c57d6b9dbf9971e2131b677de99815d4d81c964(
    *,
    policy_name: typing.Optional[builtins.str] = None,
    sampling_percentage: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2270aedab8c9db027e16b28fd9de8610d0f7e47778cdf1d501539d0e440a561d(
    original_props: typing.Any,
    *,
    id: builtins.str,
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__624aa76fbb25c1b63246b5b7fab2db8d727c5e5e55244e35cf75c4df67c9498b(
    *,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    user_pool: typing.Optional[_aws_cdk_aws_cognito_ceddda9d.UserPool] = None,
    user_pool_client: typing.Optional[_aws_cdk_aws_cognito_ceddda9d.UserPoolClient] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5a66ad6b4c71f08ad11270f15622825326a8ae23d1f4b8349ee45ee1997ed029(
    *,
    data_source_bucket_name: builtins.str,
    chunking_strategy: typing.Optional[builtins.str] = None,
    data_source_prefix: typing.Optional[builtins.str] = None,
    embedding_model_id: typing.Optional[builtins.str] = None,
    max_tokens: typing.Optional[jsii.Number] = None,
    overlap_tokens: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__45e622c5dc8075e1ee5cdf9df72ea9b7ca33e0a7cf348dfaf54f93e635e9dde8(
    *,
    certificate: _aws_cdk_aws_certificatemanager_ceddda9d.ICertificate,
    domain_name: builtins.str,
    hosted_zone: typing.Optional[_aws_cdk_aws_route53_ceddda9d.IHostedZone] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__270a76813d598a503e52c71a882567ace4b31275076ba0bcefcc5ff1011d5018(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    database_config: typing.Union[DatabaseConfig, typing.Dict[builtins.str, typing.Any]],
    file_inputs: typing.Sequence[typing.Union[FileInput, typing.Dict[builtins.str, typing.Any]]],
    memory_size: typing.Optional[jsii.Number] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efd46917d5b396c28d8f6ffeea52cc31230f92bb12d3a0b916d59526a781140a(
    statement: _aws_cdk_aws_iam_ceddda9d.PolicyStatement,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd063a11debecd44b792418fb4aa1f7320d173a2fbc3280588266e303321f59e(
    value: typing.Optional[_aws_cdk_aws_s3_deployment_ceddda9d.BucketDeployment],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__79385aca2a5a0bb7a2e64dbdad2106a739cca7fbad6670895f995ed402f5a8fe(
    *,
    database_config: typing.Union[DatabaseConfig, typing.Dict[builtins.str, typing.Any]],
    file_inputs: typing.Sequence[typing.Union[FileInput, typing.Dict[builtins.str, typing.Any]]],
    memory_size: typing.Optional[jsii.Number] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28429cd4673598c14d3b2db601f7758c41a1c9972a1d3aeb36a73a6d7afffe94(
    *,
    database_name: builtins.str,
    engine: DatabaseEngine,
    secret: _aws_cdk_aws_secretsmanager_ceddda9d.ISecret,
    security_group: _aws_cdk_aws_ec2_ceddda9d.ISecurityGroup,
    vpc: _aws_cdk_aws_ec2_ceddda9d.IVpc,
    cluster: typing.Optional[_aws_cdk_aws_rds_ceddda9d.IDatabaseCluster] = None,
    instance: typing.Optional[_aws_cdk_aws_rds_ceddda9d.IDatabaseInstance] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4cb6edfc3ff826b337155281a5d87d7f3be9eab183ccc4426ff88802b3e0c0b4(
    *,
    bucket: builtins.str,
    filename: builtins.str,
    key: builtins.str,
    location: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__efeba2470d944f9864ade05399b91a8692e4fbe022602a30b2b4ef50a015b2fb(
    *,
    type: builtins.str,
    value: builtins.str,
    chunk_index: typing.Optional[jsii.Number] = None,
    page: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5391a3753ae12822ab842065b2f29fede1c6b75f7e0ba6cdca1be351c9c104c3(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    event_source: builtins.str,
    kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    name: typing.Optional[builtins.str] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__71a910ff106734bd214c5973b84305b89274d3d6adbe4eedaa2c546cb060d0d7(
    detail_type: builtins.str,
    event_detail: typing.Any,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ecd91fa4cae79b6f27bdbae2c38230e7edda9cec831ac503ca3b7c01b0311241(
    *,
    event_source: builtins.str,
    kms_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    name: typing.Optional[builtins.str] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f22614c3ee9aff68919f8ac64743fb8c255ed9c33337d90d40c2622733942ed5(
    *,
    file_path: builtins.str,
    file_type: FileType,
    continue_on_error: typing.Optional[builtins.bool] = None,
    execution_order: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9790b02ab060fae9c48b274099105523cb8bc3432d04149d0b7a5f204a8b1bac(
    *,
    chunk_size: typing.Optional[jsii.Number] = None,
    overlap_pages: typing.Optional[jsii.Number] = None,
    page_threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__59f5637ea312a9fb8090cc497bbaa3fb29d31e5a16d1958df0e9a4337936da88(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    source_directory: builtins.str,
    build_command: typing.Optional[builtins.str] = None,
    build_output_directory: typing.Optional[builtins.str] = None,
    custom_domain: typing.Optional[typing.Union[CustomDomainConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    distribution_props: typing.Optional[typing.Union[AdditionalDistributionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    error_responses: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse, typing.Dict[builtins.str, typing.Any]]]] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    skip_build: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2648a6f2c6f02177f5b324264b7de549aa23b0c1d93c8d6cccbc307a85e0c0fc(
    *,
    source_directory: builtins.str,
    build_command: typing.Optional[builtins.str] = None,
    build_output_directory: typing.Optional[builtins.str] = None,
    custom_domain: typing.Optional[typing.Union[CustomDomainConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    distribution_props: typing.Optional[typing.Union[AdditionalDistributionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    error_responses: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_cloudfront_ceddda9d.ErrorResponse, typing.Dict[builtins.str, typing.Any]]]] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    skip_build: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d604d1407a674dc8a1780469f6fca800816236372c95a3b5438a97e1c9faff32(
    *,
    guardrail_id: builtins.str,
    guardrail_version: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d99de61f167223b9a43c96878ed271835a461896851550035527119e8b896dfb(
    *,
    max_pages_per_chunk: typing.Optional[jsii.Number] = None,
    overlap_tokens: typing.Optional[jsii.Number] = None,
    page_threshold: typing.Optional[jsii.Number] = None,
    target_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    token_threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5998f6c7e16512d92cd00097e77d737333304685208eb36a522c156f8378a9e7(
    scope: _constructs_77d1e7e8.Construct,
    id_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b61e74ddd8982f4b30ae59307c9fb3adaff26122ddc7f5faabc2cc8e1e2da034(
    scope: _constructs_77d1e7e8.Construct,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine,
    *,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cd0aad7a5879633fca8d89cbf92e8f5a13e31615116036f29a82a58c1bb4727d(
    scope: _constructs_77d1e7e8.Construct,
    id_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__82a45114a0ff76d4b9d091edd6674d4e762dc5ca19631d61579cf1aa47e30b5e(
    additional_iam_actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    narrow_actions: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__17f7e7f35ea8e49cf6ded248435aa1e1dcf416e61c549f3e7b74baad3ac399e7(
    scope: _constructs_77d1e7e8.Construct,
    *,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1637565319dd5e7a968e97c2502fcec6902286f0199800d1c319b13e1be9e8bf(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3b2728940dd748cbcf160c1d51bd321bce3e08a61f3cef60874a4c209a397858(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ebc9cce6c384f39d072a81b2fdb80ed48808971e0a0f1bce9b65437a686b37c(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__548d7298dba8149d507666f77a3ac2d921fe8d37efcb6d53d0ac3fadcec0ef38(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8c5ceb128f06013736509b04ecbcde0f14a2fe9c071515e2ed9489d35960e92a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    authenticator: typing.Optional[IAuthenticator] = None,
    communication_adapter: typing.Optional[ICommunicationAdapter] = None,
    context_strategy: typing.Optional[IContextStrategy] = None,
    hosting_adapter: typing.Optional[IHostingAdapter] = None,
    memory_size: typing.Optional[jsii.Number] = None,
    message_history_limit: typing.Optional[jsii.Number] = None,
    reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
    session_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    session_store: typing.Optional[ISessionStore] = None,
    session_ttl: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__eba4c5624b16f91d89be2a09eeaf9e99f078cde0dfdfdaa2d50e663d366ce5a1(
    *,
    description: builtins.str,
    name: builtins.str,
    retrieval: typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]],
    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    knowledge_base_arn: typing.Optional[builtins.str] = None,
    knowledge_base_id: typing.Optional[builtins.str] = None,
    type: typing.Optional[builtins.str] = None,
    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__96940ead4b065d7e4d6589f754fa6f39078d700f1938bb78866805fe4c09c540(
    *,
    architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    authenticator: typing.Optional[IAuthenticator] = None,
    communication_adapter: typing.Optional[ICommunicationAdapter] = None,
    memory_size: typing.Optional[jsii.Number] = None,
    reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8fea74c9846ad0c5bdddcbfe10063247cb7bcf58aac91e0be80d1226246784e4(
    table_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__ef86294be8c776ba98bebc269fab82304f75649efab35cf030d999168ba5d690(
    key_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7762a976633c1cec438c3058cfc410cab5cdbf541350c2fdcb64bcfd9599e7fb(
    bucket_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    include_objects: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cb1398e35974542f1ff1f03b7872981aa0ef2bb90eed20673a20914f5c7e567c(
    secret_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8aa3558a2d320688189fd59ffa216e00f3b66d4b1a02026a2dc9bd5fd61c5f36(
    topic_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5ed421dddfcb3e375ee01a9efb4d503dd54b5351b630f200cd829438bb6c9c89(
    queue_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__cbdc1926ad0aa5c4b79aa48c962c929c8e50b7236860f58373b511defa1fca97(
    state_machine_arn: builtins.str,
    actions: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__56aa9ee6986a4b2052d36311105a3c43214029d77a8db5f3ca96f5b23dd95f36(
    scope: _constructs_77d1e7e8.Construct,
    base_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__555f78633564658fa9ba3d47cbfcf9615db101bbba832804f67bcce2b828f673(
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1dcdad24849926b01541cd5e3a49b2718bca23f70268629b13a2467789ce6acc(
    *,
    account: builtins.str,
    region: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__47564dc2777638ca33ba53983ac385b2dd8b03133d66569da912ae1ce7e55503(
    *,
    account: builtins.str,
    function_name: builtins.str,
    region: builtins.str,
    scope: _constructs_77d1e7e8.Construct,
    enable_observability: typing.Optional[builtins.bool] = None,
    log_group_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__2180e53f0ba520cfa92d16443491985db8ed304d09797b9d758ad70b55d7b617(
    *,
    policy_statements: typing.Sequence[_aws_cdk_aws_iam_ceddda9d.PolicyStatement],
    unique_function_name: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__97c5107ef8c7184168153144168438a4ff4ae054305d1a82db0a0514c98b6d0b(
    original_props: typing.Any,
    *,
    id: builtins.str,
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__544372751dab1bedee4ed043bef50312abd2658c1142e4b4809c0617165dc597(
    *,
    data_protection_identifiers: typing.Optional[typing.Sequence[_aws_cdk_aws_logs_ceddda9d.DataIdentifier]] = None,
    log_group_encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e3a45e54ca44da7f036d13ce54f925e2a16d4e1ae6f2df04d64a1f10ca0133f0(
    scope: _constructs_77d1e7e8.Construct,
    props: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6ad9a3df68ffea56f493c494b7c642fca53d11a7de99864bb5e94dffe00ed330(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    existing_vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
    ip_addresses: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IIpAddresses] = None,
    max_azs: typing.Optional[jsii.Number] = None,
    nat_gateway_provider: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.NatProvider] = None,
    nat_gateways: typing.Optional[jsii.Number] = None,
    nat_gateway_subnets: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    private: typing.Optional[builtins.bool] = None,
    subnet_configuration: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8ef7c59482181ed4f28e171f52faec6a945cf35a038a8cc79fda7c3b5e028c5e(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    is_default: typing.Optional[builtins.bool] = None,
    owner_account_id: typing.Optional[builtins.str] = None,
    region: typing.Optional[builtins.str] = None,
    return_vpn_gateways: typing.Optional[builtins.bool] = None,
    subnet_group_name_tag: typing.Optional[builtins.str] = None,
    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
    vpc_id: typing.Optional[builtins.str] = None,
    vpc_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__014347d1e11f93271eb3a6b34bc02d137814401023f915adcd8e379b691810e9(
    id: builtins.str,
    service: _aws_cdk_aws_ec2_ceddda9d.InterfaceVpcEndpointService,
    peer: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IPeer] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0c7413b984143840b4fc2e4fe5dd9854fed611c52a71931a04773289b6f1fdde(
    *,
    existing_vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
    ip_addresses: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IIpAddresses] = None,
    max_azs: typing.Optional[jsii.Number] = None,
    nat_gateway_provider: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.NatProvider] = None,
    nat_gateways: typing.Optional[jsii.Number] = None,
    nat_gateway_subnets: typing.Optional[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]] = None,
    private: typing.Optional[builtins.bool] = None,
    subnet_configuration: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetConfiguration, typing.Dict[builtins.str, typing.Any]]]] = None,
    vpc_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__80db949f200ae959bca982905d50ae2ab0f53027aa891dd6a0900de4c7ae5fa0(
    _lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__8f396031ae0cfeeab7a84faee503bde8ba3dca087c9bb20bc0a3ea6d2b433ac6(
    *,
    document_id: builtins.str,
    reason: builtins.str,
    requires_chunking: builtins.bool,
    token_analysis: typing.Union[TokenAnalysis, typing.Dict[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__31fd1e05df7b558405e183d7153d9217ec52b5d7deb1bd88be445a2930061329(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__e065c545d4fce5c4fc2579c3efea8203f50b6d3c8b39aa1595ea3577d04bc025(
    enable_observability: typing.Optional[builtins.bool] = None,
    metrics_namespace: typing.Optional[builtins.str] = None,
    service_name: typing.Optional[builtins.str] = None,
    log_level: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b95daf862a9819daa9b25cecfc08214dc429ef07ac6de3920b5dea59e01616eb(
    scope: _constructs_77d1e7e8.Construct,
    id_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fb0e9adf74054c1b0a1974cab45642af57cb1651ef8052310a0229dae1eac178(
    scope: _constructs_77d1e7e8.Construct,
    state_machine: _aws_cdk_aws_stepfunctions_ceddda9d.StateMachine,
    *,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__76aa2fd577ace3b2507bf11a33f4d039ae5ac0af0d5d3edede30c4515a1a0986(
    scope: _constructs_77d1e7e8.Construct,
    id_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__308867c51abfbbc08d0fba9125db9b86eddda969dc95de8546e6f8cb242ee8a9(
    additional_iam_actions: typing.Optional[typing.Sequence[builtins.str]] = None,
    narrow_actions: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__3fe79d0c4a3a771012bc95cea6a690155ea89fa70073f87564e65aad5cdfdb64(
    scope: _constructs_77d1e7e8.Construct,
    *,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__c2db7ec0d4b3e93062e1f20f29f9821e5a0fd526ecf05f9ccaa6db663fb1e8de(
    *,
    bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.Bucket] = None,
    dlq_max_receive_count: typing.Optional[jsii.Number] = None,
    failed_prefix: typing.Optional[builtins.str] = None,
    processed_prefix: typing.Optional[builtins.str] = None,
    queue_visibility_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    raw_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__0389e881defd6b748c16712149b25f1d6a9c2415742f6287f9424ffee6d97ac9(
    *,
    number_of_results: typing.Optional[jsii.Number] = None,
    retrieval_filter: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__d45521f97bfb1a1163912d233a2c8da0cbcd4b353375612380395214a57c68dc(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    session_ttl: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__28715db6e8895cddffe1f3dd80fd586296e2531b435166f5df3ebdf499e1d6fa(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__fd8b93fe769e4781778c4a9af36af20fbb18949cc82d2ee47d36bd31e3c3419b(
    *,
    bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.IKey] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    session_ttl: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__4280ae99ea0f9116e703fc270a5be763aad71feb49471c69d3345d92d77965e5(
    *,
    window_size: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__011b55520774139b52c951d9cc59273f686e377b5415ee42a57650da571d43e7(
    original_props: typing.Any,
    *,
    id: builtins.str,
    scope: _constructs_77d1e7e8.Construct,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a706d9b87b02e59f326e98799b9e8c13a9ca457ac5ec400ad2353135b5898e6c(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__5fe65fde40d00feea5a114f7b66c391bd98a82bab15ae4f0e8c0efb5025cf1ef(
    _lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a2225f15606d5ad891bca8b49ff734819cbaa0c0a63da3363df104a7926af720(
    *,
    authenticator: typing.Optional[IAuthenticator] = None,
    stage_name: typing.Optional[builtins.str] = None,
    throttle: typing.Optional[typing.Union[ThrottleSettings, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9c51f8e9b793b3797ca9e2c8bd75c1a689276a04bee6d4924b27c32bef5f4749(
    *,
    burst_limit: typing.Optional[jsii.Number] = None,
    rate_limit: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__429b64dc2313f6bc3b05440f33465bc0b0db572fd4032aaaf24627d0864e68cd(
    *,
    avg_tokens_per_page: jsii.Number,
    total_pages: jsii.Number,
    total_tokens: jsii.Number,
    tokens_per_page: typing.Optional[typing.Sequence[jsii.Number]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__a334bfb54e6a69272a4fe5b2f56f0a97d104fadd629c1aeb6ce670eb35f363d9(
    *,
    max_tokens_per_chunk: typing.Optional[jsii.Number] = None,
    overlap_tokens: typing.Optional[jsii.Number] = None,
    token_threshold: typing.Optional[jsii.Number] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__98230924b191ba0192b7d818a592221249c2b38f4ddd572cfc62d08a37b84b42(
    *,
    bucket_name: typing.Optional[builtins.str] = None,
    prefix: typing.Optional[builtins.str] = None,
    type: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__feb650555d9014f75886d26d16787c0c2e83a042e7e61844bf4d21c890ce479c(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__117c249a26f3e7532983afc9123fadff3e20effcc69408df0f45a03eb720ea8a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__60b2b6769cfd7191f20068a71856358b8c84328bb68ac994d8b9e2d135895f28(
    id_prefix: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__900aa9de379313a2a9a3e24a2901f803dec0a30dde90b7255d9f180e263b020d(
    state_machine_id: builtins.str,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__75e07bce24d48571be58cad69f751b10a17a738fdb9db601acdc689ff1e6da22(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__1ffdc1300a392d74aedab074831b812725fc7d9f0b3c025e42cefd06be3e3273(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    description: builtins.str,
    name: builtins.str,
    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__30511d5990f52f2808903d144bad5a5c502c00b0b8c98b4fd52a3df61c18b19d(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
    prompt: builtins.str,
    expect_json: typing.Optional[builtins.bool] = None,
    invoke_type: typing.Optional[InvokeType] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__7393f9c6b2af93f7d8668b32cec54ba8c77259644ab01f57b3fbd50c78923134(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    aggregation_prompt: typing.Optional[builtins.str] = None,
    chunking_config: typing.Optional[typing.Union[ChunkingConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_prompt: typing.Optional[builtins.str] = None,
    enable_chunking: typing.Optional[builtins.bool] = None,
    enrichment_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    post_processing_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    processing_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    processing_prompt: typing.Optional[builtins.str] = None,
    step_timeouts: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b765dc24cd888585470934e534f4d8e979ddebd46e42601cc8b50c73499e7d4e(
    id: builtins.str,
    *,
    cross_region_inference_prefix: typing.Optional[BedrockCrossRegionInferencePrefix] = None,
    fm_model_id: typing.Optional[_aws_cdk_aws_bedrock_ceddda9d.FoundationModelIdentifier] = None,
    use_cross_region_inference: typing.Optional[builtins.bool] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__9606a6418d69bde20176ec33b27eaa22c0e0cdb6b105d382e9d038566f7a29f3(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    aggregation_prompt: typing.Optional[builtins.str] = None,
    chunking_config: typing.Optional[typing.Union[ChunkingConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_prompt: typing.Optional[builtins.str] = None,
    enable_chunking: typing.Optional[builtins.bool] = None,
    enrichment_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    post_processing_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    processing_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    processing_prompt: typing.Optional[builtins.str] = None,
    step_timeouts: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__881273bf12c7a325cf85df5cec4c868a102b3e1454218addb9ce294190f2a295(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    knowledge_base_id: builtins.str,
    create: typing.Optional[typing.Union[CreateKnowledgeBaseConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    guardrail: typing.Optional[typing.Union[GuardrailConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    knowledge_base_arn: typing.Optional[builtins.str] = None,
    vector_store: typing.Optional[typing.Union[VectorStoreConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    description: builtins.str,
    name: builtins.str,
    acl: typing.Optional[typing.Union[AclConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
    retrieval: typing.Optional[typing.Union[RetrievalConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__6cff1e3b59e2a9d06d2f540ea58ee953f1c1ce1d8e3d8246e78253a77fa04e07(
    lambda_function: _aws_cdk_aws_lambda_ceddda9d.IFunction,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__f200e09b5bc954c48531f3974c2eb013ba36e16011b9b0e8026a38830687556a(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    agent_definition: typing.Union[AgentDefinitionProps, typing.Dict[builtins.str, typing.Any]],
    agent_name: builtins.str,
    agent_architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    service_principal: typing.Optional[_aws_cdk_aws_iam_ceddda9d.ServicePrincipal] = None,
    architecture: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Architecture] = None,
    authenticator: typing.Optional[IAuthenticator] = None,
    communication_adapter: typing.Optional[ICommunicationAdapter] = None,
    context_strategy: typing.Optional[IContextStrategy] = None,
    hosting_adapter: typing.Optional[IHostingAdapter] = None,
    memory_size: typing.Optional[jsii.Number] = None,
    message_history_limit: typing.Optional[jsii.Number] = None,
    reserved_concurrent_executions: typing.Optional[jsii.Number] = None,
    session_bucket: typing.Optional[_aws_cdk_aws_s3_ceddda9d.IBucket] = None,
    session_store: typing.Optional[ISessionStore] = None,
    session_ttl: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__b7f396236f637ec7234d81b355cf773497392b537455f3d888c4b7170ceed70a(
    scope: _constructs_77d1e7e8.Construct,
    id: builtins.str,
    *,
    processing_agent_parameters: typing.Union[BatchAgentProps, typing.Dict[builtins.str, typing.Any]],
    aggregation_prompt: typing.Optional[builtins.str] = None,
    chunking_config: typing.Optional[typing.Union[ChunkingConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_prompt: typing.Optional[builtins.str] = None,
    enable_chunking: typing.Optional[builtins.bool] = None,
    enrichment_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    post_processing_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    processing_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    processing_prompt: typing.Optional[builtins.str] = None,
    step_timeouts: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
) -> None:
    """Type checking stubs"""
    pass

def _typecheckingstub__da9ccab0035a06d18b5aa3f2de69201b3bbd6e30f7707a291977a0e4f83a72f4(
    *,
    log_group_data_protection: typing.Optional[typing.Union[LogGroupDataProtectionProps, typing.Dict[builtins.str, typing.Any]]] = None,
    metric_namespace: typing.Optional[builtins.str] = None,
    metric_service_name: typing.Optional[builtins.str] = None,
    document_processing_table: typing.Optional[_aws_cdk_aws_dynamodb_ceddda9d.Table] = None,
    enable_observability: typing.Optional[builtins.bool] = None,
    encryption_key: typing.Optional[_aws_cdk_aws_kms_ceddda9d.Key] = None,
    eventbridge_broker: typing.Optional[EventbridgeBroker] = None,
    ingress_adapter: typing.Optional[IAdapter] = None,
    network: typing.Optional[Network] = None,
    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
    workflow_timeout: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    aggregation_prompt: typing.Optional[builtins.str] = None,
    chunking_config: typing.Optional[typing.Union[ChunkingConfig, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    classification_prompt: typing.Optional[builtins.str] = None,
    enable_chunking: typing.Optional[builtins.bool] = None,
    enrichment_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    post_processing_lambda_function: typing.Optional[_aws_cdk_aws_lambda_ceddda9d.Function] = None,
    processing_bedrock_model: typing.Optional[typing.Union[BedrockModelProps, typing.Dict[builtins.str, typing.Any]]] = None,
    processing_prompt: typing.Optional[builtins.str] = None,
    step_timeouts: typing.Optional[_aws_cdk_ceddda9d.Duration] = None,
    processing_agent_parameters: typing.Union[BatchAgentProps, typing.Dict[builtins.str, typing.Any]],
) -> None:
    """Type checking stubs"""
    pass

for cls in [IAdapter, IAuthenticator, ICommunicationAdapter, IContextStrategy, IHostingAdapter, IKnowledgeBase, IObservable, ISessionStore]:
    typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])
