constructs

type APIKeyAuthorizer struct {
	constructs.Construct
	Authorizer        awsapigatewayv2.IHttpRouteAuthorizer
	ValidatorFunction awslambda.IFunction
}

type APIKeyAuthorizerProps struct {
	// API key parameter source (header or query)
	APIKeySource *string `json:"apiKeySource"`
	// Parameter name (e.g., "X-API-Key" for header or "apiKey" for query)
	APIKeyParameter *string `json:"apiKeyParameter"`
	// Optional function to validate API keys (if not provided, creates one)
	ValidatorFunction awslambda.IFunction `json:"validatorFunction"`
	// DynamoDB table name for storing API keys (optional)
	APIKeyTableName *string `json:"apiKeyTableName"`
	// Cache results for this many seconds (0-3600)
	ResultsCacheTtl *float64 `json:"resultsCacheTtl"`
}

type AlarmConfig struct {
	// Enable error rate alarm
	EnableErrorAlarm *bool
	// Error rate threshold (percentage)
	ErrorRateThreshold *float64
	// Enable latency alarm
	EnableLatencyAlarm *bool
	// Latency threshold in milliseconds
	LatencyThreshold *float64
	// Enable throttle alarm
	EnableThrottleAlarm *bool
	// Throttle count threshold
	ThrottleThreshold *float64
	// Enable concurrent executions alarm
	EnableConcurrentAlarm *bool
	// Concurrent executions threshold
	ConcurrentThreshold *float64
	// SNS topic for alarm notifications
	AlarmTopic awssns.ITopic
}

type AlarmThresholds struct {
	// Error rate threshold (percentage)
	ErrorRate *float64
	// Latency threshold (milliseconds)
	LatencyP99 *float64
	// Throttle count threshold
	ThrottleCount *float64
	// Concurrent executions threshold
	ConcurrentExecutions *float64
	// Custom thresholds
	CustomThresholds *map[string]*float64
}

type AuditLevel string

type AuditingConstruct struct {
	constructs.Construct
	AuditBucket            awss3.Bucket
	EncryptionKey          awskms.Key
	CloudTrail             awscloudtrail.Trail
	ApplicationLogGroup    awslogs.LogGroup
	DatabaseLogGroup       awslogs.LogGroup
	AuditLogGroup          awslogs.LogGroup
	LogProcessingFunction  awslambda.Function
	LogStream              awskinesis.Stream
	FirehoseDeliveryStream awskinesisfirehose.CfnDeliveryStream
	AuditDashboard         awscloudwatch.Dashboard
	AuditAlarms            []awscloudwatch.Alarm
	IntegrityFunction      awslambda.Function
	ComplianceFunction     awslambda.Function
}

type AuditingProps struct {
	// Application name for resource naming
	AppName *string

	// Audit level - determines the scope of audit logging
	AuditLevel AuditLevel

	// Enable CloudTrail for API audit logging
	EnableCloudTrail *bool

	// Enable application-level audit logging
	EnableApplicationLogs *bool

	// Enable database audit logging
	EnableDatabaseLogs *bool

	// Enable real-time log processing
	EnableRealTimeProcessing *bool

	// Enable tamper protection for logs
	EnableTamperProtection *bool

	// Enable log aggregation across multiple regions
	EnableLogAggregation *bool

	// Log retention period in days
	LogRetentionDays *float64

	// Enable SIEM integration
	EnableSIEMIntegration *bool

	// SIEM endpoint URL for log forwarding
	SIEMEndpoint *string

	// Enable log analysis and anomaly detection
	EnableLogAnalysis *bool

	// Enable compliance reporting
	EnableComplianceReporting *bool

	// Environment for audit logging (dev, staging, prod)
	Environment *string

	// Enable log encryption
	EnableEncryption *bool

	// Custom KMS key for encryption
	EncryptionKey awskms.IKey

	// Custom S3 bucket for audit logs
	AuditBucket awss3.IBucket

	// Enable cross-account log sharing
	EnableCrossAccountAccess *bool

	// Cross-account role ARNs for log access
	CrossAccountRoleArns *[]*string

	// Enable audit trail integrity checking
	EnableIntegrityChecking *bool

	// Enable audit dashboard
	EnableDashboard *bool

	// Enable audit alerting
	EnableAlerting *bool

	// SNS topic ARN for audit alerts
	AlertTopicArn *string

	// Enable immutable audit logs
	EnableImmutableLogs *bool

	// Enable regulatory compliance features
	EnableRegulatoryCompliance *bool

	// Compliance frameworks to support
	ComplianceFrameworks *[]string
}

type AuthorizationStrategy string

type CRUDOperation string

type CacheAlertThresholds struct {
	HighCacheHitRatio *float64 // Alert if hit ratio above this
	LowCacheHitRatio  *float64 // Alert if hit ratio below this
	HighEvictionRate  *float64 // Alert if eviction rate above this
	HighMemoryUsage   *float64 // Alert if memory usage above this
	HighLatency       *float64 // Alert if latency above this (ms)
}

type CacheInvalidationStrategy string

type CacheStrategy string

type ComplianceFramework string

type ComplianceStack struct {
	constructs.Construct
	CloudTrail         awscloudtrail.Trail
	ConfigRecorder     awsconfig.CfnConfigurationRecorder
	GuardDutyDetector  awsguardduty.CfnDetector
	SecurityHub        awssecurityhub.CfnHub
	ComplianceBucket   awss3.Bucket
	EncryptionKey      awskms.Key
	ComplianceLogGroup awslogs.LogGroup
	ComplianceFunction awslambda.Function
}

