@gradientedge/cdk-utils-aws 2.5.0 → 2.7.0

package/dist/src/services/elastic-container-service/types.d.ts

@@ -4,48 +4,77 @@ import { ApplicationLoadBalancedFargateServiceProps } from 'aws-cdk-lib/aws-ecs-
 import { HealthCheck as ElbHealthCheck } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
 import { TagProps } from '../../types/index.js';
 /**
+ * Properties for creating an ECS cluster.
+ * @see {@link ClusterProps}
  */
 /** @category Interface */
 export interface EcsClusterProps extends ClusterProps {
+    /** Optional tags to apply to the ECS cluster */
     tags?: TagProps[];
 }
 /**
+ * Properties for creating an ECS task definition.
+ * @see {@link TaskDefinitionProps}
  */
 /** @category Interface */
 export interface EcsTaskProps extends TaskDefinitionProps {
+    /** Optional AWS log driver configuration for container logging */
     logging?: AwsLogDriverProps;
+    /** Optional tags to apply to the task definition */
     tags?: TagProps[];
 }
+/**
+ * Properties for configuring ECS service auto-scaling.
+ */
 /** @category Interface */
 export interface EcsScalingProps {
+    /** Maximum number of tasks to scale out to */
     maxCapacity?: number;
+    /** Minimum number of tasks to maintain */
     minCapacity?: number;
+    /** Target CPU utilization percentage for scaling */
     scaleOnCpuUtilization?: number;
+    /** Target memory utilization percentage for scaling */
     scaleOnMemoryUtilization?: number;
+    /** Target number of requests per target for scaling */
     scaleOnRequestsPerTarget?: number;
+    /** Schedule-based scaling configuration */
     scaleOnSchedule?: ScalingSchedule;
 }
 /**
+ * Health check configuration for ELB-based health checks with interval and timeout in seconds.
+ * @see {@link ElbHealthCheck}
  */
 /** @category Interface */
 export interface HealthCheck extends ElbHealthCheck {
+    /** Health check interval in seconds */
     intervalInSecs: number;
+    /** Health check timeout in seconds */
     timeoutInSecs: number;
 }
 /**
- *
+ * Health check configuration for Application Load Balanced Fargate services with interval and timeout in seconds.
+ * @see {@link FargateHealthCheck}
  */
 /** @category Interface */
 export interface EcsApplicationLoadBalancedFargateServiceHealthCheck extends FargateHealthCheck {
+    /** Health check interval in seconds */
     intervalInSecs: number;
+    /** Health check timeout in seconds */
     timeoutInSecs: number;
 }
 /**
+ * Properties for creating an Application Load Balanced Fargate service.
+ * @see {@link ApplicationLoadBalancedFargateServiceProps}
  */
 /** @category Interface */
 export interface EcsApplicationLoadBalancedFargateServiceProps extends ApplicationLoadBalancedFargateServiceProps {
+    /** Optional health check configuration for the Fargate service */
     healthCheck?: EcsApplicationLoadBalancedFargateServiceHealthCheck;
+    /** Optional AWS log driver configuration for container logging */
     logging?: AwsLogDriverProps;
+    /** Optional mount points for container volumes */
     mountPoints?: MountPoint[];
+    /** Optional auto-scaling configuration for the service */
     siteScaling?: EcsScalingProps;
 }

package/dist/src/services/elastic-file-system/types.d.ts

