@intentius/chant-lexicon-aws 0.18.15 → 0.18.17

package/src/components/cloud-executor.ts

@@ -463,6 +463,23 @@ const realCloudFormation: CloudFormationClient = {
   },
 };
 
+/** Deployment id from an ECS `update-service` response. Tolerant of Floci, whose
+ * `service` omits `deployments` entirely (real AWS always includes it) — guards
+ * the index, not just `.id` (#937). Exported for testing. */
+export function ecsDeploymentId(described: { service: { deployments?: Array<{ id: string }> } }): string {
+  return described.service.deployments?.[0]?.id ?? "";
+}
+
+/** Whether an ECS service is steady (running == desired, ≤1 active deployment).
+ * Tolerant of Floci's missing `deployments` field. Exported for testing. */
+export function ecsServiceStable(
+  svc: { runningCount?: number; desiredCount?: number; deployments?: unknown[] } | undefined,
+): boolean {
+  const running = svc?.runningCount ?? 0;
+  const desired = svc?.desiredCount ?? 0;
+  return running === desired && (svc?.deployments?.length ?? 0) <= 1;
+}
+
 const realEcs: EcsClient = {
   async updateService(args) {
     const parts = [`aws ecs update-service`, `--cluster ${q(args.cluster)}`, `--service ${q(args.service)}`];
@@ -470,20 +487,18 @@ const realEcs: EcsClient = {
     if (args.desiredCount !== undefined) parts.push(`--desired-count ${args.desiredCount}`);
     if (args.forceNewDeployment) parts.push(`--force-new-deployment`);
     const { stdout } = await run(parts.join(" "));
-    const described = JSON.parse(stdout) as { service: { deployments: Array<{ id: string }> } };
-    return { deploymentId: described.service.deployments[0]?.id ?? "" };
+    const described = JSON.parse(stdout) as { service: { deployments?: Array<{ id: string }> } };
+    return { deploymentId: ecsDeploymentId(described) };
   },
   async describeService(cluster, service) {
     const { stdout } = await run(
       `aws ecs describe-services --cluster ${q(cluster)} --services ${q(service)}`,
     );
     const described = JSON.parse(stdout) as {
-      services: Array<{ runningCount: number; desiredCount: number; deployments: unknown[] }>;
+      services: Array<{ runningCount: number; desiredCount: number; deployments?: unknown[] }>;
     };
     const svc = described.services[0];
-    const running = svc?.runningCount ?? 0;
-    const desired = svc?.desiredCount ?? 0;
-    return { runningCount: running, desiredCount: desired, stable: running === desired && (svc?.deployments.length ?? 0) <= 1 };
+    return { runningCount: svc?.runningCount ?? 0, desiredCount: svc?.desiredCount ?? 0, stable: ecsServiceStable(svc) };
   },
   async rollbackService(args) {
     await realEcs.updateService(args);

package/src/composites/agentcore-agent.test.ts

@@ -7,6 +7,7 @@ import { AttrRef } from "@intentius/chant/attrref";
 // precedent for aws-lexicon integration-style tests.
 import { resolveAttrRefs } from "../../../../packages/core/src/discovery/resolve";
 import { AgentCoreAgent } from "./agentcore-agent";
+import { Split, Ref } from "../intrinsics";
 import { awsSerializer } from "../serializer";
 
 const baseProps = {
@@ -104,6 +105,17 @@ describe("AgentCoreAgent", () => {
     );
   });
 
+  test("VPC mode accepts a cross-stack intrinsic (Fn::Split) — checks presence, not .length (#938)", () => {
+    // A cross-stack value (Split of a Parameter) is a truthy intrinsic with no
+    // `.length`; it WAS supplied, so the composite must not reject it.
+    const subnets = Split(",", Ref("SubnetIdsParam")) as unknown as string[];
+    const sgs = Split(",", Ref("SgIdsParam")) as unknown as string[];
+    const instance = AgentCoreAgent({ ...baseProps, networkMode: "VPC", vpcSubnetIds: subnets, vpcSecurityGroupIds: sgs });
+    const vpcConfigProps = ((instance.runtime as any).props.NetworkConfiguration as any).props.NetworkModeConfig.props;
+    expect(vpcConfigProps.Subnets).toBe(subnets);
+    expect(vpcConfigProps.SecurityGroups).toBe(sgs);
+  });
+
   test("throws when memoryEventExpiryDays is out of CFN bounds (3-365)", () => {
     expect(() => AgentCoreAgent({ ...baseProps, memoryEventExpiryDays: 1 })).toThrow(
       "AgentCoreAgent memoryEventExpiryDays must be between 3 and 365",

package/src/composites/agentcore-agent.ts

@@ -107,7 +107,11 @@ export type AgentCoreAgentResult = {
 export const AgentCoreAgent = Composite<AgentCoreAgentProps, AgentCoreAgentResult>((props) => {
   const { defaults } = props;
   const networkMode = props.networkMode ?? "PUBLIC";
-  if (networkMode === "VPC" && (!props.vpcSubnetIds?.length || !props.vpcSecurityGroupIds?.length)) {
+  // Check presence, not `.length`: a cross-stack value (Fn::Split of a Parameter,
+  // the shape stackOutput/Ref/Split produce) is a truthy intrinsic object with no
+  // `.length`, so a `.length` check wrongly rejects a value that WAS supplied
+  // (#938). An actually-empty list is caught by CloudFormation at deploy time.
+  if (networkMode === "VPC" && (props.vpcSubnetIds === undefined || props.vpcSecurityGroupIds === undefined)) {
     throw new Error("AgentCoreAgent requires vpcSubnetIds and vpcSecurityGroupIds when networkMode is \"VPC\"");
   }
   const memoryEventExpiryDays = props.memoryEventExpiryDays ?? 30;

package/src/generated/index.d.ts

@@ -3071,7 +3071,7 @@ export declare class AutoScalingGroup {
     TrafficSources?: AutoScalingGroup_TrafficSourceIdentifier[];
     /** A list of subnet IDs for a virtual private cloud (VPC) where instances in the Auto Scaling group can be created.
  If this resource specifies public subnets and is also in a VPC that is defined in the same stack template, you must use the [DependsOn attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-dependson.html) to declare a dependency on the [VPC-gateway attachment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc-gateway-attachment.html).
-  When you update ``VPCZoneIdentifier``, this retains the same Auto Scaling group and replaces old instances with new ones, according to the specified subnets. You can optionally specify how CloudFormation handles these updates by using an [UpdatePolicy attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-updatepolicy.html).
+  When you update ``VPCZoneIdentifier``, this retains the same Auto Scaling group and replaces old instances with new ones, according to the specified subnets. To control how CloudFormation replaces the instances, add an [UpdatePolicy attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-updatepolicy.html) to your stack. Set the update policy to ``AutoScalingInstanceRefresh``. For more information, see the [AutoScalingInstanceRefresh policy](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-updatepolicy.html#cfn-attributes-updatepolicy-instancerefresh).
   Required to launch instances into a nondefault VPC. If you specify ``VPCZoneIdentifier`` with ``AvailabilityZones``, the subnets that you specify for this property must reside in those Availability Zones. */
     VPCZoneIdentifier?: string[];
   }, attributes?: CFResourceAttributes);
@@ -17601,14 +17601,14 @@ export declare class InstanceGroupConfig {
     JobFlowId: string;
     AutoScalingPolicy?: InstanceGroupConfig_AutoScalingPolicy;
     BidPrice?: string;
-    Configurations?: InstanceGroupConfig_Configuration[];
+    Configurations?: InstanceGroupConfig_AppConfiguration[];
     CustomAmiId?: string;
     EbsConfiguration?: InstanceGroupConfig_EbsConfiguration;
-    Id?: string;
+    InstanceGroupId?: string;
     Market?: string;
     Name?: string;
   }, attributes?: CFResourceAttributes);
-  readonly Id: string;
+  readonly InstanceGroupId: string;
 }
 
 export declare class InstanceProfile {
@@ -17804,6 +17804,30 @@ export declare class InterconnectConnection {
   readonly Type: string;
 }
 
+export declare class IntermediateTable {
+  constructor(props: {
+    MembershipIdentifier: string;
+    Name: string;
+    PopulationAnalysisConfiguration: IntermediateTable_PopulationAnalysisConfiguration;
+    AnalysisRules?: IntermediateTable_IntermediateTableAnalysisRule[];
+    Arn?: string;
+    CollaborationArn?: string;
+    CollaborationIdentifier?: string;
+    Description?: string;
+    IntermediateTableIdentifier?: string;
+    KmsKeyArn?: string;
+    MembershipArn?: string;
+    Status?: IntermediateTable_IntermediateTableStatus;
+    Tags?: IntermediateTable_Tag[];
+  }, attributes?: CFResourceAttributes);
+  readonly Arn: string;
+  readonly CollaborationArn: string;
+  readonly CollaborationIdentifier: string;
+  readonly IntermediateTableIdentifier: string;
+  readonly MembershipArn: string;
+  readonly Status: IntermediateTable_IntermediateTableStatus;
+}
+
 export declare class InternetGateway {
   constructor(props: {
     InternetGatewayId?: string;
@@ -20051,6 +20075,7 @@ export declare class Listener {
     /** [HTTPS and TLS listeners] The security policy that defines which protocols and ciphers are supported. For more information, see [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/describe-ssl-policies.html) in the *Application Load Balancers Guide* and [Security policies](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/describe-ssl-policies.html) in the *Network Load Balancers Guide*.
  [HTTPS listeners] Updating the security policy can result in interruptions if the load balancer is handling a high volume of traffic. To decrease the possibility of an interruption if your load balancer is handling a high volume of traffic, create an additional load balancer or request an LCU reservation. */
     SslPolicy?: string;
+    Tags?: Listener_Tag[];
   }, attributes?: CFResourceAttributes);
   readonly ListenerArn: string;
 }
@@ -41378,6 +41403,14 @@ export declare class AppConfigResourceObject {
   });
 }
 
+export declare class AppConfiguration {
+  constructor(props: {
+    Classification?: string;
+    ConfigurationProperties?: Record<string, unknown>;
+    Configurations?: InstanceGroupConfig_AppConfiguration[];
+  });
+}
+
 export declare class AppCookieStickinessPolicy {
   constructor(props: {
     /** The name of the application cookie used for stickiness. */
@@ -44843,7 +44876,8 @@ export declare class AutoScalingGroup_AvailabilityZoneDistribution {
   constructor(props: {
     /** If launches fail in an Availability Zone, the following strategies are available. The default is ``balanced-best-effort``. 
   +  ``balanced-only`` - If launches fail in an Availability Zone, Auto Scaling will continue to attempt to launch in the unhealthy zone to preserve a balanced distribution.
-  +  ``balanced-best-effort`` - If launches fail in an Availability Zone, Auto Scaling will attempt to launch in another healthy Availability Zone instead. */
+  +  ``balanced-best-effort`` - If launches fail in an Availability Zone, Auto Scaling will attempt to launch in another healthy Availability Zone instead.
+  +  ``reservations-then-balanced`` - Auto Scaling will first attempt to launch into your Capacity Reservations, and then balance any remaining capacity across healthy Availability Zones. */
     CapacityDistributionStrategy?: "balanced-best-effort" | "balanced-only" | "reservations-then-balanced";
   });
 }
@@ -45290,7 +45324,8 @@ export declare class AvailabilityZoneDistribution {
   constructor(props: {
     /** If launches fail in an Availability Zone, the following strategies are available. The default is ``balanced-best-effort``. 
   +  ``balanced-only`` - If launches fail in an Availability Zone, Auto Scaling will continue to attempt to launch in the unhealthy zone to preserve a balanced distribution.
-  +  ``balanced-best-effort`` - If launches fail in an Availability Zone, Auto Scaling will attempt to launch in another healthy Availability Zone instead. */
+  +  ``balanced-best-effort`` - If launches fail in an Availability Zone, Auto Scaling will attempt to launch in another healthy Availability Zone instead.
+  +  ``reservations-then-balanced`` - Auto Scaling will first attempt to launch into your Capacity Reservations, and then balance any remaining capacity across healthy Availability Zones. */
     CapacityDistributionStrategy?: "balanced-best-effort" | "balanced-only" | "reservations-then-balanced";
   });
 }
@@ -78908,24 +78943,26 @@ export declare class InstanceFleetConfig_SpotResizingSpecification {
   });
 }
 
-export declare class InstanceGroupConfig_AutoScalingPolicy {
+export declare class InstanceGroupConfig_AppConfiguration {
   constructor(props: {
-    Constraints: InstanceGroupConfig_ScalingConstraints;
-    Rules: InstanceGroupConfig_ScalingRule[];
+    Classification?: string;
+    ConfigurationProperties?: Record<string, unknown>;
+    Configurations?: InstanceGroupConfig_AppConfiguration[];
   });
 }
 
-export declare class InstanceGroupConfig_Configuration {
+export declare class InstanceGroupConfig_AutoScalingPolicy {
   constructor(props: {
-    Classification?: string;
-    ConfigurationProperties?: Record<string, unknown>;
-    Configurations?: InstanceGroupConfig_Configuration[];
+    Constraints: InstanceGroupConfig_ScalingConstraints;
+    Rules: InstanceGroupConfig_ScalingRule[];
   });
 }
 
 export declare class InstanceGroupConfig_EbsBlockDeviceConfig {
   constructor(props: {
     VolumeSpecification: InstanceGroupConfig_VolumeSpecification;
+    /** Use of this property can confuse CloudFormation drift detection. The EbsBlockDeviceConfigs read from the system may return a list with one entry per volume, replacing any entry specified in the template with a VolumesPerInstance greater than one by that many entries containing only the VolumeSpecification. Thus to avoid false drift detection, it is recommended to supply repeated entries in EbsBlockDeviceConfigs for any VolumeSpecification which is intended to be repeated and not to use this property.
+ */
     VolumesPerInstance?: number;
   });
 }
@@ -79394,6 +79431,52 @@ export declare class IntermediateStorage {
   });
 }
 
+export declare class IntermediateTable_IntermediateTableAnalysisRule {
+  constructor(props: {
+    Policy: IntermediateTable_IntermediateTableAnalysisRulePolicy;
+    Type: IntermediateTable_IntermediateTableAnalysisRuleType;
+  });
+}
+
+export declare class IntermediateTable_IntermediateTableAnalysisRulePolicy {
+  constructor(props: {
+    V1: any;
+  });
+}
+
+export declare class IntermediateTable_PopulationAnalysisConfiguration {
+  constructor(props: {
+    SqlParameters?: IntermediateTable_PopulationAnalysisSqlParameters;
+  });
+}
+
+export declare class IntermediateTable_PopulationAnalysisSqlParameters {
+  constructor(props: {
+    AnalysisTemplateArn?: string;
+    QueryString?: string;
+  });
+}
+
+export declare class IntermediateTable_Tag {
+  constructor(props: {
+    Key: string;
+    Value: string;
+  });
+}
+
+export declare class IntermediateTableAnalysisRule {
+  constructor(props: {
+    Policy: IntermediateTable_IntermediateTableAnalysisRulePolicy;
+    Type: IntermediateTable_IntermediateTableAnalysisRuleType;
+  });
+}
+
+export declare class IntermediateTableAnalysisRulePolicy {
+  constructor(props: {
+    V1: any;
+  });
+}
+
 export declare class InternetGateway_Tag {
   constructor(props: {
     /** The tag key. */
@@ -84843,6 +84926,13 @@ export declare class Listener_RedirectConfig {
   });
 }
 
+export declare class Listener_Tag {
+  constructor(props: {
+    Key: string;
+    Value: string;
+  });
+}
+
 export declare class Listener_TargetGroupStickinessConfig {
   constructor(props: {
     /** [Application Load Balancers] The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness. */
@@ -85869,10 +85959,10 @@ export declare class LogAlarm_ScheduleConfiguration {
   constructor(props: {
     /** The expression that defines when the scheduled query runs, e.g. rate(1 minute). */
     ScheduleExpression: string;
-    /** The number of seconds into the past to end the query window. */
+    /** The number of seconds into the past to start the query window. Must be a positive value and cannot exceed 2592000 seconds (30 days). */
+    StartTimeOffset: number;
+    /** The number of seconds into the past to end the query window. Must be a non-negative value and cannot exceed 2592000 seconds (30 days). */
     EndTimeOffset?: number;
-    /** The number of seconds into the past to start the query window. */
-    StartTimeOffset?: number;
   });
 }
 
@@ -85880,14 +85970,16 @@ export declare class LogAlarm_ScheduledQueryConfiguration {
   constructor(props: {
     /** The aggregation expression for the scheduled query, e.g. count(*) or avg(latency) by host. */
     AggregationExpression: string;
-    /** The log groups to query. */
-    LogGroupIdentifiers: string[];
     /** The query string to execute against the specified log groups. */
     QueryString: string;
     /** The schedule configuration. */
     ScheduleConfiguration: LogAlarm_ScheduleConfiguration;
     /** The ARN of the IAM role that grants permissions to execute the scheduled query. */
     ScheduledQueryRoleARN: string;
+    /** The log groups to query. */
+    LogGroupIdentifiers?: string[];
+    /** A list of key-value pairs to associate with the scheduled query that backs the log alarm. */
+    Tags?: LogAlarm_Tag[];
   });
 }
 
@@ -98971,6 +99063,19 @@ export declare class Pool_Tag {
   });
 }
 
+export declare class PopulationAnalysisConfiguration {
+  constructor(props: {
+    SqlParameters?: IntermediateTable_PopulationAnalysisSqlParameters;
+  });
+}
+
+export declare class PopulationAnalysisSqlParameters {
+  constructor(props: {
+    AnalysisTemplateArn?: string;
+    QueryString?: string;
+  });
+}
+
 export declare class Port {
   constructor(props: {
     /** Access Direction for Protocol of the Instance(inbound/outbound). */
@@ -109362,14 +109467,16 @@ export declare class ScheduledQueryConfiguration {
   constructor(props: {
     /** The aggregation expression for the scheduled query, e.g. count(*) or avg(latency) by host. */
     AggregationExpression: string;
-    /** The log groups to query. */
-    LogGroupIdentifiers: string[];
     /** The query string to execute against the specified log groups. */
     QueryString: string;
     /** The schedule configuration. */
     ScheduleConfiguration: LogAlarm_ScheduleConfiguration;
     /** The ARN of the IAM role that grants permissions to execute the scheduled query. */
     ScheduledQueryRoleARN: string;
+    /** The log groups to query. */
+    LogGroupIdentifiers?: string[];
+    /** A list of key-value pairs to associate with the scheduled query that backs the log alarm. */
+    Tags?: LogAlarm_Tag[];
   });
 }
 
@@ -127874,6 +127981,18 @@ export type IntelligentPromptRouter_PromptRouterStatus = "AVAILABLE";
 
 export type IntelligentPromptRouter_PromptRouterType = "custom" | "default";
 
+export type IntermediateTable_AdditionalAnalyses = "ALLOWED" | "NOT_ALLOWED" | "REQUIRED";
+
+export type IntermediateTable_IntermediateTableAnalysisRuleType = "CUSTOM";
+
+export type IntermediateTable_IntermediateTableStatus =
+  | "BASE_TABLE_REMOVED"
+  | "CREATED"
+  | "DISALLOWED_BY_DATA_PROVIDER"
+  | "POPULATE_FAILED"
+  | "POPULATE_STARTED"
+  | "POPULATE_SUCCESS";
+
 export type InternetMonitorMonitor_MonitorConfigState =
   | "ACTIVE"
   | "ERROR"

package/src/generated/index.ts

@@ -688,7 +688,7 @@ export const Instance = createResource("AWS::EC2::Instance", "aws", {"InstanceId
 export const InstanceAccessControlAttributeConfiguration = createResource("AWS::SSO::InstanceAccessControlAttributeConfiguration", "aws", {});
 export const InstanceConnectEndpoint = createResource("AWS::EC2::InstanceConnectEndpoint", "aws", {"Id":"Id","AvailabilityZone":"AvailabilityZone","AvailabilityZoneId":"AvailabilityZoneId","CreatedAt":"CreatedAt","InstanceConnectEndpointArn":"InstanceConnectEndpointArn","NetworkInterfaceIds":"NetworkInterfaceIds","OwnerId":"OwnerId","PublicDnsNames":"PublicDnsNames","State":"State","StateMessage":"StateMessage","VpcId":"VpcId"});
 export const InstanceFleetConfig = createResource("AWS::EMR::InstanceFleetConfig", "aws", {"Id":"Id"});
-export const InstanceGroupConfig = createResource("AWS::EMR::InstanceGroupConfig", "aws", {"Id":"Id"});
+export const InstanceGroupConfig = createResource("AWS::EMR::InstanceGroupConfig", "aws", {"InstanceGroupId":"InstanceGroupId"});
 export const InstanceProfile = createResource("AWS::IAM::InstanceProfile", "aws", {"Arn":"Arn"});
 export const InstanceSnapshot = createResource("AWS::Lightsail::InstanceSnapshot", "aws", {"Arn":"Arn","IsFromAutoSnapshot":"IsFromAutoSnapshot","Location":"Location","FromInstanceName":"FromInstanceName","FromInstanceArn":"FromInstanceArn","ResourceType":"ResourceType","SizeInGb":"SizeInGb","State":"State","SupportCode":"SupportCode"});
 export const InstanceStorageConfig = createResource("AWS::Connect::InstanceStorageConfig", "aws", {"AssociationId":"AssociationId"});
@@ -697,6 +697,7 @@ export const IntegrationResourceProperty = createResource("AWS::Glue::Integratio
 export const IntegrationResponse = createResource("AWS::ApiGatewayV2::IntegrationResponse", "aws", {"IntegrationResponseId":"IntegrationResponseId"});
 export const IntelligentPromptRouter = createResource("AWS::Bedrock::IntelligentPromptRouter", "aws", {"CreatedAt":"CreatedAt","PromptRouterArn":"PromptRouterArn","Status":"Status","Type":"Type","UpdatedAt":"UpdatedAt"});
 export const InterconnectConnection = createResource("AWS::Interconnect::Connection", "aws", {"ConnectionId":"ConnectionId","Arn":"Arn","Provider":"Provider","Type":"Type","State":"State","SharedId":"SharedId","OwnerAccount":"OwnerAccount","BillingTier":"BillingTier"});
+export const IntermediateTable = createResource("AWS::CleanRooms::IntermediateTable", "aws", {"IntermediateTableIdentifier":"IntermediateTableIdentifier","Arn":"Arn","MembershipArn":"MembershipArn","CollaborationIdentifier":"CollaborationIdentifier","CollaborationArn":"CollaborationArn","Status":"Status"});
 export const InternetGateway = createResource("AWS::EC2::InternetGateway", "aws", {"InternetGatewayId":"InternetGatewayId"});
 export const InternetMonitorMonitor = createResource("AWS::InternetMonitor::Monitor", "aws", {"CreatedAt":"CreatedAt","ModifiedAt":"ModifiedAt","MonitorArn":"MonitorArn","ProcessingStatus":"ProcessingStatus","ProcessingStatusInfo":"ProcessingStatusInfo"});
 export const InvestigationGroup = createResource("AWS::AIOps::InvestigationGroup", "aws", {"CreatedBy":"CreatedBy","CreatedAt":"CreatedAt","LastModifiedBy":"LastModifiedBy","LastModifiedAt":"LastModifiedAt","Arn":"Arn"});
@@ -1984,6 +1985,7 @@ export const AppConfigDeployment_Tag = createProperty("AWS::AppConfig::Deploymen
 export const AppConfigEnvironment_Monitor = createProperty("AWS::AppConfig::Environment.Monitor", "aws");
 export const AppConfigEnvironment_Tag = createProperty("AWS::AppConfig::Environment.Tag", "aws");
 export const AppConfigResourceObject = createProperty("AWS::Evidently::Project.AppConfigResourceObject", "aws");
+export const AppConfiguration = createProperty("AWS::EMR::InstanceGroupConfig.AppConfiguration", "aws");
 export const AppCookieStickinessPolicy = createProperty("AWS::ElasticLoadBalancing::LoadBalancer.AppCookieStickinessPolicy", "aws");
 export const AppFlowConnector_ConnectorProvisioningConfig = createProperty("AWS::AppFlow::Connector.ConnectorProvisioningConfig", "aws");
 export const AppFlowConnector_LambdaConnectorProvisioningConfig = createProperty("AWS::AppFlow::Connector.LambdaConnectorProvisioningConfig", "aws");
@@ -5822,8 +5824,8 @@ export const InstanceFleetConfig_OnDemandProvisioningSpecification = createPrope
 export const InstanceFleetConfig_OnDemandResizingSpecification = createProperty("AWS::EMR::InstanceFleetConfig.OnDemandResizingSpecification", "aws");
 export const InstanceFleetConfig_SpotProvisioningSpecification = createProperty("AWS::EMR::InstanceFleetConfig.SpotProvisioningSpecification", "aws");
 export const InstanceFleetConfig_SpotResizingSpecification = createProperty("AWS::EMR::InstanceFleetConfig.SpotResizingSpecification", "aws");
+export const InstanceGroupConfig_AppConfiguration = createProperty("AWS::EMR::InstanceGroupConfig.AppConfiguration", "aws");
 export const InstanceGroupConfig_AutoScalingPolicy = createProperty("AWS::EMR::InstanceGroupConfig.AutoScalingPolicy", "aws");
-export const InstanceGroupConfig_Configuration = createProperty("AWS::EMR::InstanceGroupConfig.Configuration", "aws");
 export const InstanceGroupConfig_EbsBlockDeviceConfig = createProperty("AWS::EMR::InstanceGroupConfig.EbsBlockDeviceConfig", "aws");
 export const InstanceGroupConfig_EbsConfiguration = createProperty("AWS::EMR::InstanceGroupConfig.EbsConfiguration", "aws");
 export const InstanceGroupConfig_ScalingAction = createProperty("AWS::EMR::InstanceGroupConfig.ScalingAction", "aws");
@@ -5873,6 +5875,13 @@ export const InterconnectConnection_Tag = createProperty("AWS::Interconnect::Con
 export const Interface = createProperty("AWS::MediaConnect::FlowOutput.Interface", "aws");
 export const InterfaceMapping = createProperty("AWS::MediaLive::Cluster.InterfaceMapping", "aws");
 export const IntermediateStorage = createProperty("AWS::Bedrock::DataSource.IntermediateStorage", "aws");
+export const IntermediateTable_IntermediateTableAnalysisRule = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule", "aws");
+export const IntermediateTable_IntermediateTableAnalysisRulePolicy = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy", "aws");
+export const IntermediateTable_PopulationAnalysisConfiguration = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration", "aws");
+export const IntermediateTable_PopulationAnalysisSqlParameters = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters", "aws");
+export const IntermediateTable_Tag = createProperty("AWS::CleanRooms::IntermediateTable.Tag", "aws");
+export const IntermediateTableAnalysisRule = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule", "aws");
+export const IntermediateTableAnalysisRulePolicy = createProperty("AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy", "aws");
 export const InternetGateway_Tag = createProperty("AWS::EC2::InternetGateway.Tag", "aws");
 export const InternetMeasurementsLogDelivery = createProperty("AWS::InternetMonitor::Monitor.InternetMeasurementsLogDelivery", "aws");
 export const InternetMonitorMonitor_HealthEventsConfig = createProperty("AWS::InternetMonitor::Monitor.HealthEventsConfig", "aws");
@@ -6427,6 +6436,7 @@ export const Listener_JwtValidationConfig = createProperty("AWS::ElasticLoadBala
 export const Listener_ListenerAttribute = createProperty("AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute", "aws");
 export const Listener_MutualAuthentication = createProperty("AWS::ElasticLoadBalancingV2::Listener.MutualAuthentication", "aws");
 export const Listener_RedirectConfig = createProperty("AWS::ElasticLoadBalancingV2::Listener.RedirectConfig", "aws");
+export const Listener_Tag = createProperty("AWS::ElasticLoadBalancingV2::Listener.Tag", "aws");
 export const Listener_TargetGroupStickinessConfig = createProperty("AWS::ElasticLoadBalancingV2::Listener.TargetGroupStickinessConfig", "aws");
 export const Listener_TargetGroupTuple = createProperty("AWS::ElasticLoadBalancingV2::Listener.TargetGroupTuple", "aws");
 export const ListenerAttribute = createProperty("AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute", "aws");
@@ -7919,6 +7929,8 @@ export const PolicyStore_ValidationSettings = createProperty("AWS::VerifiedPermi
 export const PolicyTag = createProperty("AWS::FMS::Policy.PolicyTag", "aws");
 export const Pool_OptionalKeyword = createProperty("AWS::SMSVOICE::Pool.OptionalKeyword", "aws");
 export const Pool_Tag = createProperty("AWS::SMSVOICE::Pool.Tag", "aws");
+export const PopulationAnalysisConfiguration = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration", "aws");
+export const PopulationAnalysisSqlParameters = createProperty("AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters", "aws");
 export const Port = createProperty("AWS::Lightsail::Instance.Port", "aws");
 export const Portal = createProperty("AWS::IoTSiteWise::AccessPolicy.Portal", "aws");
 export const PortalOptionsConfiguration = createProperty("AWS::SSO::Application.PortalOptionsConfiguration", "aws");

package/src/generated/lexicon-aws.json

@@ -5045,6 +5045,11 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "AppConfiguration": {
+    "resourceType": "AWS::EMR::InstanceGroupConfig.AppConfiguration",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "AppCookieStickinessPolicy": {
     "resourceType": "AWS::ElasticLoadBalancing::LoadBalancer.AppCookieStickinessPolicy",
     "kind": "property",
@@ -8347,8 +8352,7 @@
       "KmsKeyArn": "KmsKeyArn"
     },
     "createOnly": [
-      "KmsKeyId",
-      "ForceDelete"
+      "KmsKeyId"
     ],
     "writeOnly": [
       "KmsKeyId",
@@ -48825,7 +48829,7 @@
     "kind": "resource",
     "lexicon": "aws",
     "attrs": {
-      "Id": "Id"
+      "InstanceGroupId": "InstanceGroupId"
     },
     "createOnly": [
       "InstanceRole",
@@ -48838,17 +48842,21 @@
       "Market",
       "BidPrice"
     ],
+    "writeOnly": [
+      "EbsConfiguration/EbsBlockDeviceConfigs/*/VolumesPerInstance"
+    ],
     "primaryIdentifier": [
-      "Id"
+      "InstanceGroupId",
+      "JobFlowId"
     ]
   },
-  "InstanceGroupConfig_AutoScalingPolicy": {
-    "resourceType": "AWS::EMR::InstanceGroupConfig.AutoScalingPolicy",
+  "InstanceGroupConfig_AppConfiguration": {
+    "resourceType": "AWS::EMR::InstanceGroupConfig.AppConfiguration",
     "kind": "property",
     "lexicon": "aws"
   },
-  "InstanceGroupConfig_Configuration": {
-    "resourceType": "AWS::EMR::InstanceGroupConfig.Configuration",
+  "InstanceGroupConfig_AutoScalingPolicy": {
+    "resourceType": "AWS::EMR::InstanceGroupConfig.AutoScalingPolicy",
     "kind": "property",
     "lexicon": "aws"
   },
@@ -49451,6 +49459,92 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "IntermediateTable": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable",
+    "kind": "resource",
+    "lexicon": "aws",
+    "attrs": {
+      "IntermediateTableIdentifier": "IntermediateTableIdentifier",
+      "Arn": "Arn",
+      "MembershipArn": "MembershipArn",
+      "CollaborationIdentifier": "CollaborationIdentifier",
+      "CollaborationArn": "CollaborationArn",
+      "Status": "Status"
+    },
+    "propertyConstraints": {
+      "Arn": {
+        "maxLength": 256
+      },
+      "MembershipArn": {
+        "maxLength": 100
+      },
+      "CollaborationArn": {
+        "maxLength": 100
+      },
+      "Name": {
+        "pattern": "^(?!\\s*$)[\\u0020-\\uD7FF\\uE000-\\uFFFD\\uD800\\uDBFF-\\uDC00\\uDFFF\\t]*$",
+        "minLength": 1,
+        "maxLength": 100
+      },
+      "Description": {
+        "pattern": "^[\\u0020-\\uD7FF\\uE000-\\uFFFD\\uD800\\uDBFF-\\uDC00\\uDFFF\\t\\r\\n]*$",
+        "maxLength": 255
+      },
+      "KmsKeyArn": {
+        "minLength": 4,
+        "maxLength": 2048
+      }
+    },
+    "createOnly": [
+      "MembershipIdentifier",
+      "Name",
+      "PopulationAnalysisConfiguration"
+    ],
+    "primaryIdentifier": [
+      "IntermediateTableIdentifier",
+      "MembershipIdentifier"
+    ],
+    "tagging": {
+      "taggable": true,
+      "tagOnCreate": true,
+      "tagUpdatable": true
+    }
+  },
+  "IntermediateTableAnalysisRule": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTableAnalysisRulePolicy": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_IntermediateTableAnalysisRule": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRule",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_IntermediateTableAnalysisRulePolicy": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.IntermediateTableAnalysisRulePolicy",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_PopulationAnalysisConfiguration": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_PopulationAnalysisSqlParameters": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "IntermediateTable_Tag": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.Tag",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "InternetGateway": {
     "resourceType": "AWS::EC2::InternetGateway",
     "kind": "resource",
@@ -54791,7 +54885,12 @@
     ],
     "primaryIdentifier": [
       "ListenerArn"
-    ]
+    ],
+    "tagging": {
+      "taggable": true,
+      "tagOnCreate": true,
+      "tagUpdatable": true
+    }
   },
   "ListenerAttribute": {
     "resourceType": "AWS::ElasticLoadBalancingV2::Listener.ListenerAttribute",
@@ -55022,6 +55121,11 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "Listener_Tag": {
+    "resourceType": "AWS::ElasticLoadBalancingV2::Listener.Tag",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "Listener_TargetGroupStickinessConfig": {
     "resourceType": "AWS::ElasticLoadBalancingV2::Listener.TargetGroupStickinessConfig",
     "kind": "property",
@@ -71684,6 +71788,16 @@
     "kind": "property",
     "lexicon": "aws"
   },
+  "PopulationAnalysisConfiguration": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisConfiguration",
+    "kind": "property",
+    "lexicon": "aws"
+  },
+  "PopulationAnalysisSqlParameters": {
+    "resourceType": "AWS::CleanRooms::IntermediateTable.PopulationAnalysisSqlParameters",
+    "kind": "property",
+    "lexicon": "aws"
+  },
   "Port": {
     "resourceType": "AWS::Lightsail::Instance.Port",
     "kind": "property",