type ComplianceStackProps struct {
	// Application name for resource naming
	AppName *string

	// Compliance frameworks to implement
	ComplianceFrameworks *[]ComplianceFramework

	// Enable CloudTrail logging
	EnableCloudTrail *bool

	// Enable AWS Config rules
	EnableConfig *bool

	// Enable GuardDuty threat detection
	EnableGuardDuty *bool

	// Enable Security Hub
	EnableSecurityHub *bool

	// Enable data encryption at rest
	EnableEncryption *bool

	// Data retention period in days
	DataRetentionDays *float64

	// Enable compliance reports
	EnableComplianceReports *bool

	// S3 bucket for compliance data
	ComplianceBucket awss3.IBucket

	// KMS key for encryption
	EncryptionKey awskms.IKey

	// CloudWatch log group for compliance logs
	ComplianceLogGroup awslogs.ILogGroup

	// Enable detailed access logging
	EnableDetailedLogging *bool

	// Enable audit trail
	EnableAuditTrail *bool

	// Environment for compliance (dev, staging, prod)
	Environment *string

	// Organization ID for multi-account setup
	OrganizationId *string

	// Enable compliance automation
	EnableAutomation *bool

	// Notification topic ARN for compliance alerts
	NotificationTopicArn *string
}

type ConnectionTable struct {
	*DynamORMTable
}

type ConnectionTableProps struct {
	DynamORMTableProps
	// Enable user index for user-based queries
	EnableUserIndex *bool
	// Enable tenant index for multi-tenant support
	EnableTenantIndex *bool
}

type CorsConfig struct {
	AllowOrigins     []string
	AllowMethods     []string
	AllowHeaders     []string
	ExposeHeaders    []string
	MaxAge           awscdk.Duration
	AllowCredentials bool
}

type CustomDomainConfig struct {
	DomainName     string
	CertificateArn string
	BasePath       string
}

type DynamORMCRUDAPI struct {
	constructs.Construct

	// The DynamORM table
	Table *DynamORMTable

	// API Gateway REST API
	API awsapigateway.RestApi

	// Lambda functions for different operations
	CreateFunction *LiftFunction
	ReadFunction   *LiftFunction
	UpdateFunction *LiftFunction
	DeleteFunction *LiftFunction
	ListFunction   *LiftFunction
	SearchFunction *LiftFunction

	// API Gateway resources
	EntityResource awsapigateway.Resource
	ItemResource   awsapigateway.Resource

	// Optional cache
	Cache *DynamORMCache

	// CloudWatch metrics
	Metrics map[string]awscloudwatch.Metric

	// IAM execution role
	ExecutionRole awsiam.Role
	// contains filtered or unexported fields
}

type DynamORMCRUDAPIProps struct {
	// Required: The DynamORM table for CRUD operations
	DynamORMTable *DynamORMTable

	// API configuration
	APIName        *string
	APIDescription *string
	StageName      *string

	// Entity configuration
	EntityName     *string // Name of the entity (e.g., "User", "Order")
	EntityResource *string // API resource path (e.g., "/users", "/orders")
	PrimaryKey     *string // Primary key field name
	SortKey        *string // Sort key field name (optional)

	// CRUD operations to enable
	EnabledOperations []CRUDOperation

	// Validation configuration
	ValidationStrategy ValidationStrategy
	ValidationSchema   *string  // JSON schema for validation
	RequiredFields     []string // Required fields for create/update

	// Authorization configuration
	AuthorizationStrategy AuthorizationStrategy
	CognitoUserPool       *string // Cognito User Pool ID
	JWTSecret             *string // JWT secret for validation

	// Multi-tenant configuration
	EnableMultiTenant *bool   // Enable multi-tenant support
	TenantAttribute   *string // Tenant attribute name
	TenantFromAuth    *bool   // Extract tenant from auth context

	// Pagination configuration
	EnablePagination *bool // Enable pagination for list operations
	DefaultPageSize  *int  // Default page size
	MaxPageSize      *int  // Maximum page size

	// Search configuration
	EnableSearch     *bool    // Enable search operations
	SearchableFields []string // Fields that can be searched
	SearchIndexes    []string // GSI names for search

	// Caching configuration
	EnableCaching *bool // Enable response caching
	CacheConfig   *DynamORMCacheProps

	// Monitoring configuration
	EnableMetrics         *bool // Enable CloudWatch metrics
	EnableTracing         *bool // Enable X-Ray tracing
	EnableDetailedMetrics *bool // Enable detailed monitoring

	// Performance configuration
	BatchSize      *int // Batch size for list operations
	TimeoutSeconds *int // Lambda timeout in seconds

	// CORS configuration
	EnableCORS  *bool    // Enable CORS
	CORSOrigins []string // Allowed origins
	CORSMethods []string // Allowed methods
	CORSHeaders []string // Allowed headers

	// Rate limiting
	EnableRateLimit *bool // Enable rate limiting
	RateLimit       *int  // Requests per minute
	BurstLimit      *int  // Burst limit

	// Tags
	Tags *map[string]*string
}

type DynamORMCache struct {
	constructs.Construct

	// The DynamORM table being cached
	Table *DynamORMTable

	// MemoryDB cluster (if using MemoryDB)
	MemoryDBCluster awsmemorydb.CfnCluster

	// CloudWatch metrics
	Metrics map[string]awscloudwatch.Metric

	// IAM role for cache access
	CacheAccessRole awsiam.Role
	// contains filtered or unexported fields
}

type DynamORMCacheProps struct {
	// Required: The DynamORM table to cache
	DynamORMTable *DynamORMTable

	// Caching strategy
	CacheStrategy CacheStrategy

	// Cache invalidation strategy
	InvalidationStrategy CacheInvalidationStrategy

	// In-memory cache configuration
	InMemoryConfig *InMemoryCacheConfig

	// Redis configuration (for external Redis)
	RedisConfig *RedisCacheConfig

	// MemoryDB configuration (for AWS MemoryDB)
	MemoryDBConfig *MemoryDBCacheConfig

	// Cache behavior settings
	DefaultTTL        awscdk.Duration // Default TTL for cached items
	MaxCacheSize      *int            // Maximum cache size (in-memory only)
	EnableMetrics     *bool           // Enable cache metrics
	EnableCompression *bool           // Enable cache value compression

	// Multi-tenant settings
	EnableTenantIsolation *bool   // Enable tenant-specific caching
	TenantAttribute       *string // Tenant attribute name

	// Performance settings
	PrefetchPatterns []string // Patterns to prefetch
	WarmupQueries    []string // Queries to run on startup

	// Monitoring
	EnableDetailedMetrics *bool // Enable detailed cache metrics
	AlertThresholds       *CacheAlertThresholds
}