@@ -1,16 +1,25 @@
 import { AuthorizationConfig } from 'aws-cdk-lib/aws-ecs';
 import { AccessPointOptions, FileSystemProps } from 'aws-cdk-lib/aws-efs';
 /**
+ * Properties for creating an EFS file system.
+ * @see {@link FileSystemProps}
  */
 /** @category Interface */
 export interface EfsFileSystemProps extends FileSystemProps {
+    /** Optional ECS authorization configuration for mounting the file system */
     authorizationConfig?: AuthorizationConfig;
+    /** When true, appends a timestamp to the logical ID to force replacement on each deployment */
     provisionNewOnDeployment?: boolean;
+    /** Optional root directory path for the file system mount */
     rootDirectory?: string;
+    /** Optional transit encryption mode for data in transit */
     transitEncryption?: string;
+    /** Optional port number for transit encryption */
     transitEncryptionPort?: number;
 }
 /**
+ * Options for creating an EFS access point.
+ * @see {@link AccessPointOptions}
  */
 /** @category Interface */
 export interface EfsAccessPointOptions extends AccessPointOptions {

package/dist/src/services/elastic-kubernetes-service/main.d.ts

@@ -25,9 +25,9 @@ export declare class EksManager {
      * @summary Method to create an eks deployment
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param image
-     * @param vpc
+     * @param props the EKS cluster properties including application capacity and port
+     * @param image the Docker image asset to deploy in the cluster
+     * @param vpc the VPC in which the EKS cluster will be created
      */
     createEksDeployment(id: string, scope: CommonConstruct, props: EksClusterProps, image: DockerImageAsset, vpc: IVpc): Cluster;
 }

package/dist/src/services/elastic-kubernetes-service/main.js

@@ -23,9 +23,9 @@ export class EksManager {
      * @summary Method to create an eks deployment
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param image
-     * @param vpc
+     * @param props the EKS cluster properties including application capacity and port
+     * @param image the Docker image asset to deploy in the cluster
+     * @param vpc the VPC in which the EKS cluster will be created
      */
     createEksDeployment(id, scope, props, image, vpc) {
         if (!props)
@@ -33,6 +33,7 @@ export class EksManager {
         if (!props.clusterName)
             throw new Error(`EksCluster clusterName undefined for ${id}`);
         const appLabel = { app: `${id}`.toLowerCase() };
+        /* Define the Kubernetes Deployment manifest for the application */
         const deployment = {
             apiVersion: 'apps/v1',
             kind: 'Deployment',
@@ -53,6 +54,7 @@ export class EksManager {
                 },
             },
         };
+        /* Define the Kubernetes Service manifest with a LoadBalancer to expose the application */
         const service = {
             apiVersion: 'v1',
             kind: 'Service',
@@ -70,6 +72,7 @@ export class EksManager {
                 type: 'LoadBalancer',
             },
         };
+        /* Create the EKS cluster with default capacity using T3 Large instances */
         const cluster = new Cluster(scope, `${id}Cluster`, {
             clusterName: scope.resourceNameFormatter.format(props.clusterName, scope.props.resourceNameOptions?.eks),
             defaultCapacity: props.appCapacity,
@@ -78,6 +81,7 @@ export class EksManager {
             version: KubernetesVersion.V1_27,
             vpc,
         });
+        /* Apply both the Service and Deployment manifests to the cluster */
         cluster.addManifest(`${id}Pod`, service, deployment);
         createCfnOutput(`${id}-clusterArn`, scope, cluster.clusterArn);
         createCfnOutput(`${id}-clusterEndpoint`, scope, cluster.clusterEndpoint);

package/dist/src/services/elastic-kubernetes-service/types.d.ts

@@ -1,8 +1,12 @@
 import { ClusterProps } from 'aws-cdk-lib/aws-eks';
 /**
+ * Properties for creating an EKS cluster with application deployment.
+ * @see {@link ClusterProps}
  */
 /** @category Interface */
 export interface EksClusterProps extends ClusterProps {
+    /** The number of default capacity instances to provision in the cluster */
     appCapacity: number;
+    /** The container port the application listens on */
     appContainerPort: number;
 }

package/dist/src/services/elasticache/main.d.ts

@@ -20,29 +20,29 @@ import { ElastiCacheProps, ReplicatedElastiCacheProps } from './types.js';
  */
 export declare class ElastiCacheManager {
     /**
-     * @summary Method to create an elasticache resource
+     * @summary Method to create an ElastiCache subnet group
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param subnetIds
+     * @param scope scope in which this resource is defined
+     * @param subnetIds the list of subnet IDs to include in the subnet group
      */
     createElastiCacheSubnetGroup(id: string, scope: CommonConstruct, subnetIds: string[]): CfnSubnetGroup;
     /**
-     * @summary Method to create an elasticache resource
+     * @summary Method to create an ElastiCache cache cluster
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param props
-     * @param subnetIds
-     * @param securityGroupIds
-     * @param logDeliveryConfigurations
+     * @param scope scope in which this resource is defined
+     * @param props the ElastiCache cluster properties
+     * @param subnetIds the list of subnet IDs for the cache subnet group
+     * @param securityGroupIds the list of VPC security group IDs to associate with the cluster
+     * @param logDeliveryConfigurations optional log delivery configuration for the cluster
      */
     createElastiCache(id: string, scope: CommonConstruct, props: ElastiCacheProps, subnetIds: string[], securityGroupIds: string[], logDeliveryConfigurations?: any): CfnCacheCluster;
     /**
-     * @summary Method to create an replicated elasticache resource
+     * @summary Method to create a replicated ElastiCache replication group
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param props
-     * @param subnetIds
-     * @param securityGroupIds
+     * @param scope scope in which this resource is defined
+     * @param props the replicated ElastiCache properties
+     * @param subnetIds the list of subnet IDs for the cache subnet group
+     * @param securityGroupIds the list of VPC security group IDs to associate with the replication group
      */
     createReplicatedElastiCache(id: string, scope: CommonConstruct, props: ReplicatedElastiCacheProps, subnetIds: string[], securityGroupIds: string[]): CfnReplicationGroup;
 }

package/dist/src/services/elasticache/main.js

@@ -21,10 +21,10 @@ import { createCfnOutput } from '../../utils/index.js';
  */
 export class ElastiCacheManager {
     /**
-     * @summary Method to create an elasticache resource
+     * @summary Method to create an ElastiCache subnet group
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param subnetIds
+     * @param scope scope in which this resource is defined
+     * @param subnetIds the list of subnet IDs to include in the subnet group
      */
     createElastiCacheSubnetGroup(id, scope, subnetIds) {
         return new CfnSubnetGroup(scope, `${id}`, {
@@ -34,19 +34,20 @@ export class ElastiCacheManager {
         });
     }
     /**
-     * @summary Method to create an elasticache resource
+     * @summary Method to create an ElastiCache cache cluster
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param props
-     * @param subnetIds
-     * @param securityGroupIds
-     * @param logDeliveryConfigurations
+     * @param scope scope in which this resource is defined
+     * @param props the ElastiCache cluster properties
+     * @param subnetIds the list of subnet IDs for the cache subnet group
+     * @param securityGroupIds the list of VPC security group IDs to associate with the cluster
+     * @param logDeliveryConfigurations optional log delivery configuration for the cluster
      */
     createElastiCache(id, scope, props, subnetIds, securityGroupIds, logDeliveryConfigurations) {
         if (!props)
             throw new Error(`ElastiCache props undefined for ${id}`);
         if (!props.clusterName)
             throw new Error(`ElastiCache clusterName undefined for ${id}`);
+        /* Create a dedicated subnet group before provisioning the cache cluster */
         const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds);
         const elasticacheCluster = new CfnCacheCluster(scope, `${id}`, {
             ...props,
@@ -55,6 +56,7 @@ export class ElastiCacheManager {
             logDeliveryConfigurations,
             vpcSecurityGroupIds: securityGroupIds,
         });
+        /* Ensure the subnet group is created before the cache cluster */
         elasticacheCluster.addDependency(subnetGroup);
         if (props.tags && !_.isEmpty(props.tags)) {
             _.forEach(props.tags, tag => {
@@ -67,16 +69,17 @@ export class ElastiCacheManager {
         return elasticacheCluster;
     }
     /**
-     * @summary Method to create an replicated elasticache resource
+     * @summary Method to create a replicated ElastiCache replication group
      * @param id scoped id of the resource
-     * @param scope scope in which scope resource is defined
-     * @param props
-     * @param subnetIds
-     * @param securityGroupIds
+     * @param scope scope in which this resource is defined
+     * @param props the replicated ElastiCache properties
+     * @param subnetIds the list of subnet IDs for the cache subnet group
+     * @param securityGroupIds the list of VPC security group IDs to associate with the replication group
      */
     createReplicatedElastiCache(id, scope, props, subnetIds, securityGroupIds) {
         if (!props)
             throw new Error(`ElastiCache props undefined for ${id}`);
+        /* Create a dedicated subnet group before provisioning the replication group */
         const subnetGroup = this.createElastiCacheSubnetGroup(`${id}-subnetGroup`, scope, subnetIds);
         const elasticacheCluster = new CfnReplicationGroup(scope, `${id}`, {
             ...props,
@@ -85,6 +88,7 @@ export class ElastiCacheManager {
             replicationGroupId: `${id}-${scope.props.stage}`,
             securityGroupIds,
         });
+        /* Ensure the subnet group is created before the replication group */
         elasticacheCluster.addDependency(subnetGroup);
         return elasticacheCluster;
     }

package/dist/src/services/elasticache/types.d.ts

@@ -1,10 +1,14 @@
 import { CfnCacheClusterProps, CfnReplicationGroupProps } from 'aws-cdk-lib/aws-elasticache';
 /**
+ * Properties for creating an ElastiCache cache cluster.
+ * @see {@link CfnCacheClusterProps}
  */
 /** @category Interface */
 export interface ElastiCacheProps extends CfnCacheClusterProps {
 }
 /**
+ * Properties for creating an ElastiCache replication group.
+ * @see {@link CfnReplicationGroupProps}
  */
 /** @category Interface */
 export interface ReplicatedElastiCacheProps extends CfnReplicationGroupProps {

package/dist/src/services/eventbridge/main.d.ts

@@ -45,23 +45,23 @@ export declare class EventManager {
      * @summary Method to create an eventbridge rule with lambda target
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param lambdaFunction
-     * @param eventBusName
-     * @param eventPattern
-     * @param scheduleExpression
+     * @param props the CfnRule properties for the event rule
+     * @param lambdaFunction the Lambda function to invoke as the rule target
+     * @param eventBusName optional name of the custom event bus to attach the rule to
+     * @param eventPattern optional event pattern to filter events
+     * @param scheduleExpression optional cron or rate expression for scheduled rules
      */
     createLambdaRule(id: string, scope: CommonConstruct, props: RuleProps, lambdaFunction: IFunction, eventBusName?: string, eventPattern?: any, scheduleExpression?: string): CfnRule;
     /**
      * @summary Method to create an eventbridge rule with fargate task target
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param cluster
-     * @param task
-     * @param subnetIds
-     * @param role
-     * @param eventPattern
+     * @param props the CfnRule properties for the event rule
+     * @param cluster the ECS cluster to run the Fargate task in
+     * @param task the ECS task definition to execute
+     * @param subnetIds the list of subnet IDs for the Fargate task's VPC configuration
+     * @param role the IAM role granting EventBridge permission to run the ECS task
+     * @param eventPattern optional event pattern to filter events
      */
     createFargateTaskRule(id: string, scope: CommonConstruct, props: RuleProps, cluster: ICluster, task: ITaskDefinition, subnetIds: string[], role: Role | CfnRole, eventPattern?: any): CfnRule;
     /**

package/dist/src/services/eventbridge/main.js

@@ -34,6 +34,7 @@ export class EventManager {
             throw new Error(`EventBus props undefined for ${id}`);
         if (!props.eventBusName)
             throw new Error(`EventBus eventBusName undefined for ${id}`);
+        /* Skip name formatting for the 'default' event bus since it is an AWS built-in name */
         let eventBusName = props.eventBusName;
         if (eventBusName !== 'default') {
             eventBusName = scope.resourceNameFormatter.format(props.eventBusName, scope.props.resourceNameOptions?.eventbridgeBus);
@@ -82,11 +83,11 @@ export class EventManager {
      * @summary Method to create an eventbridge rule with lambda target
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param lambdaFunction
-     * @param eventBusName
-     * @param eventPattern
-     * @param scheduleExpression
+     * @param props the CfnRule properties for the event rule
+     * @param lambdaFunction the Lambda function to invoke as the rule target
+     * @param eventBusName optional name of the custom event bus to attach the rule to
+     * @param eventPattern optional event pattern to filter events
+     * @param scheduleExpression optional cron or rate expression for scheduled rules
      */
     createLambdaRule(id, scope, props, lambdaFunction, eventBusName, eventPattern, scheduleExpression) {
         if (!props)
@@ -113,6 +114,7 @@ export class EventManager {
                 Tags.of(eventRule).add(tag.key, tag.value);
             });
         }
+        /* Grant EventBridge permission to invoke the Lambda function */
         new CfnPermission(scope, `${id}LambdaPermission`, {
             action: 'lambda:InvokeFunction',
             functionName: lambdaFunction.functionName,
@@ -127,12 +129,12 @@ export class EventManager {
      * @summary Method to create an eventbridge rule with fargate task target
      * @param id scoped id of the resource
      * @param scope scope in which this resource is defined
-     * @param props
-     * @param cluster
-     * @param task
-     * @param subnetIds
-     * @param role
-     * @param eventPattern
+     * @param props the CfnRule properties for the event rule
+     * @param cluster the ECS cluster to run the Fargate task in
+     * @param task the ECS task definition to execute
+     * @param subnetIds the list of subnet IDs for the Fargate task's VPC configuration
+     * @param role the IAM role granting EventBridge permission to run the ECS task
+     * @param eventPattern optional event pattern to filter events
      */
     createFargateTaskRule(id, scope, props, cluster, task, subnetIds, role, eventPattern) {
         if (!props)
@@ -177,6 +179,7 @@ export class EventManager {
             throw new Error(`Pipe props undefined for ${id}`);
         if (!props.name)
             throw new Error(`Pipe name undefined for ${id}`);
+        /* Create an IAM role granting the pipe access to poll the SQS queue and start the Step Function */
         const pipeRole = scope.iamManager.createRoleForSqsToSfnPipe(`${id}-role`, scope, sourceQueue.queueArn, targetStepFunction.stateMachineArn);
         const pipe = new CfnPipe(scope, `${id}`, {
             ...props,
@@ -184,6 +187,7 @@ export class EventManager {
             roleArn: pipeRole.roleArn,
             source: sourceQueue.queueArn,
             sourceParameters: {
+                /* Apply optional filter criteria to only forward matching SQS messages */
                 filterCriteria: props.pipeFilterPattern
                     ? {
                         filters: [
@@ -223,6 +227,7 @@ export class EventManager {
             throw new Error(`Pipe props undefined for ${id}`);
         if (!props.name)
             throw new Error(`Pipe name undefined for ${id}`);
+        /* Create an IAM role granting the pipe access to poll the SQS queue and invoke the Lambda */
         const pipeRole = scope.iamManager.createRoleForSqsToLambdaPipe(`${id}-role`, scope, sourceQueue.queueArn, targetLambdaFunction.functionArn);
         const pipe = new CfnPipe(scope, `${id}`, {
             ...props,
@@ -230,6 +235,7 @@ export class EventManager {
             roleArn: pipeRole.roleArn,
             source: sourceQueue.queueArn,
             sourceParameters: {
+                /* Apply optional filter criteria to only forward matching SQS messages */
                 filterCriteria: props.pipeFilterPattern
                     ? {
                         filters: [
@@ -266,6 +272,7 @@ export class EventManager {
             throw new Error(`Pipe props undefined for ${id}`);
         if (!props.name)
             throw new Error(`Pipe name undefined for ${id}`);
+        /* Create an IAM role granting the pipe access to read the DynamoDB stream and invoke the Lambda */
         const pipeRole = scope.iamManager.createRoleForDynamoDbToLambdaPipe(`${id}-role`, scope, sourceDynamoDbStreamArn, targetLambdaFunction.functionArn);
         const pipe = new CfnPipe(scope, `${id}`, {
             ...props,
@@ -273,6 +280,7 @@ export class EventManager {
             roleArn: pipeRole.roleArn,
             source: sourceDynamoDbStreamArn,
             sourceParameters: {
+                /* Apply optional filter criteria to only forward matching DynamoDB stream records */
                 filterCriteria: props.pipeFilterPattern
                     ? {
                         filters: [

package/dist/src/services/eventbridge/target.d.ts

@@ -50,9 +50,13 @@ export interface LogGroupNoPolicyProps extends TargetBaseProps {
 export declare class CloudWatchLogGroupNoPolicy implements IRuleTarget {
     private readonly logGroup;
     private readonly props;
+    /**
+     * @param logGroup the CloudWatch log group to use as the event target
+     * @param props optional configuration for the log group target
+     */
     constructor(logGroup: ILogGroup, props?: LogGroupNoPolicyProps);
     /**
-     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     * @summary Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
      */
     bind(): RuleTargetConfig;
 }

package/dist/src/services/eventbridge/target.js

@@ -37,14 +37,19 @@ export class EventTargetManager {
 export class CloudWatchLogGroupNoPolicy {
     logGroup;
     props;
+    /**
+     * @param logGroup the CloudWatch log group to use as the event target
+     * @param props optional configuration for the log group target
+     */
     constructor(logGroup, props = {}) {
         this.logGroup = logGroup;
         this.props = props;
     }
     /**
-     * Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
+     * @summary Returns a RuleTarget that can be used to log an event into a CloudWatch LogGroup
      */
     bind() {
+        /* Resolve the log group's stack to build the ARN in the correct account/region */
         const logGroupStack = Stack.of(this.logGroup);
         return {
             ...bindBaseTargetConfig(this.props),

package/dist/src/services/eventbridge/types.d.ts

@@ -2,48 +2,74 @@ import { CfnRuleProps, EventBusProps as EBProps, RuleProps as EBRuleProps } from
 import { CfnPipeProps } from 'aws-cdk-lib/aws-pipes';
 import { TagProps } from '../../types/index.js';
 /**
+ * Properties for creating an EventBridge Pipe from an SQS queue to a Step Function.
+ * @see {@link CfnPipeProps}
  */
 /** @category Interface */
 export interface SqsToSfnPipeProps extends CfnPipeProps {
+    /** Optional filter pattern to apply to SQS messages before forwarding */
     pipeFilterPattern?: any;
+    /** Optional input template to transform the event before sending to the Step Function */
     sfnInputTemplate?: string;
+    /** The invocation type for the Step Function target (e.g. 'FIRE_AND_FORGET') */
     sfnInvocationType?: string;
+    /** The maximum number of SQS messages to process in a single batch */
     sqsBatchSize?: number;
+    /** The maximum batching window in seconds before sending the batch */
     sqsMaximumBatchingWindowInSeconds?: number;
 }
 /**
+ * Properties for creating an EventBridge Pipe from an SQS queue to a Lambda function.
+ * @see {@link CfnPipeProps}
  */
 /** @category Interface */
 export interface SqsToLambdaPipeProps extends CfnPipeProps {
+    /** Optional filter pattern to apply to SQS messages before forwarding */
     pipeFilterPattern?: any;
+    /** The maximum number of SQS messages to process in a single batch */
     sqsBatchSize?: number;
+    /** Optional input template to transform the event before sending to the Lambda function */
     lambdaInputTemplate?: string;
+    /** The maximum batching window in seconds before sending the batch */
     sqsMaximumBatchingWindowInSeconds?: number;
 }
 /**
+ * Properties for creating an EventBridge rule using the L2 construct.
+ * @see {@link EBRuleProps}
  */
 /** @category Interface */
 export interface EventRuleProps extends EBRuleProps {
+    /** Optional tags to apply to the event rule */
     tags?: TagProps[];
 }
 /**
+ * Properties for creating an EventBridge rule using the L1 CfnRule construct.
+ * @see {@link CfnRuleProps}
  */
 /** @category Interface */
 export interface RuleProps extends CfnRuleProps {
+    /** Optional input to pass to the rule targets */
     input?: string;
+    /** Optional tags to apply to the rule */
     tags?: TagProps[];
 }
 /**
+ * Properties for creating an EventBridge event bus.
+ * @see {@link EBProps}
  */
 /** @category Interface */
 export interface EventBusProps extends EBProps {
 }
 /**
- }
+ * Properties for creating an EventBridge Pipe from a DynamoDB stream to a Lambda function.
+ * @see {@link CfnPipeProps}
  */
 /** @category Interface */
 export interface DynamoDbToLambdaPipeProps extends CfnPipeProps {
+    /** Optional filter pattern to apply to DynamoDB stream records before forwarding */
     pipeFilterPattern?: any;
+    /** The maximum number of DynamoDB stream records to process in a single batch */
     dynamoDbBatchSize?: number;
+    /** The position in the DynamoDB stream to start reading from (e.g. 'LATEST', 'TRIM_HORIZON') */
     dynamoDbStartingPosition: string;
 }

package/dist/src/services/evidently/types.d.ts

@@ -1,25 +1,35 @@
 import { CfnExperimentProps, CfnFeatureProps, CfnLaunchProps, CfnProjectProps, CfnSegmentProps } from 'aws-cdk-lib/aws-evidently';
 /**
+ * Properties for creating an Evidently project.
+ * @see {@link CfnProjectProps}
  */
 /** @category Interface */
 export interface EvidentlyProjectProps extends CfnProjectProps {
 }
 /**
+ * Properties for creating an Evidently feature flag.
+ * @see {@link CfnFeatureProps}
  */
 /** @category Interface */
 export interface EvidentlyFeatureProps extends CfnFeatureProps {
 }
 /**
+ * Properties for creating an Evidently launch (gradual feature rollout).
+ * @see {@link CfnLaunchProps}
  */
 /** @category Interface */
 export interface EvidentlyLaunchProps extends CfnLaunchProps {
 }
 /**
+ * Properties for creating an Evidently experiment (A/B test).
+ * @see {@link CfnExperimentProps}
  */
 /** @category Interface */
 export interface EvidentlyExperimentProps extends CfnExperimentProps {
 }
 /**
+ * Properties for creating an Evidently audience segment.
+ * @see {@link CfnSegmentProps}
  */
 /** @category Interface */
 export interface EvidentlySegmentProps extends CfnSegmentProps {