@intentius/chant-lexicon-aws 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@intentius/chant-lexicon-aws",
-  "version": "0.0.2",
+  "version": "0.0.4",
+  "license": "Apache-2.0",
   "type": "module",
   "files": ["src/", "dist/"],
   "publishConfig": {
@@ -15,9 +16,10 @@
 },
 "scripts": {
   "generate": "bun run src/codegen/generate-cli.ts",
+  "bundle": "bun run src/package-cli.ts",
   "validate": "bun run src/validate-cli.ts",
   "docs": "bun src/codegen/docs-cli.ts",
-  "prepack": "bun run generate && bun run validate"
+  "prepack": "bun run bundle && bun run validate"
 },
 "dependencies": {
   "@intentius/chant": "0.0.1",

package/src/codegen/docs.ts

@@ -115,7 +115,7 @@ export async function generateDocs(options?: { verbose?: boolean }): Promise<voi
 
   const config: DocsConfig = {
     name: "aws",
-    basePath: process.env.DOCS_BASE_PATH ?? "/lexicons/aws/",
+    basePath: process.env.DOCS_BASE_PATH ?? "/chant/lexicons/aws/",
     displayName: "AWS CloudFormation",
     description: "AWS CloudFormation lexicon for chant — resource types, intrinsics, and lint rules",
     distDir,

package/src/generated/index.d.ts

@@ -13592,6 +13592,7 @@ export declare class Function {
     /** The instruction set architecture that the function supports. Enter a string array with one of the valid values (arm64 or x86_64). The default value is ``x86_64``. */
     architectures?: "arm64" | "x86_64"[];
     arn?: string;
+    /** Configuration for the capacity provider that manages compute resources for Lambda functions. */
     capacityProviderConfig?: Function_CapacityProviderConfig;
     /** To enable code signing for this function, specify the ARN of a code-signing configuration. A code-signing configuration includes a set of signing profiles, which define the trusted publishers for this function. */
     codeSigningConfigArn?: string;
@@ -13599,6 +13600,7 @@ export declare class Function {
     deadLetterConfig?: Function_DeadLetterConfig;
     /** A description of the function. */
     description?: string;
+    /** Configuration settings for [durable functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html), including execution timeout and retention period for execution history. */
     durableConfig?: Function_DurableConfig;
     /** Environment variables that are accessible from function code during execution. */
     environment?: Function_Environment;
@@ -13610,6 +13612,7 @@ export declare class Function {
     /** The name of the Lambda function, up to 64 characters in length. If you don't specify a name, CFN generates one.
  If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name. */
     functionName?: string;
+    /** Configuration that defines the scaling behavior for a Lambda Managed Instances function, including the minimum and maximum number of execution environments that can be provisioned. */
     functionScalingConfig?: Function_FunctionScalingConfig;
     /** The name of the method within your code that Lambda calls to run your function. Handler is required if the deployment package is a .zip file archive. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see [Lambda programming model](https://docs.aws.amazon.com/lambda/latest/dg/foundation-progmodel.html). */
     handler?: string;
@@ -13650,6 +13653,7 @@ export declare class Function {
     /** A list of [tags](https://docs.aws.amazon.com/lambda/latest/dg/tagging.html) to apply to the function.
   You must have the ``lambda:TagResource``, ``lambda:UntagResource``, and ``lambda:ListTags`` permissions for your [principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html) to manage the CFN stack. If you don't have these permissions, there might be unexpected behavior with stack-level tags propagating to the resource during resource creation and update. */
     tags?: Function_Tag[];
+    /** The function's tenant isolation configuration settings. Determines whether the Lambda function runs on a shared or dedicated infrastructure per unique tenant. */
     tenancyConfig?: Function_TenancyConfig;
     /** The amount of time (in seconds) that Lambda allows a function to run before stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds. For more information, see [Lambda execution environment](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html). */
     timeout?: number;
@@ -14738,13 +14742,13 @@ export declare class Host {
     /** The ID of the Outpost hardware asset. */
     assetId?: string;
     /** Indicates whether the host accepts any untargeted instance launches that match its instance type configuration, or if it only accepts Host tenancy instance launches that specify its unique host ID. */
-    autoPlacement?: string;
+    autoPlacement?: "off" | "on";
     /** ID of the host created. */
     hostId?: string;
     /** Automatically allocates a new dedicated host and moves your instances on to it if a degradation is detected on your current host. */
-    hostMaintenance?: string;
+    hostMaintenance?: "off" | "on";
     /** Indicates whether to enable or disable host recovery for the Dedicated Host. Host recovery is disabled by default. */
-    hostRecovery?: string;
+    hostRecovery?: "off" | "on";
     /** Specifies the instance family to be supported by the Dedicated Hosts. If you specify an instance family, the Dedicated Hosts support multiple instance types within that instance family. */
     instanceFamily?: string;
     /** Specifies the instance type to be supported by the Dedicated Hosts. If you specify an instance type, the Dedicated Hosts support instances of the specified instance type only. */
@@ -25829,57 +25833,96 @@ export declare class ReplicationConfiguration {
 
 export declare class ReplicationGroup {
   constructor(props: {
+    /** A user-created description for the replication group. */
     replicationGroupDescription: string;
+    /** A flag that enables encryption at rest when set to true.AtRestEncryptionEnabled after the replication group is created. To enable encryption at rest on a replication group you must set AtRestEncryptionEnabled to true when you create the replication group. */
     atRestEncryptionEnabled?: boolean;
+    /** Reserved parameter. The password used to access a password protected server.AuthToken can be specified only on replication groups where TransitEncryptionEnabled is true. For more information. */
     authToken?: string;
+    /** Specifies whether a read-only replica is automatically promoted to read/write primary if the existing primary fails. AutomaticFailoverEnabled must be enabled for Redis (cluster mode enabled) replication groups. */
     automaticFailoverEnabled?: boolean;
+    /** This parameter is currently disabled. */
     autoMinorVersionUpgrade?: boolean;
+    /** The compute and memory capacity of the nodes in the node group (shard). */
     cacheNodeType?: string;
+    /** The name of the parameter group to associate with this replication group. If this argument is omitted, the default cache parameter group for the specified engine is used. */
     cacheParameterGroupName?: string;
+    /** A list of cache security group names to associate with this replication group. */
     cacheSecurityGroupNames?: string[];
+    /** The name of the cache subnet group to be used for the replication group. */
     cacheSubnetGroupName?: string;
+    /** Enabled or Disabled. To modify cluster mode from Disabled to Enabled, you must first set the cluster mode to Compatible. Compatible mode allows your Redis OSS clients to connect using both cluster mode enabled and cluster mode disabled. After you migrate all Redis OSS clients to use cluster mode enabled, you can then complete cluster mode configuration and set the cluster mode to Enabled. For more information, see Modify cluster mode. */
     clusterMode?: string;
-    configurationEndPointAddress?: string;
-    configurationEndPointPort?: string;
+    /** The configuration details of the replication group. */
+    configurationEndPoint?: ReplicationGroup_Endpoint;
+    /** Enables data tiering. Data tiering is only supported for replication groups using the r6gd node type. This parameter must be set to true when using r6gd nodes. */
     dataTieringEnabled?: boolean;
+    /** The name of the cache engine to be used for the clusters in this replication group. */
     engine?: string;
+    /** The version number of the cache engine to be used for the clusters in this replication group. To view the supported cache engine versions, use the DescribeCacheEngineVersions operation. */
     engineVersion?: string;
+    /** The name of the Global datastore */
     globalReplicationGroupId?: string;
+    /** The network type you choose when creating a replication group, either ipv4 | ipv6. IPv6 is supported for workloads using Redis OSS engine version 6.2 onward or Memcached engine version 1.6.6 on all instances built on the Nitro system. */
     ipDiscovery?: string;
+    /** The ID of the KMS key used to encrypt the disk on the cluster. */
     kmsKeyId?: string;
+    /** Specifies the destination, format and type of the logs. */
     logDeliveryConfigurations?: ReplicationGroup_LogDeliveryConfigurationRequest[];
+    /** A flag indicating if you have Multi-AZ enabled to enhance fault tolerance. For more information, see Minimizing Downtime: Multi-AZ. */
     multiAZEnabled?: boolean;
+    /** Must be either ipv4 | ipv6 | dual_stack. IPv6 is supported for workloads using Redis OSS engine version 6.2 onward or Memcached engine version 1.6.6 on all instances built on the Nitro system */
     networkType?: string;
+    /** NodeGroupConfiguration is a property of the AWS::ElastiCache::ReplicationGroup resource that configures an Amazon ElastiCache (ElastiCache) Redis cluster node group. */
     nodeGroupConfiguration?: ReplicationGroup_NodeGroupConfiguration[];
+    /** The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS) topic to which notifications are sent. */
     notificationTopicArn?: string;
+    /** The number of clusters this replication group initially has.This parameter is not used if there is more than one node group (shard). You should use ReplicasPerNodeGroup instead. */
     numCacheClusters?: number;
+    /** An optional parameter that specifies the number of node groups (shards) for this Redis (cluster mode enabled) replication group. For Redis (cluster mode disabled) either omit this parameter or set it to 1. */
     numNodeGroups?: number;
+    /** The port number on which each member of the replication group accepts connections. */
     port?: number;
+    /** A list of EC2 Availability Zones in which the replication group's clusters are created. The order of the Availability Zones in the list is the order in which clusters are allocated. The primary cluster is created in the first AZ in the list. This parameter is not used if there is more than one node group (shard). You should use NodeGroupConfiguration instead. */
     preferredCacheClusterAZs?: string[];
+    /** Specifies the weekly time range during which maintenance on the cluster is performed. It is specified as a range in the format ddd:hh24:mi-ddd:hh24:mi (24H Clock UTC). The minimum maintenance window is a 60 minute period. */
     preferredMaintenanceWindow?: string;
+    /** The identifier of the cluster that serves as the primary for this replication group. This cluster must already exist and have a status of available. */
     primaryClusterId?: string;
-    primaryEndPointAddress?: string;
-    primaryEndPointPort?: string;
-    readEndPointAddresses?: string;
-    readEndPointAddressesList?: string[];
-    readEndPointPorts?: string;
-    readEndPointPortsList?: string[];
-    readerEndPointAddress?: string;
-    readerEndPointPort?: string;
+    /** The primary endpoint configuration */
+    primaryEndPoint?: ReplicationGroup_Endpoint;
+    readEndPoint?: Record<string, unknown>;
+    /** The endpoint of the reader node in the replication group. */
+    readerEndPoint?: ReplicationGroup_Endpoint;
+    /** An optional parameter that specifies the number of replica nodes in each node group (shard). Valid values are 0 to 5. */
     replicasPerNodeGroup?: number;
+    /** The replication group identifier. This parameter is stored as a lowercase string. */
     replicationGroupId?: string;
+    /** One or more Amazon VPC security groups associated with this replication group. */
     securityGroupIds?: string[];
+    /** A list of Amazon Resource Names (ARN) that uniquely identify the Redis RDB snapshot files stored in Amazon S3. */
     snapshotArns?: string[];
+    /** The name of a snapshot from which to restore data into the new replication group. The snapshot status changes to restoring while the new replication group is being created. */
     snapshotName?: string;
+    /** The number of days for which ElastiCache retains automatic snapshots before deleting them. For example, if you set SnapshotRetentionLimit to 5, a snapshot that was taken today is retained for 5 days before being deleted. */
     snapshotRetentionLimit?: number;
+    /** The cluster ID that is used as the daily snapshot source for the replication group. This parameter cannot be set for Redis (cluster mode enabled) replication groups. */
     snapshottingClusterId?: string;
+    /** The daily time range (in UTC) during which ElastiCache begins taking a daily snapshot of your node group (shard). */
     snapshotWindow?: string;
+    /** A list of cost allocation tags to be added to this resource. Tags are comma-separated key,value pairs (e.g. Key=myKey, Value=myKeyValue. You can include multiple tags as shown following: Key=myKey, Value=myKeyValue Key=mySecondKey, Value=mySecondKeyValue. */
     tags?: ReplicationGroup_Tag[];
+    /** A flag that enables in-transit encryption when set to true. */
     transitEncryptionEnabled?: boolean;
+    /** A setting that allows you to migrate your clients to use in-transit encryption, with no downtime. When setting TransitEncryptionEnabled to true, you can set your TransitEncryptionMode to preferred in the same request, to allow both encrypted and unencrypted connections at the same time. Once you migrate all your Redis OSS clients to use encrypted connections you can modify the value to required to allow encrypted connections only. Setting TransitEncryptionMode to required is a two-step process that requires you to first set the TransitEncryptionMode to preferred, after that you can set TransitEncryptionMode to required. This process will not trigger the replacement of the replication group. */
     transitEncryptionMode?: string;
+    /** The ID of user group to associate with the replication group. */
     userGroupIds?: string[];
   });
-  readonly replicationGroupId: string;
+  readonly configurationEndPoint: ReplicationGroup_Endpoint;
+  readonly primaryEndPoint: ReplicationGroup_Endpoint;
+  readonly readEndPoint: Record<string, unknown>;
+  readonly readerEndPoint: ReplicationGroup_Endpoint;
 }
 
 export declare class ReplicationInstance {
@@ -54445,6 +54488,7 @@ export declare class CapacityManagerDataExport_Tag {
 
 export declare class CapacityProviderConfig {
   constructor(props: {
+    /** Configuration for Lambda-managed instances used by the capacity provider. */
     lambdaManagedInstancesCapacityProviderConfig: Function_LambdaManagedInstancesCapacityProviderConfig;
   });
 }
@@ -57161,7 +57205,8 @@ export declare class Code {
     /** The ARN of the KMSlong (KMS) customer managed key that's used to encrypt your function's .zip deployment package. If you don't provide a customer managed key, Lambda uses an [owned key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). */
     sourceKMSKeyArn?: string;
     /** (Node.js and Python) The source code of your Lambda function. If you include your function source inline with this parameter, CFN places it in a file named ``index`` and zips it to create a [deployment package](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html). This zip file cannot exceed 4MB. For the ``Handler`` property, the first part of the handler identifier must be ``index``. For example, ``index.handler``.
-  When you specify source code inline for a Node.js function, the ``index`` file that CFN creates uses the extension ``.js``. This means that LAM treats the file as a CommonJS module. ES modules aren't supported for inline functions.
+  When you specify source code inline for a Node.js function, the ``index`` file that CFN creates uses the extension ``.js``. This means that Node.js treats the file as a CommonJS module.
+ When using Node.js 24 or later, Node.js can automatically detect if a ``.js`` file should be treated as CommonJS or as an ES module. To enable auto-detection, add the ``--experimental-detect-module`` flag to the ``NODE_OPTIONS`` environment variable. For more information, see [Experimental Node.js features](https://docs.aws.amazon.com//lambda/latest/dg/lambda-nodejs.html#nodejs-experimental-features).
    For JSON, you must escape quotes and special characters such as newline (``\n``) with a backslash.
  If you specify a function that interacts with an AWS CloudFormation custom resource, you don't have to write your own functions to send responses to the custom resource that invoked the function. AWS CloudFormation provides a response module ([cfn-response](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-lambda-function-code-cfnresponsemodule.html)) that simplifies sending responses. See [Using Lambda with CloudFormation](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudformation.html) for details. */
     zipFile?: string;
@@ -73116,9 +73161,9 @@ export declare class DTMFSpecification {
 
 export declare class DurableConfig {
   constructor(props: {
-    /** The amount of time (in seconds) that Lambda allows a durable function to run before stopping it. The maximum is one 366-day year or 31,622,400 seconds. */
+    /** The maximum time (in seconds) that a durable execution can run before timing out. This timeout applies to the entire durable execution, not individual function invocations. */
     executionTimeout: number;
-    /** The number of days after a durable execution is closed that Lambda retains its history, from one to 90 days. The default is 14 days. */
+    /** The number of days to retain execution history after a durable execution completes. After this period, execution history is no longer available through the GetDurableExecutionHistory API. */
     retentionPeriodInDays?: number;
   });
 }
@@ -82781,6 +82826,7 @@ export declare class FulfillmentUpdatesSpecification {
 
 export declare class Function_CapacityProviderConfig {
   constructor(props: {
+    /** Configuration for Lambda-managed instances used by the capacity provider. */
     lambdaManagedInstancesCapacityProviderConfig: Function_LambdaManagedInstancesCapacityProviderConfig;
   });
 }
@@ -82798,7 +82844,8 @@ export declare class Function_Code {
     /** The ARN of the KMSlong (KMS) customer managed key that's used to encrypt your function's .zip deployment package. If you don't provide a customer managed key, Lambda uses an [owned key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). */
     sourceKMSKeyArn?: string;
     /** (Node.js and Python) The source code of your Lambda function. If you include your function source inline with this parameter, CFN places it in a file named ``index`` and zips it to create a [deployment package](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html). This zip file cannot exceed 4MB. For the ``Handler`` property, the first part of the handler identifier must be ``index``. For example, ``index.handler``.
-  When you specify source code inline for a Node.js function, the ``index`` file that CFN creates uses the extension ``.js``. This means that LAM treats the file as a CommonJS module. ES modules aren't supported for inline functions.
+  When you specify source code inline for a Node.js function, the ``index`` file that CFN creates uses the extension ``.js``. This means that Node.js treats the file as a CommonJS module.
+ When using Node.js 24 or later, Node.js can automatically detect if a ``.js`` file should be treated as CommonJS or as an ES module. To enable auto-detection, add the ``--experimental-detect-module`` flag to the ``NODE_OPTIONS`` environment variable. For more information, see [Experimental Node.js features](https://docs.aws.amazon.com//lambda/latest/dg/lambda-nodejs.html#nodejs-experimental-features).
    For JSON, you must escape quotes and special characters such as newline (``\n``) with a backslash.
  If you specify a function that interacts with an AWS CloudFormation custom resource, you don't have to write your own functions to send responses to the custom resource that invoked the function. AWS CloudFormation provides a response module ([cfn-response](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-lambda-function-code-cfnresponsemodule.html)) that simplifies sending responses. See [Using Lambda with CloudFormation](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudformation.html) for details. */
     zipFile?: string;
@@ -82814,9 +82861,9 @@ export declare class Function_DeadLetterConfig {
 
 export declare class Function_DurableConfig {
   constructor(props: {
-    /** The amount of time (in seconds) that Lambda allows a durable function to run before stopping it. The maximum is one 366-day year or 31,622,400 seconds. */
+    /** The maximum time (in seconds) that a durable execution can run before timing out. This timeout applies to the entire durable execution, not individual function invocations. */
     executionTimeout: number;
-    /** The number of days after a durable execution is closed that Lambda retains its history, from one to 90 days. The default is 14 days. */
+    /** The number of days to retain execution history after a durable execution completes. After this period, execution history is no longer available through the GetDurableExecutionHistory API. */
     retentionPeriodInDays?: number;
   });
 }
@@ -82871,7 +82918,7 @@ export declare class Function_LambdaManagedInstancesCapacityProviderConfig {
     capacityProviderArn: string;
     /** The amount of memory in GiB allocated per vCPU for execution environments. */
     executionEnvironmentMemoryGiBPerVCpu?: number;
-    /** The maximum number of concurrent execution environments that can run on each compute instance. */
+    /** The maximum number of concurrent executions that can run on each execution environment. */
     perExecutionEnvironmentMaxConcurrency?: number;
   });
 }
@@ -82931,7 +82978,7 @@ export declare class Function_Tag {
 
 export declare class Function_TenancyConfig {
   constructor(props: {
-    /** Determines how your Lambda function isolates execution environments between tenants. */
+    /** Tenant isolation mode allows for invocation to be sent to a corresponding execution environment dedicated to a specific tenant ID. */
     tenantIsolationMode: "PER_TENANT";
   });
 }
@@ -94752,7 +94799,7 @@ export declare class LambdaManagedInstancesCapacityProviderConfig {
     capacityProviderArn: string;
     /** The amount of memory in GiB allocated per vCPU for execution environments. */
     executionEnvironmentMemoryGiBPerVCpu?: number;
-    /** The maximum number of concurrent execution environments that can run on each compute instance. */
+    /** The maximum number of concurrent executions that can run on each execution environment. */
     perExecutionEnvironmentMaxConcurrency?: number;
   });
 }
@@ -108452,10 +108499,15 @@ export declare class Nodegroup_UpdateConfig {
 
 export declare class NodeGroupConfiguration {
   constructor(props: {
+    /** Either the ElastiCache for Redis supplied 4-digit id or a user supplied id for the node group these configuration values apply to. */
     nodeGroupId?: string;
+    /** The Availability Zone where the primary node of this node group (shard) is launched. */
     primaryAvailabilityZone?: string;
+    /** A list of Availability Zones to be used for the read replicas. The number of Availability Zones in this list must match the value of ReplicaCount or ReplicasPerNodeGroup if not specified. */
     replicaAvailabilityZones?: string[];
+    /** The number of read replica nodes in this node group (shard). */
     replicaCount?: number;
+    /** A string of comma-separated values where the first set of values are the slot numbers (zero based), and the second set of values are the keyspaces for each slot. The following example specifies three slots (numbered 0, 1, and 2): 0,1,2,0-4999,5000-9999,10000-16,383. */
     slots?: string;
   });
 }
@@ -129267,6 +129319,7 @@ export declare class ReplicationConfiguration_RepositoryFilter {
 
 export declare class ReplicationGroup_CloudWatchLogsDestinationDetails {
   constructor(props: {
+    /** The name of the CloudWatch Logs log group. */
     logGroup: string;
   });
 }
@@ -129278,8 +129331,18 @@ export declare class ReplicationGroup_DestinationDetails {
   });
 }
 
+export declare class ReplicationGroup_Endpoint {
+  constructor(props: {
+    /** The DNS hostname of the cache node. */
+    address?: string;
+    /** The port number that the cache engine is listening on. */
+    port?: string;
+  });
+}
+
 export declare class ReplicationGroup_KinesisFirehoseDestinationDetails {
   constructor(props: {
+    /** The name of the Kinesis Data Firehose delivery stream. */
     deliveryStream: string;
   });
 }
@@ -129287,25 +129350,35 @@ export declare class ReplicationGroup_KinesisFirehoseDestinationDetails {
 export declare class ReplicationGroup_LogDeliveryConfigurationRequest {
   constructor(props: {
     destinationDetails: ReplicationGroup_DestinationDetails;
+    /** Specify either CloudWatch Logs or Kinesis Data Firehose as the destination type. Valid values are either cloudwatch-logs or kinesis-firehose. */
     destinationType: string;
+    /** Valid values are either json or text. */
     logFormat: string;
+    /** Valid value is either slow-log, which refers to slow-log or engine-log. */
     logType: string;
   });
 }
 
 export declare class ReplicationGroup_NodeGroupConfiguration {
   constructor(props: {
+    /** Either the ElastiCache for Redis supplied 4-digit id or a user supplied id for the node group these configuration values apply to. */
     nodeGroupId?: string;
+    /** The Availability Zone where the primary node of this node group (shard) is launched. */
     primaryAvailabilityZone?: string;
+    /** A list of Availability Zones to be used for the read replicas. The number of Availability Zones in this list must match the value of ReplicaCount or ReplicasPerNodeGroup if not specified. */
     replicaAvailabilityZones?: string[];
+    /** The number of read replica nodes in this node group (shard). */
     replicaCount?: number;
+    /** A string of comma-separated values where the first set of values are the slot numbers (zero based), and the second set of values are the keyspaces for each slot. The following example specifies three slots (numbered 0, 1, and 2): 0,1,2,0-4999,5000-9999,10000-16,383. */
     slots?: string;
   });
 }
 
 export declare class ReplicationGroup_Tag {
   constructor(props: {
+    /** The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. */
     key: string;
+    /** The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. */
     value: string;
   });
 }
@@ -144181,7 +144254,7 @@ export declare class TemporalFilterSettings {
 
 export declare class TenancyConfig {
   constructor(props: {
-    /** Determines how your Lambda function isolates execution environments between tenants. */
+    /** Tenant isolation mode allows for invocation to be sent to a corresponding execution environment dedicated to a specific tenant ID. */
     tenantIsolationMode: "PER_TENANT";
   });
 }

package/src/generated/index.ts

@@ -1087,7 +1087,7 @@ export const RemediationConfiguration = createResource("AWS::Config::Remediation
 export const ReplicaKey = createResource("AWS::KMS::ReplicaKey", "aws", {"arn":"Arn","keyId":"KeyId"});
 export const ReplicationConfig = createResource("AWS::DMS::ReplicationConfig", "aws", {"replicationConfigArn":"ReplicationConfigArn"});
 export const ReplicationConfiguration = createResource("AWS::ECR::ReplicationConfiguration", "aws", {"registryId":"RegistryId"});
-export const ReplicationGroup = createResource("AWS::ElastiCache::ReplicationGroup", "aws", {"replicationGroupId":"ReplicationGroupId"});
+export const ReplicationGroup = createResource("AWS::ElastiCache::ReplicationGroup", "aws", {"configurationEndPoint":"ConfigurationEndPoint","primaryEndPoint":"PrimaryEndPoint","readEndPoint":"ReadEndPoint","readerEndPoint":"ReaderEndPoint"});
 export const ReplicationInstance = createResource("AWS::DMS::ReplicationInstance", "aws", {"replicationInstancePublicIpAddresses":"ReplicationInstancePublicIpAddresses","id":"Id","replicationInstancePrivateIpAddresses":"ReplicationInstancePrivateIpAddresses"});
 export const ReplicationSet = createResource("AWS::SSMIncidents::ReplicationSet", "aws", {"arn":"Arn"});
 export const ReplicationSubnetGroup = createResource("AWS::DMS::ReplicationSubnetGroup", "aws", {"id":"Id"});
@@ -11717,6 +11717,7 @@ export const ReplicationConfiguration_ReplicationRule = createProperty("AWS::ECR
 export const ReplicationConfiguration_RepositoryFilter = createProperty("AWS::ECR::ReplicationConfiguration.RepositoryFilter", "aws");
 export const ReplicationGroup_CloudWatchLogsDestinationDetails = createProperty("AWS::ElastiCache::ReplicationGroup.CloudWatchLogsDestinationDetails", "aws");
 export const ReplicationGroup_DestinationDetails = createProperty("AWS::ElastiCache::ReplicationGroup.DestinationDetails", "aws");
+export const ReplicationGroup_Endpoint = createProperty("AWS::ElastiCache::ReplicationGroup.Endpoint", "aws");
 export const ReplicationGroup_KinesisFirehoseDestinationDetails = createProperty("AWS::ElastiCache::ReplicationGroup.KinesisFirehoseDestinationDetails", "aws");
 export const ReplicationGroup_LogDeliveryConfigurationRequest = createProperty("AWS::ElastiCache::ReplicationGroup.LogDeliveryConfigurationRequest", "aws");
 export const ReplicationGroup_NodeGroupConfiguration = createProperty("AWS::ElastiCache::ReplicationGroup.NodeGroupConfiguration", "aws");

package/src/generated/lexicon-aws.json

@@ -48382,6 +48382,29 @@
     "attrs": {
       "hostId": "HostId"
     },
+    "propertyConstraints": {
+      "AutoPlacement": {
+        "default": "on",
+        "enum": [
+          "on",
+          "off"
+        ]
+      },
+      "HostRecovery": {
+        "default": "off",
+        "enum": [
+          "on",
+          "off"
+        ]
+      },
+      "HostMaintenance": {
+        "default": "off",
+        "enum": [
+          "on",
+          "off"
+        ]
+      }
+    },
     "createOnly": [
       "AvailabilityZone",
       "InstanceType",
@@ -87598,33 +87621,69 @@
     "kind": "resource",
     "lexicon": "aws",
     "attrs": {
-      "replicationGroupId": "ReplicationGroupId"
+      "configurationEndPoint": "ConfigurationEndPoint",
+      "primaryEndPoint": "PrimaryEndPoint",
+      "readEndPoint": "ReadEndPoint",
+      "readerEndPoint": "ReaderEndPoint"
     },
     "propertyConstraints": {
+      "NumNodeGroups": {
+        "default": 1
+      },
+      "AutomaticFailoverEnabled": {
+        "default": false
+      },
       "ReplicasPerNodeGroup": {
         "minimum": 0,
         "maximum": 5
       },
-      "SecurityGroupIds": {
-        "format": "AWS::EC2::SecurityGroup.Ids"
+      "TransitEncryptionEnabled": {
+        "default": false
       },
       "NumCacheClusters": {
         "minimum": 1,
         "maximum": 6
+      },
+      "AtRestEncryptionEnabled": {
+        "default": false
+      },
+      "SecurityGroupIds": {
+        "format": "AWS::EC2::SecurityGroup.Ids"
+      },
+      "SnapshotRetentionLimit": {
+        "default": 0
       }
     },
     "createOnly": [
+      "AtRestEncryptionEnabled",
+      "CacheSubnetGroupName",
+      "DataTieringEnabled",
+      "GlobalReplicationGroupId",
       "KmsKeyId",
+      "NetworkType",
       "Port",
+      "PreferredCacheClusterAZs",
+      "ReplicasPerNodeGroup",
+      "ReplicationGroupId",
       "SnapshotArns",
-      "SnapshotName",
+      "SnapshotName"
+    ],
+    "writeOnly": [
+      "AuthToken",
+      "CacheParameterGroupName",
+      "CacheSecurityGroupNames",
       "CacheSubnetGroupName",
-      "NetworkType",
-      "DataTieringEnabled",
-      "AtRestEncryptionEnabled",
-      "ReplicationGroupId",
-      "GlobalReplicationGroupId",
+      "EngineVersion",
+      "NotificationTopicArn",
+      "PreferredMaintenanceWindow",
+      "SecurityGroupIds",
+      "SnapshotArns",
+      "SnapshotName",
+      "NodeGroupConfiguration",
+      "NumNodeGroups",
       "ReplicasPerNodeGroup",
+      "KmsKeyId",
+      "PrimaryClusterId",
       "PreferredCacheClusterAZs"
     ],
     "primaryIdentifier": [
@@ -87641,6 +87700,11 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "ReplicationGroup_Endpoint": {
+    "resourceType": "AWS::ElastiCache::ReplicationGroup.Endpoint",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "ReplicationGroup_KinesisFirehoseDestinationDetails": {
     "resourceType": "AWS::ElastiCache::ReplicationGroup.KinesisFirehoseDestinationDetails",
     "kind": "property",

package/src/package-cli.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+/**
+ * Thin entry point for `bun run bundle` in lexicon-aws.
+ * Generates src/generated/ files and writes dist/ bundle.
+ *
+ * NOTE: Does NOT call plugin.package() because that internally spawns
+ * `bun pm pack`, which would cause infinite recursion when invoked
+ * from a prepack lifecycle script.
+ */
+import { generate, writeGeneratedFiles } from "./codegen/generate";
+import { packageLexicon } from "./codegen/package";
+import { writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+
+// 1. Generate src/generated/ files
+const genResult = await generate({ verbose: true });
+writeGeneratedFiles(genResult, pkgDir);
+console.error(`Generated ${genResult.resources} resources, ${genResult.properties} property types, ${genResult.enums} enums`);
+
+// 2. Run package pipeline and write dist/
+const { spec, stats } = await packageLexicon({ verbose: true });
+
+const distDir = join(pkgDir, "dist");
+mkdirSync(join(distDir, "types"), { recursive: true });
+mkdirSync(join(distDir, "rules"), { recursive: true });
+mkdirSync(join(distDir, "skills"), { recursive: true });
+
+writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
+writeFileSync(join(distDir, "meta.json"), spec.registry);
+writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
+
+for (const [name, content] of spec.rules) {
+  writeFileSync(join(distDir, "rules", name), content);
+}
+for (const [name, content] of spec.skills) {
+  writeFileSync(join(distDir, "skills", name), content);
+}
+
+if (spec.integrity) {
+  writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
+}
+
+console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
+console.error(`dist/ written to ${distDir}`);