type DynamORMEventStore struct {
	constructs.Construct

	// Event table for storing events
	EventTable *DynamORMTable

	// Snapshot table for storing snapshots
	SnapshotTable *DynamORMTable

	// S3 bucket for archival (if enabled)
	ArchivalBucket awss3.IBucket

	// CloudWatch metrics
	Metrics map[string]awscloudwatch.Metric

	// IAM roles for different access patterns
	EventReaderRole     awsiam.Role
	EventWriterRole     awsiam.Role
	SnapshotManagerRole awsiam.Role
	// contains filtered or unexported fields
}

type DynamORMEventStoreProps struct {
	// Event store pattern
	Pattern EventStorePattern

	// Table configuration
	EventTableName    *string
	SnapshotTableName *string

	// Multi-tenant configuration
	EnableMultiTenant *bool
	TenantAttribute   *string

	// Event configuration
	EnableEventVersioning  *bool
	EnableEventEncryption  *bool
	EnableEventCompression *bool
	EventTTL               awscdk.Duration // TTL for old events

	// Snapshot configuration
	SnapshotStrategy     SnapshotStrategy
	SnapshotFrequency    *int            // Number of events between snapshots
	SnapshotSizeLimit    *int            // Size limit in KB for snapshots
	SnapshotTimeInterval awscdk.Duration // Time interval for snapshots
	SnapshotRetention    awscdk.Duration // How long to keep snapshots

	// Performance configuration
	EventStreamEnabled    *bool    // Enable DynamoDB streams for events
	SnapshotStreamEnabled *bool    // Enable DynamoDB streams for snapshots
	EnableAutoScaling     *bool    // Enable auto-scaling
	ReadCapacity          *float64 // Read capacity units
	WriteCapacity         *float64 // Write capacity units

	// Archival configuration
	EnableArchival *bool           // Enable event archival to S3
	ArchivalBucket awss3.IBucket   // S3 bucket for archival
	ArchivalAfter  awscdk.Duration // Archive events after this duration

	// Monitoring configuration
	EnableMetrics         *bool // Enable CloudWatch metrics
	EnableDetailedMetrics *bool // Enable detailed monitoring
	AlertThresholds       *EventStoreAlertThresholds

	// Security configuration
	EnableEncryption *bool   // Enable encryption at rest
	KMSKey           *string // KMS key for encryption

	// Query optimization
	EnableGSIs        *bool    // Enable Global Secondary Indexes
	ProjectionQueries []string // Queries for projection views

	// Tags
	Tags *map[string]*string
}

type DynamORMModelSpec struct {
	ModelName    string
	PartitionKey string
	SortKey      string
	GSIs         []GSISpec
	TTLAttribute string
	Attributes   map[string]string
}

type DynamORMStreamProcessor struct {
	constructs.Construct

	// The Lambda function processing DynamoDB stream records
	Function *LiftFunction

	// The DynamORM table
	Table *DynamORMTable

	// Dead letter queue (if enabled)
	DeadLetterQueue awssqs.IQueue

	// Event source mapping
	EventSource awslambdaeventsources.DynamoEventSource

	// SNS topic for alerts
	AlertTopic awssns.ITopic
	// contains filtered or unexported fields
}

type DynamORMStreamProcessorProps struct {
	// Lambda function properties
	FunctionProps awslambda.FunctionProps

	// DynamORMTable to attach stream processor to (required)
	DynamORMTable *DynamORMTable

	// Dead letter queue properties (optional)
	DeadLetterQueueProps *awssqs.QueueProps

	// Enable dead letter queue (default: true)
	EnableDeadLetterQueue *bool

	// DynamoDB Streams event source configuration
	EventSourceProps *awslambdaeventsources.DynamoEventSourceProps

	// Additional DynamoDB stream processor settings
	BatchSize               *float64                   // Default: 10
	MaxBatchingWindow       awscdk.Duration            // Default: 5 seconds
	StartingPosition        awslambda.StartingPosition // Default: LATEST
	MaxRecordAge            awscdk.Duration            // Default: 24 hours
	BisectBatchOnError      *bool                      // Default: false
	RetryAttempts           *float64                   // Default: 10000
	ReportBatchItemFailures *bool                      // Default: true
	TumblingWindow          awscdk.Duration            // For tumbling window processing
	ParallelizationFactor   *float64                   // Default: 1

	// DynamORM-specific settings
	EnableTracing     *bool
	EnableMultiTenant *bool
	EnableMonitoring  *bool
	TenantAttribute   *string // Default: "TenantID"

	// Event filtering and routing
	EventFilters   []StreamEventFilter  // Custom event filters
	ProcessingMode StreamProcessingMode // Default: SEQUENTIAL

	// Performance optimization
	EnableMetricsCollection *bool    // Default: true
	CustomMetrics           []string // Custom metrics to track
}

type DynamORMTable struct {
	Table awsdynamodb.Table
	// contains filtered or unexported fields
}

type DynamORMTableProps struct {
	// Required
	PartitionKey *awsdynamodb.Attribute
	SortKey      *awsdynamodb.Attribute // Optional but common

	// Table configuration
	TableName           *string
	BillingMode         awsdynamodb.BillingMode
	PointInTimeRecovery *bool
	Stream              awsdynamodb.StreamViewType
	TimeToLiveAttribute *string
	DeletionProtection  *bool
	RemovalPolicy       awscdk.RemovalPolicy

	// DynamORM specific
	EnableMultiTenant *bool
	TenantAttribute   *string
	EnableVersioning  *bool
	EnableTimestamps  *bool

	// Capacity (for provisioned mode)
	ReadCapacity      *float64
	WriteCapacity     *float64
	EnableAutoScaling *bool

	// Tags
	Tags *map[string]*string
}

type DynamoStreamProcessor struct {
	constructs.Construct

	// The Lambda function processing DynamoDB stream records
	Function *LiftFunction

	// The DynamORM streaming table
	StreamingTable *StreamingTable

	// Dead letter queue (if enabled)
	DeadLetterQueue awssqs.IQueue

	// Event source mapping
	EventSource awslambdaeventsources.DynamoEventSource
}

type DynamoStreamProcessorProps struct {
	// Lambda function properties
	FunctionProps awslambda.FunctionProps

	// DynamORM Streaming table properties (creates new table if not provided)
	StreamingTableProps *StreamingTableProps

	// Dead letter queue properties (optional)
	DeadLetterQueueProps *awssqs.QueueProps

	// Enable dead letter queue (default: true)
	EnableDeadLetterQueue *bool

	// DynamoDB Streams event source configuration
	EventSourceProps *awslambdaeventsources.DynamoEventSourceProps

	// Additional DynamoDB stream processor settings
	BatchSize               *float64                   // Default: 10
	MaxBatchingWindow       awscdk.Duration            // Default: 5 seconds
	StartingPosition        awslambda.StartingPosition // Default: LATEST
	MaxRecordAge            awscdk.Duration            // Default: 24 hours
	BisectBatchOnError      *bool                      // Default: false
	RetryAttempts           *float64                   // Default: 10000
	ReportBatchItemFailures *bool                      // Default: true
	TumblingWindow          awscdk.Duration            // For tumbling window processing
	ParallelizationFactor   *float64                   // Default: 1

	// Lift-specific settings
	EnableTracing     *bool
	EnableMultiTenant *bool
	EnableMonitoring  *bool
}

type EnhancedMonitoring struct {
	constructs.Construct
	Metrics       map[string]awscloudwatch.IMetric
	Alarms        map[string]awscloudwatch.IAlarm
	Dashboard     awscloudwatch.Dashboard
	LogGroup      awslogs.LogGroup
	MetricFilters map[string]awslogs.MetricFilter
}

type EnhancedMonitoringProps struct {
	// Resource to monitor
	Resource MonitorableResource
	// Custom namespace for metrics
	Namespace *string
	// Alert configuration
	AlertTopic awssns.ITopic
	// Dashboard configuration
	DashboardName *string
	// Metric configuration
	MetricConfig *MetricConfiguration
	// Alarm thresholds
	AlarmThresholds *AlarmThresholds
	// Enable real-time streaming
	EnableRealTimeStreaming *bool
	// Environment tag
	Environment *string
}

type EnhancedSecurity struct {
	constructs.Construct
	SecurityGroup    awsec2.SecurityGroup
	WAF              awswafv2.CfnWebACL
	Secrets          map[string]awssecretsmanager.Secret
	VPCFlowLogsGroup awslogs.LogGroup
	SecurityMetrics  map[string]awscloudwatch.IMetric
	VPCEndpoints     map[string]awsec2.InterfaceVpcEndpoint
}

type EnhancedSecurityProps struct {
	// VPC configuration
	Vpc awsec2.IVpc
	// Allowed ingress rules
	IngressRules []SecurityRule
	// Allowed egress rules
	EgressRules []SecurityRule
	// WAF configuration
	EnableWAF *bool
	WAFConfig *WAFRuleConfig
	// Secrets to create
	Secrets []SecretConfig
	// Enable VPC Flow Logs
	EnableVPCFlowLogs *bool
	// Enable GuardDuty integration
	EnableGuardDuty *bool
	// Enable Security Hub integration
	EnableSecurityHub *bool
	// Enable Config rules
	EnableConfigRules *bool
	// Environment tag
	Environment *string
	// Application name
	ApplicationName *string
}

type EventBridgeHandler struct {
	constructs.Construct

	// The Lambda function handling events
	Function *LiftFunction

	// The EventBridge rule
	Rule awsevents.Rule

	// The event bus (default or custom)
	EventBus awsevents.IEventBus

	// Dead letter queue (if enabled)
	DeadLetterQueue awssqs.IQueue

	// Lambda target
	Target awseventstargets.LambdaFunction
}

type EventBridgeHandlerProps struct {
	// Lambda function properties
	FunctionProps awslambda.FunctionProps

	// Event rule properties (optional - creates new rule if not provided)
	RuleProps *awsevents.RuleProps

	// Existing rule to use (optional - creates new if not provided)
	ExistingRule awsevents.Rule

	// Existing event bus to use (optional - uses default if not provided)
	ExistingEventBus awsevents.IEventBus

	// Event bus properties for creating a custom event bus
	EventBusProps *awsevents.EventBusProps

	// Event pattern for filtering events
	EventPattern *awsevents.EventPattern

	// Schedule expression for scheduled events (conflicts with EventPattern)
	ScheduleExpression *string

	// Lambda target properties
	TargetProps *awseventstargets.LambdaFunctionProps

	// Dead letter queue properties (optional)
	DeadLetterQueueProps *awssqs.QueueProps

	// Enable dead letter queue (default: true)
	EnableDeadLetterQueue *bool

	// Maximum event age in seconds (default: 3600)
	MaxEventAge awscdk.Duration

	// Retry attempts for failed invocations (default: 3)
	RetryAttempts *float64

	// Enable input transformation
	InputTransformation *awsevents.RuleTargetInput

	// Lift-specific settings
	EnableTracing     *bool
	EnableMultiTenant *bool
	EnableMonitoring  *bool

	// Cross-account event bus support
	CrossAccountEventBusArn *string
}

type EventRoutingTable struct {
	*DynamORMTable
}

type EventRoutingTableProps struct {
	DynamORMTableProps
	// Enable source index for querying by event source
	EnableSourceIndex *bool
	// Enable status index for querying by processing status
	EnableStatusIndex *bool
	// Enable date index for time-based queries
	EnableDateIndex *bool
}

type EventStoreAlertThresholds struct {
	HighEventRate        *float64 // Events per second threshold
	HighErrorRate        *float64 // Error rate threshold
	HighLatency          *float64 // Latency threshold (ms)
	LowSnapshotFrequency *float64 // Minimum snapshot frequency
	HighStorageUsage     *float64 // Storage usage threshold (GB)
}

type EventStorePattern string

type GSIProps struct {
	// Index name
	IndexName *string
	// Partition key attribute definition
	PartitionKey *awsdynamodb.Attribute
	// Sort key attribute definition (optional)
	SortKey *awsdynamodb.Attribute
	// Projection type (defaults to ALL)
	ProjectionType awsdynamodb.ProjectionType
	// For composite keys
	CompositeFields []string // For dynamorm composite key support
}

type GSISpec struct {
	IndexName    string
	PartitionKey string
	SortKey      string
}

type IdempotencyTableProps struct {
	DynamORMTableProps
}

type IdempotentFunction struct {
	constructs.Construct
	Function         *LiftFunction
	IdempotencyTable *DynamORMTable
}

type IdempotentFunctionProps struct {
	LiftFunctionProps
	// How to extract the idempotency key
	KeyExtractor IdempotentKeyExtractor
	// Field name for key extraction (e.g., header name, body field, path param)
	KeyField *string
	// TTL for idempotency records in seconds (default 24 hours)
	TTLSeconds *float64
	// DynamoDB table name for idempotency tracking (optional - will create if not provided)
	TableName *string
	// Enable response caching
	EnableResponseCaching *bool
	// Maximum response size to cache in KB (default 400KB)
	MaxResponseSizeKB *float64
}

type IdempotentKeyExtractor string

type InMemoryCacheConfig struct {
	MaxSize          *int            // Maximum number of items
	TTL              awscdk.Duration // Time to live
	EvictionPolicy   *string         // LRU, LFU, FIFO
	ConcurrencyLevel *int            // Concurrency level for map
	EnableStatistics *bool           // Enable cache statistics
}

type KinesisProcessor struct {
	constructs.Construct
	Stream   awskinesis.IStream
	Function LiftFunction
	DLQ      awssqs.IQueue
	Consumer awskinesis.IStreamConsumer
}

type KinesisProcessorProps struct {
	// The Lambda function configuration
	FunctionProps *LiftFunctionProps `field:"required"`

	// Optional: Stream configuration
	StreamProps *awskinesis.StreamProps `field:"optional"`

	// Optional: Use an existing stream instead of creating a new one
	ExistingStream awskinesis.IStream `field:"optional"`

	// Optional: Event source configuration
	EventSourceProps *awslambdaeventsources.KinesisEventSourceProps `field:"optional"`

	// Optional: Enable dead letter queue for failed records
	EnableDLQ *bool `field:"optional"`

	// Optional: DLQ configuration
	DLQProps *awssqs.QueueProps `field:"optional"`

	// Optional: Stream mode (provisioned or on-demand)
	StreamMode *awskinesis.StreamMode `field:"optional"`

	// Optional: Number of shards (for provisioned mode)
	ShardCount *float64 `field:"optional"`

	// Optional: Data retention period in hours (24-8760 hours)
	RetentionPeriodHours *float64 `field:"optional"`

	// Optional: Enable encryption
	Encryption *awskinesis.StreamEncryption `field:"optional"`

	// Optional: Enable enhanced fan-out
	EnableEnhancedFanOut *bool `field:"optional"`

	// Optional: Consumer name for enhanced fan-out
	ConsumerName *string `field:"optional"`

	// Optional: Batch size for processing (1-10000)
	BatchSize *float64 `field:"optional"`

	// Optional: Maximum batching window in seconds
	MaxBatchingWindowSeconds *float64 `field:"optional"`

	// Optional: Parallelization factor (1-10)
	ParallelizationFactor *float64 `field:"optional"`

	// Optional: Starting position
	StartingPosition *awslambda.StartingPosition `field:"optional"`

	// Optional: Maximum record age in seconds
	MaxRecordAgeSeconds *float64 `field:"optional"`

	// Optional: Bisect batch on function error
	BisectBatchOnError *bool `field:"optional"`

	// Optional: Maximum retry attempts
	RetryAttempts *float64 `field:"optional"`

	// Optional: Tumbling window in seconds
	TumblingWindowSeconds *float64 `field:"optional"`

	// Optional: Report batch item failures
	ReportBatchItemFailures *bool `field:"optional"`
}

type LiftAPI struct {
	constructs.Construct
	HttpAPI  awsapigatewayv2.HttpApi
	Stage    awsapigatewayv2.IHttpStage
	LogGroup awslogs.ILogGroup
}

type LiftAPIProps struct {
	// Name of the API
	Name *string
	// Description of the API
	Description *string
	// Enable CORS
	EnableCORS *bool
	// Custom domain name
	DomainName *string
	// Certificate ARN for custom domain
	CertificateArn *string
	// Enable access logging
	EnableAccessLogging *bool
	// CloudWatch log group for access logs
	AccessLogGroup awslogs.ILogGroup
	// Throttle settings
	ThrottleRateLimit  *float64
	ThrottleBurstLimit *float64
	// Stage name (defaults to $default)
	StageName *string
	// Enable detailed CloudWatch metrics
	EnableDetailedMetrics *bool
	// API Key configuration
	RequireApiKey *bool
	// Request/Response validation models
	RequestValidators map[string]*RequestValidator
	// Default authorizer for all routes
	DefaultAuthorizer awsapigatewayv2.IHttpRouteAuthorizer
}

type LiftFunction struct {
	constructs.Construct
	Function        awslambda.Function
	LogGroup        awslogs.LogGroup
	DeadLetterQueue awssqs.IQueue
}

type LiftFunctionProps struct {
	awslambda.FunctionProps
	// EnableTracing enables X-Ray tracing for the function
	EnableTracing *bool
	// EnableMetrics enables CloudWatch metrics
	EnableMetrics *bool
	// EnableMultiTenant enables multi-tenant support
	EnableMultiTenant *bool
	// EnableDeadLetterQueue creates a DLQ for failed invocations
	EnableDeadLetterQueue *bool
	// DeadLetterQueue to use (optional - will create if not provided)
	DeadLetterQueue awssqs.IQueue
	// DeadLetterQueueMaxReceiveCount before sending to DLQ (default: 3)
	DeadLetterQueueMaxReceiveCount *float64
	// LogRetentionDays for CloudWatch Logs (default: 30)
	LogRetentionDays *float64
	// ReservedConcurrentExecutions to limit concurrent executions
	ReservedConcurrentExecutions *float64
	// EnableDynamORM configures DynamORM environment variables
	EnableDynamORM *bool
	// DynamORM table name (optional - for when using DynamORM)
	DynamORMTableName *string
	// DynamORM debug mode
	DynamORMDebug *bool
}

type LiftTable struct {
	constructs.Construct
	Table awsdynamodb.Table
}

type LiftTableProps struct {
	// Table name
	TableName *string
	// Enable multi-tenant partitioning
	EnableMultiTenant *bool
	// Enable point-in-time recovery
	EnablePointInTimeRecovery *bool
	// Enable DynamoDB Streams
	EnableStreams *bool
	// Stream view type
	StreamViewType awsdynamodb.StreamViewType
	// Time to live attribute name
	TimeToLiveAttribute *string
	// Enable auto-scaling
	EnableAutoScaling *bool
	// Read capacity (for provisioned mode)
	ReadCapacity *float64
	// Write capacity (for provisioned mode)
	WriteCapacity *float64
}

type MemoryDBCacheConfig struct {
	ClusterName      *string    // MemoryDB cluster name
	NodeType         *string    // Node type (e.g., db.t4g.small)
	NumShards        *int       // Number of shards
	ReplicasPerShard *int       // Replicas per shard
	ParameterGroup   *string    // Parameter group
	SecurityGroupIds *[]*string // Security group IDs
	SubnetGroupName  *string    // Subnet group name
}

type MetricConfiguration struct {
	// Enable detailed metrics
	DetailedMetrics *bool
	// Custom dimensions
	Dimensions *map[string]*string
	// Metric resolution (1 or 60 seconds)
	Resolution *float64
	// Percentiles to track
	Percentiles *[]*float64
	// Enable custom business metrics
	EnableBusinessMetrics *bool
}

type MonitorableResource interface {
	// GetResourceName returns the name of the resource
	GetResourceName() *string
}

type MonitoredFunction struct {
	constructs.Construct
	Function  *LiftFunction
	LogGroup  awslogs.LogGroup
	Dashboard awscloudwatch.Dashboard
	Alarms    map[string]awscloudwatch.Alarm
}

type MonitoredFunctionProps struct {
	LiftFunctionProps
	// CloudWatch Logs retention in days
	LogRetentionDays *float64
	// Enable CloudWatch dashboard
	EnableDashboard *bool
	// Dashboard name (optional - will generate if not provided)
	DashboardName *string
	// Alarm configuration
	AlarmConfig *AlarmConfig
	// Custom metrics namespace
	MetricsNamespace *string
	// Enable enhanced monitoring (Lambda Insights)
	EnableLambdaInsights *bool
	// Log level (ERROR, WARN, INFO, DEBUG)
	LogLevel *string
	// Enable CloudWatch Logs Insights queries
	EnableLogInsightsQueries *bool
}

type MultiTenantAPI struct {
	constructs.Construct
	API            awsapigatewayv2.HttpApi
	Function       *LiftFunction
	TenantTable    awsdynamodb.Table
	RateLimitTable awsdynamodb.Table
	WebACL         awswafv2.CfnWebACL
}

type MultiTenantAPIProps struct {
	// API name
	APIName *string

	// Lambda function code
	Code awslambda.Code

	// Lambda function handler
	Handler *string

	// Lambda function runtime
	Runtime awslambda.Runtime

	// Lambda function memory size
	MemorySize *float64

	// Lambda function timeout
	Timeout awscdk.Duration

	// Cognito user pool for authentication
	UserPool awscognito.IUserPool

	// Optional user pool client
	UserPoolClient awscognito.IUserPoolClient

	// Enable per-tenant rate limiting
	EnableTenantRateLimiting *bool

	// Rate limit per tenant (requests per 5 minutes)
	TenantRateLimit *float64

	// Enable tenant isolation via JWT claims
	EnableJWTTenantIsolation *bool

	// JWT claim for tenant ID
	TenantIDClaim *string

	// Enable header-based tenant isolation
	EnableHeaderTenantIsolation *bool

	// Header name for tenant ID
	TenantIDHeader *string

	// Enable path-based tenant isolation
	EnablePathTenantIsolation *bool

	// Enable WAF protection
	EnableWAF *bool

	// Enable detailed CloudWatch logging
	EnableDetailedLogging *bool

	// Enable request/response logging
	EnableAccessLogging *bool

	// Custom domain configuration
	CustomDomain *CustomDomainConfig

	// CORS configuration
	CorsConfig *CorsConfig

	// Throttling configuration
	ThrottleConfig *ThrottleConfig

	// Environment variables to pass to Lambda
	Environment map[string]*string
}

type RateLimitTableProps struct {
	DynamORMTableProps
}

type RateLimitType string

type RateLimitedFunction struct {
	constructs.Construct
	Function  *LiftFunction
	RateTable *DynamORMTable
	// contains filtered or unexported fields
}

type RateLimitedFunctionProps struct {
	LiftFunctionProps
	// Type of rate limiting (IP, User, or Tenant based)
	RateLimitType RateLimitType
	// Rate limit window in seconds
	WindowSeconds *float64
	// Maximum requests allowed in the window
	Limit *float64
	// DynamoDB table name for rate tracking (optional - will create if not provided)
	TableName *string
	// Enable CloudWatch metrics for rate limiting
	EnableMetrics *bool
}

type RedisCacheConfig struct {
	Host              *string         // Redis host
	Port              *int            // Redis port
	Password          *string         // Redis password
	Database          *int            // Redis database number
	MaxConnections    *int            // Maximum connections
	ConnectionTimeout awscdk.Duration // Connection timeout
	EnableTLS         *bool           // Enable TLS
}

type RequestTrackingTable struct {
	*DynamORMTable
}

type RequestTrackingTableProps struct {
	DynamORMTableProps
	// Enable correlation index for querying by correlation ID
	EnableCorrelationIndex *bool
	// Enable status index for querying by request status
	EnableStatusIndex *bool
	// Enable user index for querying by user ID
	EnableUserIndex *bool
	// Enable timestamp index for time-based queries
	EnableTimestampIndex *bool
}

type RequestValidator struct {
	// Validate request body
	ValidateBody *bool
	// Validate request parameters
	ValidateParameters *bool
	// JSON schema for body validation
	BodySchema interface{}
}

type RouteOptions struct {
	// Authorizer for this route
	Authorizer awsapigatewayv2.IHttpRouteAuthorizer
	// Request validation
	RequestValidator *RequestValidator
	// Route-specific throttling
	ThrottleRateLimit  *float64
	ThrottleBurstLimit *float64
}

type S3EventFilter struct {
	Prefix *string
	Suffix *string
}

type S3Processor struct {
	constructs.Construct

	// The Lambda function processing S3 events
	Function *LiftFunction

	// The S3 bucket
	Bucket awss3.IBucket

	// Dead letter queue (if enabled)
	DeadLetterQueue awssqs.IQueue

	// Event source mapping
	EventSource awslambdaeventsources.S3EventSource

	// Replication bucket (if cross-region replication is enabled)
	ReplicationBucket awss3.IBucket
}

type S3ProcessorProps struct {
	// Lambda function properties
	FunctionProps awslambda.FunctionProps

	// S3 bucket properties (optional - creates new bucket if not provided)
	BucketProps *awss3.BucketProps

	// Existing bucket to use (optional - creates new if not provided)
	ExistingBucket awss3.IBucket

	// S3 event types to process (default: ObjectCreated)
	EventTypes *[]awss3.EventType

	// Key prefix filter for S3 events (optional)
	KeyPrefix *string

	// Key suffix filter for S3 events (optional)
	KeySuffix *string

	// Dead letter queue properties (optional)
	DeadLetterQueueProps *awssqs.QueueProps

	// Enable dead letter queue (default: true)
	EnableDeadLetterQueue *bool

	// S3 event source configuration
	EventSourceProps *awslambdaeventsources.S3EventSourceProps

	// Additional S3 processor settings
	BatchSize         *float64        // Default: 10
	MaxBatchingWindow awscdk.Duration // Default: 5 seconds

	// Multi-region support
	CrossRegionReplication *bool
	ReplicationBucket      awss3.IBucket

	// Lifecycle rules
	EnableLifecycleRules *bool
	LifecycleRules       *[]*awss3.LifecycleRule

	// External bucket support
	ExternalBucket awss3.IBucket

	// Event filtering
	EventFilter *S3EventFilter

	// Access logging
	EnableAccessLogging *bool
	AccessLogsBucket    awss3.IBucket
	AccessLogsPrefix    *string

	// Versioning and backup
	EnableVersioning *bool
	EnableBackup     *bool

	// Lift-specific settings
	EnableTracing     *bool
	EnableMultiTenant *bool
	EnableMonitoring  *bool
}

type SNSProcessor struct {
	constructs.Construct
	Topic    awssns.ITopic
	Function LiftFunction
	DLQ      awssqs.IQueue
}

type SNSProcessorProps struct {
	// The Lambda function configuration
	FunctionProps *LiftFunctionProps `field:"required"`

	// Optional: Topic configuration
	TopicProps *awssns.TopicProps `field:"optional"`

	// Optional: Use an existing topic instead of creating a new one
	ExistingTopic awssns.ITopic `field:"optional"`

	// Optional: SNS subscription configuration
	SubscriptionProps *awslambdaeventsources.SnsEventSourceProps `field:"optional"`

	// Optional: Enable dead letter queue for failed messages
	EnableDLQ *bool `field:"optional"`

	// Optional: DLQ configuration
	DLQProps *awssqs.QueueProps `field:"optional"`

	// Optional: Message filtering policy
	FilterPolicy *map[string]awssns.SubscriptionFilter `field:"optional"`

	// Optional: Enable FIFO topic
	EnableFifo *bool `field:"optional"`

	// Optional: Enable content-based deduplication
	ContentBasedDeduplication *bool `field:"optional"`

	// Optional: Message retention period in seconds (1 hour to 14 days)
	MessageRetentionSeconds *float64 `field:"optional"`

	// Optional: Display name for the topic
	DisplayName *string `field:"optional"`

	// Optional: Subscription protocol (defaults to lambda)
	Protocol *string `field:"optional"`

	// Optional: Raw message delivery
	RawMessageDelivery *bool `field:"optional"`
}

type SQSProcessor struct {
	constructs.Construct

	// The Lambda function processing SQS messages
	Function *LiftFunction

	// The SQS queue
	Queue awssqs.IQueue

	// Dead letter queue (if enabled)
	DeadLetterQueue awssqs.IQueue

	// Event source mapping
	EventSource awslambdaeventsources.SqsEventSource
}

type SQSProcessorProps struct {
	// Lambda function properties
	FunctionProps awslambda.FunctionProps

	// SQS queue properties (optional - creates new queue if not provided)
	QueueProps *awssqs.QueueProps

	// Existing queue to use (optional - creates new if not provided)
	ExistingQueue awssqs.IQueue

	// Dead letter queue properties (optional)
	DeadLetterQueueProps *awssqs.QueueProps

	// Enable dead letter queue (default: true)
	EnableDeadLetterQueue *bool

	// SQS event source configuration
	EventSourceProps *awslambdaeventsources.SqsEventSourceProps

	// Additional SQS processor settings
	BatchSize                       *float64        // Default: 10
	MaxBatchingWindow               awscdk.Duration // Default: 5 seconds
	VisibilityTimeout               awscdk.Duration // Default: 6 times function timeout
	MessageRetentionPeriod          awscdk.Duration // Default: 14 days
	MaxReceiveCount                 *float64        // Default: 3
	EnableContentBasedDeduplication *bool           // For FIFO queues
	FifoQueue                       *bool           // Default: false
	ReceiveMessageWaitTimeSeconds   *float64        // For long polling (0-20)

	// Lift-specific settings
	EnableTracing     *bool
	EnableMultiTenant *bool
	EnableMonitoring  *bool
}

type SecretConfig struct {
	Name             string
	Description      string
	Template         string
	GenerateKey      string
	ExcludeChars     string
	Length           float64
	EnableRotation   bool
	RotationLambda   awslambda.IFunction
	RotationSchedule *awssecretsmanager.RotationScheduleOptions
}

type SecureFunction struct {
	constructs.Construct
	Function      *LiftFunction
	SecurityGroup awsec2.ISecurityGroup
	KmsKey        awskms.IKey
	Vpc           awsec2.IVpc
	VpcEndpoints  map[string]awsec2.InterfaceVpcEndpoint
}

type SecureFunctionProps struct {
	LiftFunctionProps
	// VPC to deploy the function in (optional - will create if not provided)
	Vpc awsec2.IVpc
	// VPC subnets to use (defaults to private subnets)
	VpcSubnets *awsec2.SubnetSelection
	// Security group IDs to attach
	SecurityGroupIds *[]*string
	// Enable KMS encryption for environment variables
	EnableKMSEncryption *bool
	// KMS key for encryption (optional - will create if not provided)
	KmsKey awskms.IKey
	// Secrets to inject from Secrets Manager
	Secrets *map[string]awssecretsmanager.ISecret
	// Enable private endpoints only (no internet access)
	PrivateOnly *bool
	// Additional security policies to attach
	AdditionalPolicies *[]awsiam.PolicyStatement
}

type SecurityRule struct {
	Port        float64
	Protocol    awsec2.Protocol
	Source      awsec2.IPeer
	Description string
	RuleAction  string // "allow" or "deny"
}

type SnapshotStrategy string

type StreamEventFilter struct {
	EventName        *string           // INSERT, MODIFY, REMOVE
	AttributeFilters map[string]string // Attribute filters
	TenantFilter     *string           // Filter by tenant ID
}

type StreamProcessingMode string

type StreamingTable struct {
	*DynamORMTable
}

type StreamingTableProps struct {
	DynamORMTableProps
	// Stream view type (NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES, KEYS_ONLY)
	StreamViewType awsdynamodb.StreamViewType
	// Enable stream encryption (defaults to true)
	EnableStreamEncryption *bool
}

type ThrottleConfig struct {
	RateLimit  float64
	BurstLimit float64
}

type ValidationStrategy string

type WAFCustomRule struct {
	Name        string
	Priority    float64
	Statement   string
	Action      string
	Description string
}

type WAFRuleConfig struct {
	EnableRateLimit      *bool
	RateLimit            *float64
	EnableSQLiProtection *bool
	EnableXSSProtection  *bool
	EnableKnownBadInputs *bool
	CustomRules          *[]WAFCustomRule
	IPWhitelist          *[]*string
	IPBlacklist          *[]*string
	GeoBlocking          *[]string
}

type WebSocketAPI struct {
	constructs.Construct

	// The WebSocket API
	WebSocketApi awsapigatewayv2.WebSocketApi

	// The stage
	Stage awsapigatewayv2.WebSocketStage

	// Lambda functions for different routes
	ConnectFunction    *LiftFunction
	DisconnectFunction *LiftFunction
	DefaultFunction    *LiftFunction

	// Connection management table (DynamORM-based)
	ConnectionTable *ConnectionTable

	// Routes map
	Routes map[string]awsapigatewayv2.WebSocketRoute

	// Access log group
	AccessLogGroup awslogs.ILogGroup
}

type WebSocketAPIProps struct {
	// API name
	ApiName *string
	// API description
	Description *string
	// Route selection expression (default: "$request.body.action")
	RouteSelectionExpression *string

	// Lambda function properties for handlers
	FunctionProps awslambda.FunctionProps

	// Connection management table properties (uses DynamORM)
	ConnectionTableProps *ConnectionTableProps
	// Enable automatic connection management
	EnableConnectionManagement *bool

	// WebSocket route configurations
	Routes []*WebSocketRouteConfig

	// Default route function (for unmatched routes)
	DefaultRouteFunction awslambda.IFunction

	// Connect route function ($connect)
	ConnectRouteFunction awslambda.IFunction

	// Disconnect route function ($disconnect)
	DisconnectRouteFunction awslambda.IFunction

	// Stage configuration
	StageName *string
	// Auto deploy stage
	AutoDeploy *bool

	// Access logging
	EnableAccessLogging *bool
	AccessLogGroup      awslogs.ILogGroup

	// Throttling
	ThrottleRateLimit  *float64
	ThrottleBurstLimit *float64

	// Default authorizer for all routes
	DefaultAuthorizer awsapigatewayv2.IWebSocketRouteAuthorizer

	// Lift-specific settings
	EnableTracing         *bool
	EnableMultiTenant     *bool
	EnableMonitoring      *bool
	EnableDeadLetterQueue *bool
}

type WebSocketRouteConfig struct {
	// Route key (e.g., "$connect", "$disconnect", "$default", "custom")
	RouteKey *string
	// Lambda function for this route
	Function awslambda.IFunction
	// Whether this route requires authorization
	RequireAuthorization *bool
	// Custom authorizer for this route
	Authorizer awsapigatewayv2.IWebSocketRouteAuthorizer
}