@horietakehiro/aws-cdk-utul 0.41.54 → 0.41.55

package/lib/types/cfn-resource-types/aws-connect-workspace.d.ts

@@ -0,0 +1,143 @@
+export type ThemeString = string;
+export type WorkspaceFontFamily = ("ARIAL" | "COURIER_NEW" | "GEORGIA" | "TIMES_NEW_ROMAN" | "TREBUCHET" | "VERDANA");
+/**
+ * The type of media
+ */
+export type MediaType = ("IMAGE_LOGO_LIGHT_FAVICON" | "IMAGE_LOGO_DARK_FAVICON" | "IMAGE_LOGO_LIGHT_HORIZONTAL" | "IMAGE_LOGO_DARK_HORIZONTAL");
+/**
+ * Resource Type definition for AWS::Connect::Workspace
+ */
+export interface _AWS_CONNECT_WORKSPACE {
+    /**
+     * The Amazon Resource Name (ARN) for the workspace.
+     */
+    Arn?: string;
+    /**
+     * The name of the workspace.
+     */
+    Name: string;
+    /**
+     * The identifier of the workspace.
+     */
+    Id?: string;
+    /**
+     * The identifier of the Amazon Connect instance.
+     */
+    InstanceArn: string;
+    /**
+     * The visibility of the workspace. Will always be set to ASSIGNED oninitial creation.
+     */
+    Visibility?: ("ALL" | "ASSIGNED" | "NONE");
+    /**
+     * The description of the workspace
+     */
+    Description?: string;
+    /**
+     * The title of the workspace
+     */
+    Title?: string;
+    Theme?: WorkspaceTheme;
+    /**
+     * The media items for the workspace
+     *
+     * @maxItems 4
+     */
+    Media?: MediaItem[];
+    /**
+     * The pages associated with the workspace
+     */
+    Pages?: WorkspacePage[];
+    /**
+     * The resource ARNs associated with the workspace
+     */
+    Associations?: string[];
+    /**
+     * An array of key-value pairs to apply to this resource.
+     *
+     * @maxItems 50
+     */
+    Tags?: Tag[];
+}
+/**
+ * The theme configuration for the workspace
+ */
+export interface WorkspaceTheme {
+    Light?: WorkspaceThemeConfig;
+    Dark?: WorkspaceThemeConfig;
+}
+export interface WorkspaceThemeConfig {
+    Palette?: WorkspaceThemePalette;
+    Typography?: WorkspaceThemeTypography;
+}
+export interface WorkspaceThemePalette {
+    Header?: PaletteHeader;
+    Navigation?: PaletteNavigation;
+    Canvas?: PaletteCanvas;
+    Primary?: PalettePrimary;
+}
+export interface PaletteHeader {
+    Background?: ThemeString;
+    Text?: ThemeString;
+    TextHover?: ThemeString;
+    InvertActionsColors?: boolean;
+}
+export interface PaletteNavigation {
+    Background?: ThemeString;
+    TextBackgroundHover?: ThemeString;
+    TextBackgroundActive?: ThemeString;
+    Text?: ThemeString;
+    TextHover?: ThemeString;
+    TextActive?: ThemeString;
+    InvertActionsColors?: boolean;
+}
+export interface PaletteCanvas {
+    ContainerBackground?: ThemeString;
+    PageBackground?: ThemeString;
+    ActiveBackground?: ThemeString;
+}
+export interface PalettePrimary {
+    Default?: ThemeString;
+    Active?: ThemeString;
+    ContrastText?: ThemeString;
+}
+export interface WorkspaceThemeTypography {
+    FontFamily?: FontFamily;
+}
+export interface FontFamily {
+    Default?: WorkspaceFontFamily;
+}
+export interface MediaItem {
+    Type: MediaType;
+    Source?: string;
+}
+export interface WorkspacePage {
+    /**
+     * The Amazon Resource Name (ARN) of the resource associated with the page.
+     */
+    ResourceArn: string;
+    /**
+     * The page identifier.
+     */
+    Page: string;
+    /**
+     * The slug for the page.
+     */
+    Slug?: string;
+    /**
+     * The input data for the page.
+     */
+    InputData?: string;
+}
+/**
+ * A key-value pair to associate with a resource.
+ */
+export interface Tag {
+    /**
+     * 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;
+}

package/lib/types/cfn-resource-types/aws-connect-workspace.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/cfn-resource-types/aws-connectcampaignsv2-campaign.d.ts

@@ -61,6 +61,10 @@ export type ContactFlowId = string;
  * The phone number associated with the Amazon Connect instance, in E.164 format. If you do not specify a source phone number, you must specify a queue.
  */
 export type SourcePhoneNumber = string;
+/**
+ * Maximum ring time for outbound calls in seconds
+ */
+export type RingTimeout = number;
 /**
  * Arn
  */
@@ -219,6 +223,7 @@ export interface TelephonyOutboundConfig {
     ConnectContactFlowId: ContactFlowId;
     ConnectSourcePhoneNumber?: SourcePhoneNumber;
     AnswerMachineDetectionConfig?: AnswerMachineDetectionConfig;
+    RingTimeout?: RingTimeout;
 }
 /**
  * The configuration used for answering machine detection during outbound calls

package/lib/types/cfn-resource-types/aws-connectcampaignsv2-campaign.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-connectcampaignsv2-campaign.js","sourceRoot":"","sources":["aws-connectcampaignsv2-campaign.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Campaign name\n */\nexport type CampaignName = string\n/**\n * Amazon Connect Instance Id\n */\nexport type InstanceId = string\n/**\n * The possible types of channel subtype config parameters\n */\nexport type ChannelSubtypeConfig = (ChannelSubtypeConfig1 & {\nTelephony?: TelephonyChannelSubtypeConfig\nSms?: SmsChannelSubtypeConfig\nEmail?: EmailChannelSubtypeConfig\n})\nexport type ChannelSubtypeConfig1 = {\n[k: string]: unknown\n}\n/**\n * Allocates outbound capacity for the specific channel of this campaign between multiple active campaigns\n */\nexport type Capacity = number\n/**\n * The queue for the call\n */\nexport type QueueId = string\n/**\n * Telephony Outbound Mode\n */\nexport type TelephonyOutboundMode = ({\nProgressiveConfig?: ProgressiveConfig\nPredictiveConfig?: PredictiveConfig\nAgentlessConfig?: AgentlessConfig\nPreviewConfig?: PreviewConfig\n} & TelephonyOutboundMode1)\n/**\n * The bandwidth allocation of a queue resource.\n */\nexport type BandwidthAllocation = number\n/**\n * Timeout duration for a preview contact in seconds\n */\nexport type TimeoutDuration = number\n/**\n * Actions that can performed on a contact by an agent\n */\nexport type AgentAction = \"DISCARD\"\n/**\n * Actions that can be performed by agent during preview phase\n */\nexport type AgentActions = AgentAction[]\nexport type TelephonyOutboundMode1 = {\n[k: string]: unknown\n}\n/**\n * The identifier of the contact flow for the outbound call\n */\nexport type ContactFlowId = string\n/**\n * The phone number associated with the Amazon Connect instance, in E.164 format. If you do not specify a source phone number, you must specify a queue.\n */\nexport type SourcePhoneNumber = string\n/**\n * Arn\n */\nexport type Arn = string\n/**\n * Email address used for Email messages\n */\nexport type EmailAddress = string\n/**\n * The name of the source email address display name\n */\nexport type SourceEmailAddressDisplayName = string\n/**\n * The possible source of the campaign\n */\nexport type Source = ({\nCustomerProfilesSegmentArn?: Arn\nEventTrigger?: EventTrigger\n} & Source1)\nexport type Source1 = {\n[k: string]: unknown\n}\n/**\n * Timestamp with no UTC offset or timezone\n */\nexport type TimeStamp = string\n/**\n * Time duration in ISO 8601 format\n */\nexport type Iso8601Duration = string\n/**\n * Time Zone Id in the IANA format\n */\nexport type TimeZone = string\n/**\n * Local TimeZone Detection method\n */\nexport type LocalTimeZoneDetectionType = (\"ZIP_CODE\" | \"AREA_CODE\")\n/**\n * Local TimeZone Detection method list\n */\nexport type LocalTimeZoneDetection = LocalTimeZoneDetectionType[]\n/**\n * Day of week\n */\nexport type DayOfWeek = (\"MONDAY\" | \"TUESDAY\" | \"WEDNESDAY\" | \"THURSDAY\" | \"FRIDAY\" | \"SATURDAY\" | \"SUNDAY\")\n/**\n * Time in ISO 8601 format, e.g. T23:11\n */\nexport type Iso8601Time = string\n/**\n * List of time range\n */\nexport type TimeRangeList = TimeRange[]\n/**\n * Daily Hours map\n */\nexport type DailyHours = DailyHour[]\n/**\n * Restricted period config\n */\nexport type RestrictedPeriods = ({\nRestrictedPeriodList?: RestrictedPeriodList\n} & RestrictedPeriods1)\n/**\n * Date in ISO 8601 format, e.g. 2024-01-01\n */\nexport type Iso8601Date = string\n/**\n * List of restricted period\n */\nexport type RestrictedPeriodList = RestrictedPeriod[]\nexport type RestrictedPeriods1 = {\n[k: string]: unknown\n}\n/**\n * The communication limit time unit\n */\nexport type CommunicationLimitTimeUnit = \"DAY\"\n/**\n * List of communication limit\n */\nexport type CommunicationLimitList = CommunicationLimit[]\n/**\n * Enumeration of Instance Limits handling in a Campaign\n */\nexport type InstanceLimitsHandling = (\"OPT_IN\" | \"OPT_OUT\")\n\n/**\n * Definition of AWS::ConnectCampaignsV2::Campaign Resource Type\n */\nexport interface _AWS_CONNECTCAMPAIGNSV2_CAMPAIGN {\n/**\n * Amazon Connect Campaign Arn\n */\nArn?: string\nName: CampaignName\nConnectInstanceId: InstanceId\nChannelSubtypeConfig: ChannelSubtypeConfig\nSource?: Source\nConnectCampaignFlowArn?: Arn\nSchedule?: Schedule\nCommunicationTimeConfig?: CommunicationTimeConfig\nCommunicationLimitsOverride?: CommunicationLimitsConfig\n/**\n * One or more tags.\n * \n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * Telephony Channel Subtype config\n */\nexport interface TelephonyChannelSubtypeConfig {\nCapacity?: Capacity\nConnectQueueId?: QueueId\nOutboundMode: TelephonyOutboundMode\nDefaultOutboundConfig: TelephonyOutboundConfig\n}\n/**\n * Progressive config\n */\nexport interface ProgressiveConfig {\nBandwidthAllocation: BandwidthAllocation\n}\n/**\n * Predictive config\n */\nexport interface PredictiveConfig {\nBandwidthAllocation: BandwidthAllocation\n}\n/**\n * Agentless config\n */\nexport interface AgentlessConfig {\n\n}\n/**\n * Preview config\n */\nexport interface PreviewConfig {\nBandwidthAllocation: BandwidthAllocation\nTimeoutConfig: TimeoutConfig\nAgentActions?: AgentActions\n}\n/**\n * Timeout Config for preview contacts\n */\nexport interface TimeoutConfig {\nDurationInSeconds?: TimeoutDuration\n[k: string]: unknown\n}\n/**\n * Default Telephone Outbound config\n */\nexport interface TelephonyOutboundConfig {\nConnectContactFlowId: ContactFlowId\nConnectSourcePhoneNumber?: SourcePhoneNumber\nAnswerMachineDetectionConfig?: AnswerMachineDetectionConfig\n}\n/**\n * The configuration used for answering machine detection during outbound calls\n */\nexport interface AnswerMachineDetectionConfig {\n/**\n * Flag to decided whether outbound calls should have answering machine detection enabled or not\n */\nEnableAnswerMachineDetection: boolean\n/**\n * Enables detection of prompts (e.g., beep after after a voicemail greeting)\n */\nAwaitAnswerMachinePrompt?: boolean\n}\n/**\n * SMS Channel Subtype config\n */\nexport interface SmsChannelSubtypeConfig {\nCapacity?: Capacity\nOutboundMode: SmsOutboundMode\nDefaultOutboundConfig: SmsOutboundConfig\n}\n/**\n * SMS Outbound Mode\n */\nexport interface SmsOutboundMode {\nAgentlessConfig?: AgentlessConfig\n}\n/**\n * Default SMS outbound config\n */\nexport interface SmsOutboundConfig {\nConnectSourcePhoneNumberArn: Arn\nWisdomTemplateArn: Arn\n}\n/**\n * Email Channel Subtype config\n */\nexport interface EmailChannelSubtypeConfig {\nCapacity?: Capacity\nOutboundMode: EmailOutboundMode\nDefaultOutboundConfig: EmailOutboundConfig\n}\n/**\n * Email Outbound Mode\n */\nexport interface EmailOutboundMode {\nAgentlessConfig?: AgentlessConfig\n}\n/**\n * Default SMS outbound config\n */\nexport interface EmailOutboundConfig {\nConnectSourceEmailAddress: EmailAddress\nSourceEmailAddressDisplayName?: SourceEmailAddressDisplayName\nWisdomTemplateArn: Arn\n}\n/**\n * The event trigger of the campaign\n */\nexport interface EventTrigger {\nCustomerProfilesDomainArn?: Arn\n}\n/**\n * Campaign schedule\n */\nexport interface Schedule {\nStartTime: TimeStamp\nEndTime: TimeStamp\nRefreshFrequency?: Iso8601Duration\n}\n/**\n * Campaign communication time config\n */\nexport interface CommunicationTimeConfig {\nLocalTimeZoneConfig: LocalTimeZoneConfig\nTelephony?: TimeWindow\nSms?: TimeWindow\nEmail?: TimeWindow\n}\n/**\n * Local time zone config\n */\nexport interface LocalTimeZoneConfig {\nDefaultTimeZone?: TimeZone\nLocalTimeZoneDetection?: LocalTimeZoneDetection\n}\n/**\n * Time window config\n */\nexport interface TimeWindow {\nOpenHours: OpenHours\nRestrictedPeriods?: RestrictedPeriods\n}\n/**\n * Open Hours config\n */\nexport interface OpenHours {\nDailyHours: DailyHours\n}\n/**\n * Daily Hour\n */\nexport interface DailyHour {\nKey?: DayOfWeek\nValue?: TimeRangeList\n}\n/**\n * Time range in 24 hour format\n */\nexport interface TimeRange {\nStartTime: Iso8601Time\nEndTime: Iso8601Time\n}\n/**\n * Restricted period\n */\nexport interface RestrictedPeriod {\n/**\n * The name of a restricted period\n */\nName?: string\nStartDate: Iso8601Date\nEndDate: Iso8601Date\n}\n/**\n * Communication limits config\n */\nexport interface CommunicationLimitsConfig {\nAllChannelsSubtypes?: CommunicationLimits\nInstanceLimitsHandling?: InstanceLimitsHandling\n}\n/**\n * Communication limits\n */\nexport interface CommunicationLimits {\nCommunicationLimitList?: CommunicationLimitList\n}\n/**\n * Communication Limit\n */\nexport interface CommunicationLimit {\nMaxCountPerRecipient: number\nFrequency: number\nUnit: CommunicationLimitTimeUnit\n}\nexport interface Tag {\n/**\n * The key name of the tag.\n */\nKey: string\n/**\n * The value for the tag.\n */\nValue: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-connectcampaignsv2-campaign.js","sourceRoot":"","sources":["aws-connectcampaignsv2-campaign.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Campaign name\n */\nexport type CampaignName = string\n/**\n * Amazon Connect Instance Id\n */\nexport type InstanceId = string\n/**\n * The possible types of channel subtype config parameters\n */\nexport type ChannelSubtypeConfig = (ChannelSubtypeConfig1 & {\nTelephony?: TelephonyChannelSubtypeConfig\nSms?: SmsChannelSubtypeConfig\nEmail?: EmailChannelSubtypeConfig\n})\nexport type ChannelSubtypeConfig1 = {\n[k: string]: unknown\n}\n/**\n * Allocates outbound capacity for the specific channel of this campaign between multiple active campaigns\n */\nexport type Capacity = number\n/**\n * The queue for the call\n */\nexport type QueueId = string\n/**\n * Telephony Outbound Mode\n */\nexport type TelephonyOutboundMode = ({\nProgressiveConfig?: ProgressiveConfig\nPredictiveConfig?: PredictiveConfig\nAgentlessConfig?: AgentlessConfig\nPreviewConfig?: PreviewConfig\n} & TelephonyOutboundMode1)\n/**\n * The bandwidth allocation of a queue resource.\n */\nexport type BandwidthAllocation = number\n/**\n * Timeout duration for a preview contact in seconds\n */\nexport type TimeoutDuration = number\n/**\n * Actions that can performed on a contact by an agent\n */\nexport type AgentAction = \"DISCARD\"\n/**\n * Actions that can be performed by agent during preview phase\n */\nexport type AgentActions = AgentAction[]\nexport type TelephonyOutboundMode1 = {\n[k: string]: unknown\n}\n/**\n * The identifier of the contact flow for the outbound call\n */\nexport type ContactFlowId = string\n/**\n * The phone number associated with the Amazon Connect instance, in E.164 format. If you do not specify a source phone number, you must specify a queue.\n */\nexport type SourcePhoneNumber = string\n/**\n * Maximum ring time for outbound calls in seconds\n */\nexport type RingTimeout = number\n/**\n * Arn\n */\nexport type Arn = string\n/**\n * Email address used for Email messages\n */\nexport type EmailAddress = string\n/**\n * The name of the source email address display name\n */\nexport type SourceEmailAddressDisplayName = string\n/**\n * The possible source of the campaign\n */\nexport type Source = ({\nCustomerProfilesSegmentArn?: Arn\nEventTrigger?: EventTrigger\n} & Source1)\nexport type Source1 = {\n[k: string]: unknown\n}\n/**\n * Timestamp with no UTC offset or timezone\n */\nexport type TimeStamp = string\n/**\n * Time duration in ISO 8601 format\n */\nexport type Iso8601Duration = string\n/**\n * Time Zone Id in the IANA format\n */\nexport type TimeZone = string\n/**\n * Local TimeZone Detection method\n */\nexport type LocalTimeZoneDetectionType = (\"ZIP_CODE\" | \"AREA_CODE\")\n/**\n * Local TimeZone Detection method list\n */\nexport type LocalTimeZoneDetection = LocalTimeZoneDetectionType[]\n/**\n * Day of week\n */\nexport type DayOfWeek = (\"MONDAY\" | \"TUESDAY\" | \"WEDNESDAY\" | \"THURSDAY\" | \"FRIDAY\" | \"SATURDAY\" | \"SUNDAY\")\n/**\n * Time in ISO 8601 format, e.g. T23:11\n */\nexport type Iso8601Time = string\n/**\n * List of time range\n */\nexport type TimeRangeList = TimeRange[]\n/**\n * Daily Hours map\n */\nexport type DailyHours = DailyHour[]\n/**\n * Restricted period config\n */\nexport type RestrictedPeriods = ({\nRestrictedPeriodList?: RestrictedPeriodList\n} & RestrictedPeriods1)\n/**\n * Date in ISO 8601 format, e.g. 2024-01-01\n */\nexport type Iso8601Date = string\n/**\n * List of restricted period\n */\nexport type RestrictedPeriodList = RestrictedPeriod[]\nexport type RestrictedPeriods1 = {\n[k: string]: unknown\n}\n/**\n * The communication limit time unit\n */\nexport type CommunicationLimitTimeUnit = \"DAY\"\n/**\n * List of communication limit\n */\nexport type CommunicationLimitList = CommunicationLimit[]\n/**\n * Enumeration of Instance Limits handling in a Campaign\n */\nexport type InstanceLimitsHandling = (\"OPT_IN\" | \"OPT_OUT\")\n\n/**\n * Definition of AWS::ConnectCampaignsV2::Campaign Resource Type\n */\nexport interface _AWS_CONNECTCAMPAIGNSV2_CAMPAIGN {\n/**\n * Amazon Connect Campaign Arn\n */\nArn?: string\nName: CampaignName\nConnectInstanceId: InstanceId\nChannelSubtypeConfig: ChannelSubtypeConfig\nSource?: Source\nConnectCampaignFlowArn?: Arn\nSchedule?: Schedule\nCommunicationTimeConfig?: CommunicationTimeConfig\nCommunicationLimitsOverride?: CommunicationLimitsConfig\n/**\n * One or more tags.\n * \n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * Telephony Channel Subtype config\n */\nexport interface TelephonyChannelSubtypeConfig {\nCapacity?: Capacity\nConnectQueueId?: QueueId\nOutboundMode: TelephonyOutboundMode\nDefaultOutboundConfig: TelephonyOutboundConfig\n}\n/**\n * Progressive config\n */\nexport interface ProgressiveConfig {\nBandwidthAllocation: BandwidthAllocation\n}\n/**\n * Predictive config\n */\nexport interface PredictiveConfig {\nBandwidthAllocation: BandwidthAllocation\n}\n/**\n * Agentless config\n */\nexport interface AgentlessConfig {\n\n}\n/**\n * Preview config\n */\nexport interface PreviewConfig {\nBandwidthAllocation: BandwidthAllocation\nTimeoutConfig: TimeoutConfig\nAgentActions?: AgentActions\n}\n/**\n * Timeout Config for preview contacts\n */\nexport interface TimeoutConfig {\nDurationInSeconds?: TimeoutDuration\n[k: string]: unknown\n}\n/**\n * Default Telephone Outbound config\n */\nexport interface TelephonyOutboundConfig {\nConnectContactFlowId: ContactFlowId\nConnectSourcePhoneNumber?: SourcePhoneNumber\nAnswerMachineDetectionConfig?: AnswerMachineDetectionConfig\nRingTimeout?: RingTimeout\n}\n/**\n * The configuration used for answering machine detection during outbound calls\n */\nexport interface AnswerMachineDetectionConfig {\n/**\n * Flag to decided whether outbound calls should have answering machine detection enabled or not\n */\nEnableAnswerMachineDetection: boolean\n/**\n * Enables detection of prompts (e.g., beep after after a voicemail greeting)\n */\nAwaitAnswerMachinePrompt?: boolean\n}\n/**\n * SMS Channel Subtype config\n */\nexport interface SmsChannelSubtypeConfig {\nCapacity?: Capacity\nOutboundMode: SmsOutboundMode\nDefaultOutboundConfig: SmsOutboundConfig\n}\n/**\n * SMS Outbound Mode\n */\nexport interface SmsOutboundMode {\nAgentlessConfig?: AgentlessConfig\n}\n/**\n * Default SMS outbound config\n */\nexport interface SmsOutboundConfig {\nConnectSourcePhoneNumberArn: Arn\nWisdomTemplateArn: Arn\n}\n/**\n * Email Channel Subtype config\n */\nexport interface EmailChannelSubtypeConfig {\nCapacity?: Capacity\nOutboundMode: EmailOutboundMode\nDefaultOutboundConfig: EmailOutboundConfig\n}\n/**\n * Email Outbound Mode\n */\nexport interface EmailOutboundMode {\nAgentlessConfig?: AgentlessConfig\n}\n/**\n * Default SMS outbound config\n */\nexport interface EmailOutboundConfig {\nConnectSourceEmailAddress: EmailAddress\nSourceEmailAddressDisplayName?: SourceEmailAddressDisplayName\nWisdomTemplateArn: Arn\n}\n/**\n * The event trigger of the campaign\n */\nexport interface EventTrigger {\nCustomerProfilesDomainArn?: Arn\n}\n/**\n * Campaign schedule\n */\nexport interface Schedule {\nStartTime: TimeStamp\nEndTime: TimeStamp\nRefreshFrequency?: Iso8601Duration\n}\n/**\n * Campaign communication time config\n */\nexport interface CommunicationTimeConfig {\nLocalTimeZoneConfig: LocalTimeZoneConfig\nTelephony?: TimeWindow\nSms?: TimeWindow\nEmail?: TimeWindow\n}\n/**\n * Local time zone config\n */\nexport interface LocalTimeZoneConfig {\nDefaultTimeZone?: TimeZone\nLocalTimeZoneDetection?: LocalTimeZoneDetection\n}\n/**\n * Time window config\n */\nexport interface TimeWindow {\nOpenHours: OpenHours\nRestrictedPeriods?: RestrictedPeriods\n}\n/**\n * Open Hours config\n */\nexport interface OpenHours {\nDailyHours: DailyHours\n}\n/**\n * Daily Hour\n */\nexport interface DailyHour {\nKey?: DayOfWeek\nValue?: TimeRangeList\n}\n/**\n * Time range in 24 hour format\n */\nexport interface TimeRange {\nStartTime: Iso8601Time\nEndTime: Iso8601Time\n}\n/**\n * Restricted period\n */\nexport interface RestrictedPeriod {\n/**\n * The name of a restricted period\n */\nName?: string\nStartDate: Iso8601Date\nEndDate: Iso8601Date\n}\n/**\n * Communication limits config\n */\nexport interface CommunicationLimitsConfig {\nAllChannelsSubtypes?: CommunicationLimits\nInstanceLimitsHandling?: InstanceLimitsHandling\n}\n/**\n * Communication limits\n */\nexport interface CommunicationLimits {\nCommunicationLimitList?: CommunicationLimitList\n}\n/**\n * Communication Limit\n */\nexport interface CommunicationLimit {\nMaxCountPerRecipient: number\nFrequency: number\nUnit: CommunicationLimitTimeUnit\n}\nexport interface Tag {\n/**\n * The key name of the tag.\n */\nKey: string\n/**\n * The value for the tag.\n */\nValue: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-datazone-connection.d.ts

@@ -1,4 +1,4 @@
-export type ConnectionPropertiesInput = (AthenaProperties | GlueProperties | HyperPodProperties | IamProperties | RedshiftProperties | SparkEmrProperties | AmazonQProperties | SparkGlueProperties | S3Properties);
+export type ConnectionPropertiesInput = (AthenaProperties | GlueProperties | HyperPodProperties | IamProperties | RedshiftProperties | SparkEmrProperties | AmazonQProperties | SparkGlueProperties | S3Properties | MlflowProperties);
 /**
  * Glue Connection Type
  */
@@ -316,6 +316,7 @@ export interface SparkEmrPropertiesInput {
     PythonVirtualEnv?: string;
     RuntimeRole?: string;
     TrustedCertificatesS3Uri?: string;
+    ManagedEndpointArn?: string;
 }
 export interface AmazonQProperties {
     AmazonQProperties: AmazonQPropertiesInput;
@@ -372,3 +373,15 @@ export interface S3PropertiesInput {
      */
     S3AccessGrantLocationId?: string;
 }
+export interface MlflowProperties {
+    MlflowProperties: MlflowPropertiesInput;
+}
+/**
+ * MLflow Properties Input
+ */
+export interface MlflowPropertiesInput {
+    /**
+     * The ARN of the MLflow tracking server
+     */
+    TrackingServerArn?: string;
+}

package/lib/types/cfn-resource-types/aws-datazone-connection.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-datazone-connection.js","sourceRoot":"","sources":["aws-datazone-connection.ts"],"names":[],"mappings":"","sourcesContent":["export type ConnectionPropertiesInput = (AthenaProperties | GlueProperties | HyperPodProperties | IamProperties | RedshiftProperties | SparkEmrProperties | AmazonQProperties | SparkGlueProperties | S3Properties)\n/**\n * Glue Connection Type\n */\nexport type GlueConnectionType = string\n/**\n * Compute Environments\n */\nexport type ComputeEnvironments = string\n/**\n * Authentication Type\n */\nexport type AuthenticationType = (\"BASIC\" | \"OAUTH2\" | \"CUSTOM\")\n/**\n * OAuth2 Grant Type\n */\nexport type OAuth2GrantType = (\"AUTHORIZATION_CODE\" | \"CLIENT_CREDENTIALS\" | \"JWT_BEARER\")\nexport type RedshiftStorageProperties = (ClusterName | WorkgroupName)\nexport type RedshiftCredentials = (SecretArn | UsernamePassword)\n/**\n * Connection Type\n */\nexport type ConnectionType = string\n\n/**\n * Connections enables users to connect their DataZone resources (domains, projects, and environments) to external resources/services (data, compute, etc)\n */\nexport interface _AWS_DATAZONE_CONNECTION {\nAwsLocation?: AwsLocation\n/**\n * The ID of the connection.\n */\nConnectionId?: string\n/**\n * The description of the connection.\n */\nDescription?: string\n/**\n * The ID of the domain in which the connection is created.\n */\nDomainId?: string\n/**\n * The identifier of the domain in which the connection is created.\n */\nDomainIdentifier: string\n/**\n * The ID of the domain unit in which the connection is created.\n */\nDomainUnitId?: string\n/**\n * Specifies whether the trusted identity propagation is enabled\n */\nEnableTrustedIdentityPropagation?: boolean\n/**\n * The ID of the environment in which the connection is created.\n */\nEnvironmentId?: string\n/**\n * The identifier of the environment in which the connection is created.\n */\nEnvironmentIdentifier?: string\n/**\n * The identifier of the project in which the connection should be created. If \n */\nProjectIdentifier?: string\n/**\n * The role of the user in the environment.\n */\nEnvironmentUserRole?: string\n/**\n * The name of the connection.\n */\nName: string\n/**\n * The ID of the project in which the connection is created.\n */\nProjectId?: string\nProps?: ConnectionPropertiesInput\nType?: ConnectionType\n/**\n * The scope of the connection.\n */\nScope?: (\"DOMAIN\" | \"PROJECT\")\n}\n/**\n * AWS Location of project\n */\nexport interface AwsLocation {\nAccessRole?: string\nAwsAccountId?: string\nAwsRegion?: string\nIamConnectionId?: string\n}\nexport interface AthenaProperties {\nAthenaProperties: AthenaPropertiesInput\n}\n/**\n * Athena Properties Input\n */\nexport interface AthenaPropertiesInput {\nWorkgroupName: string\n}\nexport interface GlueProperties {\nGlueProperties: GluePropertiesInput\n}\n/**\n * Glue Properties Input\n */\nexport interface GluePropertiesInput {\nGlueConnectionInput?: GlueConnectionInput\n}\n/**\n * Glue Connection Input\n */\nexport interface GlueConnectionInput {\nConnectionProperties?: ConnectionProperties\nPhysicalConnectionRequirements?: PhysicalConnectionRequirements\nName?: string\nDescription?: string\nConnectionType?: GlueConnectionType\nMatchCriteria?: string\nValidateCredentials?: boolean\n/**\n * @minItems 1\n * @maxItems 50\n */\nValidateForComputeEnvironments?: ComputeEnvironments[]\nSparkProperties?: PropertyMap\nAthenaProperties?: PropertyMap\nPythonProperties?: PropertyMap\nAuthenticationConfiguration?: AuthenticationConfigurationInput\n}\n/**\n * Connection Properties\n */\nexport interface ConnectionProperties {\n/**\n * This interface was referenced by `ConnectionProperties`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\n/**\n * Physical Connection Requirements\n */\nexport interface PhysicalConnectionRequirements {\nSubnetId?: string\n/**\n * @minItems 1\n * @maxItems 50\n */\nSubnetIdList?: string[]\n/**\n * @minItems 0\n * @maxItems 50\n */\nSecurityGroupIdList?: string[]\nAvailabilityZone?: string\n}\n/**\n * Property Map\n */\nexport interface PropertyMap {\n/**\n * This interface was referenced by `PropertyMap`'s JSON-Schema definition\n * via the `patternProperty` \"^[\\u0020-\\uD7FF\\uE000-\\uFFFF\\t]*$\".\n */\n[k: string]: string\n}\n/**\n * Authentication Configuration Input\n */\nexport interface AuthenticationConfigurationInput {\nAuthenticationType?: AuthenticationType\nOAuth2Properties?: OAuth2Properties\nSecretArn?: string\nKmsKeyArn?: string\nBasicAuthenticationCredentials?: BasicAuthenticationCredentials\nCustomAuthenticationCredentials?: CredentialMap\n}\n/**\n * OAuth2 Properties\n */\nexport interface OAuth2Properties {\nOAuth2GrantType?: OAuth2GrantType\nOAuth2ClientApplication?: OAuth2ClientApplication\nTokenUrl?: string\nTokenUrlParametersMap?: TokenUrlParametersMap\nAuthorizationCodeProperties?: AuthorizationCodeProperties\nOAuth2Credentials?: GlueOAuth2Credentials\n}\n/**\n * OAuth2 Client Application\n */\nexport interface OAuth2ClientApplication {\nUserManagedClientApplicationClientId?: string\nAWSManagedClientApplicationReference?: string\n}\n/**\n * The token URL parameters.\n */\nexport interface TokenUrlParametersMap {\n/**\n * This interface was referenced by `TokenUrlParametersMap`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\n/**\n * Authorization Code Properties\n */\nexport interface AuthorizationCodeProperties {\nAuthorizationCode?: string\nRedirectUri?: string\n}\n/**\n * Glue OAuth2 Credentials\n */\nexport interface GlueOAuth2Credentials {\nUserManagedClientApplicationClientSecret?: string\nAccessToken?: string\nRefreshToken?: string\nJwtToken?: string\n}\n/**\n * Basic Authentication Credentials\n */\nexport interface BasicAuthenticationCredentials {\nUserName?: string\nPassword?: string\n}\n/**\n * Credential Map\n */\nexport interface CredentialMap {\n/**\n * This interface was referenced by `CredentialMap`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\nexport interface HyperPodProperties {\nHyperPodProperties: HyperPodPropertiesInput\n}\n/**\n * HyperPod Properties Input\n */\nexport interface HyperPodPropertiesInput {\nClusterName: string\n}\nexport interface IamProperties {\nIamProperties: IamPropertiesInput\n}\n/**\n * IAM Properties Input\n */\nexport interface IamPropertiesInput {\nGlueLineageSyncEnabled?: boolean\n}\nexport interface RedshiftProperties {\nRedshiftProperties: RedshiftPropertiesInput\n}\n/**\n * Redshift Properties Input\n */\nexport interface RedshiftPropertiesInput {\nStorage?: RedshiftStorageProperties\nDatabaseName?: string\nHost?: string\nPort?: number\nCredentials?: RedshiftCredentials\nLineageSync?: RedshiftLineageSyncConfigurationInput\n}\nexport interface ClusterName {\nClusterName: string\n}\nexport interface WorkgroupName {\nWorkgroupName: string\n}\nexport interface SecretArn {\nSecretArn: string\n}\nexport interface UsernamePassword {\nUsernamePassword: UsernamePassword1\n}\n/**\n * The username and password to be used for authentication.\n */\nexport interface UsernamePassword1 {\nPassword: string\nUsername: string\n}\n/**\n * Redshift Lineage Sync Configuration Input\n */\nexport interface RedshiftLineageSyncConfigurationInput {\nEnabled?: boolean\nSchedule?: LineageSyncSchedule\n}\n/**\n * Lineage Sync Schedule\n */\nexport interface LineageSyncSchedule {\nSchedule?: string\n}\nexport interface SparkEmrProperties {\nSparkEmrProperties: SparkEmrPropertiesInput\n}\n/**\n * Spark EMR Properties Input.\n */\nexport interface SparkEmrPropertiesInput {\nComputeArn?: string\nInstanceProfileArn?: string\nJavaVirtualEnv?: string\nLogUri?: string\nPythonVirtualEnv?: string\nRuntimeRole?: string\nTrustedCertificatesS3Uri?: string\n}\nexport interface AmazonQProperties {\nAmazonQProperties: AmazonQPropertiesInput\n}\n/**\n * Amazon Q properties of the connection.\n */\nexport interface AmazonQPropertiesInput {\n/**\n * Specifies whether Amazon Q is enabled for the connection\n */\nIsEnabled?: boolean\n/**\n * The authentication mode of the connection's AmazonQ properties\n */\nAuthMode?: string\nProfileArn?: string\n}\nexport interface SparkGlueProperties {\nSparkGlueProperties: SparkGluePropertiesInput\n}\n/**\n * Spark Glue Properties Input.\n */\nexport interface SparkGluePropertiesInput {\nAdditionalArgs?: SparkGlueArgs\nGlueConnectionName?: string\nGlueVersion?: string\nIdleTimeout?: number\nJavaVirtualEnv?: string\nNumberOfWorkers?: number\nPythonVirtualEnv?: string\nWorkerType?: string\n}\n/**\n * Spark Glue Args.\n */\nexport interface SparkGlueArgs {\nConnection?: string\n}\nexport interface S3Properties {\nS3Properties: S3PropertiesInput\n}\n/**\n * S3 Properties Input\n */\nexport interface S3PropertiesInput {\n/**\n * The Amazon S3 URI that's part of the Amazon S3 properties of a connection.\n */\nS3Uri: string\n/**\n * The Amazon S3 Access Grant location ID that's part of the Amazon S3 properties of a connection.\n */\nS3AccessGrantLocationId?: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-datazone-connection.js","sourceRoot":"","sources":["aws-datazone-connection.ts"],"names":[],"mappings":"","sourcesContent":["export type ConnectionPropertiesInput = (AthenaProperties | GlueProperties | HyperPodProperties | IamProperties | RedshiftProperties | SparkEmrProperties | AmazonQProperties | SparkGlueProperties | S3Properties | MlflowProperties)\n/**\n * Glue Connection Type\n */\nexport type GlueConnectionType = string\n/**\n * Compute Environments\n */\nexport type ComputeEnvironments = string\n/**\n * Authentication Type\n */\nexport type AuthenticationType = (\"BASIC\" | \"OAUTH2\" | \"CUSTOM\")\n/**\n * OAuth2 Grant Type\n */\nexport type OAuth2GrantType = (\"AUTHORIZATION_CODE\" | \"CLIENT_CREDENTIALS\" | \"JWT_BEARER\")\nexport type RedshiftStorageProperties = (ClusterName | WorkgroupName)\nexport type RedshiftCredentials = (SecretArn | UsernamePassword)\n/**\n * Connection Type\n */\nexport type ConnectionType = string\n\n/**\n * Connections enables users to connect their DataZone resources (domains, projects, and environments) to external resources/services (data, compute, etc)\n */\nexport interface _AWS_DATAZONE_CONNECTION {\nAwsLocation?: AwsLocation\n/**\n * The ID of the connection.\n */\nConnectionId?: string\n/**\n * The description of the connection.\n */\nDescription?: string\n/**\n * The ID of the domain in which the connection is created.\n */\nDomainId?: string\n/**\n * The identifier of the domain in which the connection is created.\n */\nDomainIdentifier: string\n/**\n * The ID of the domain unit in which the connection is created.\n */\nDomainUnitId?: string\n/**\n * Specifies whether the trusted identity propagation is enabled\n */\nEnableTrustedIdentityPropagation?: boolean\n/**\n * The ID of the environment in which the connection is created.\n */\nEnvironmentId?: string\n/**\n * The identifier of the environment in which the connection is created.\n */\nEnvironmentIdentifier?: string\n/**\n * The identifier of the project in which the connection should be created. If \n */\nProjectIdentifier?: string\n/**\n * The role of the user in the environment.\n */\nEnvironmentUserRole?: string\n/**\n * The name of the connection.\n */\nName: string\n/**\n * The ID of the project in which the connection is created.\n */\nProjectId?: string\nProps?: ConnectionPropertiesInput\nType?: ConnectionType\n/**\n * The scope of the connection.\n */\nScope?: (\"DOMAIN\" | \"PROJECT\")\n}\n/**\n * AWS Location of project\n */\nexport interface AwsLocation {\nAccessRole?: string\nAwsAccountId?: string\nAwsRegion?: string\nIamConnectionId?: string\n}\nexport interface AthenaProperties {\nAthenaProperties: AthenaPropertiesInput\n}\n/**\n * Athena Properties Input\n */\nexport interface AthenaPropertiesInput {\nWorkgroupName: string\n}\nexport interface GlueProperties {\nGlueProperties: GluePropertiesInput\n}\n/**\n * Glue Properties Input\n */\nexport interface GluePropertiesInput {\nGlueConnectionInput?: GlueConnectionInput\n}\n/**\n * Glue Connection Input\n */\nexport interface GlueConnectionInput {\nConnectionProperties?: ConnectionProperties\nPhysicalConnectionRequirements?: PhysicalConnectionRequirements\nName?: string\nDescription?: string\nConnectionType?: GlueConnectionType\nMatchCriteria?: string\nValidateCredentials?: boolean\n/**\n * @minItems 1\n * @maxItems 50\n */\nValidateForComputeEnvironments?: ComputeEnvironments[]\nSparkProperties?: PropertyMap\nAthenaProperties?: PropertyMap\nPythonProperties?: PropertyMap\nAuthenticationConfiguration?: AuthenticationConfigurationInput\n}\n/**\n * Connection Properties\n */\nexport interface ConnectionProperties {\n/**\n * This interface was referenced by `ConnectionProperties`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\n/**\n * Physical Connection Requirements\n */\nexport interface PhysicalConnectionRequirements {\nSubnetId?: string\n/**\n * @minItems 1\n * @maxItems 50\n */\nSubnetIdList?: string[]\n/**\n * @minItems 0\n * @maxItems 50\n */\nSecurityGroupIdList?: string[]\nAvailabilityZone?: string\n}\n/**\n * Property Map\n */\nexport interface PropertyMap {\n/**\n * This interface was referenced by `PropertyMap`'s JSON-Schema definition\n * via the `patternProperty` \"^[\\u0020-\\uD7FF\\uE000-\\uFFFF\\t]*$\".\n */\n[k: string]: string\n}\n/**\n * Authentication Configuration Input\n */\nexport interface AuthenticationConfigurationInput {\nAuthenticationType?: AuthenticationType\nOAuth2Properties?: OAuth2Properties\nSecretArn?: string\nKmsKeyArn?: string\nBasicAuthenticationCredentials?: BasicAuthenticationCredentials\nCustomAuthenticationCredentials?: CredentialMap\n}\n/**\n * OAuth2 Properties\n */\nexport interface OAuth2Properties {\nOAuth2GrantType?: OAuth2GrantType\nOAuth2ClientApplication?: OAuth2ClientApplication\nTokenUrl?: string\nTokenUrlParametersMap?: TokenUrlParametersMap\nAuthorizationCodeProperties?: AuthorizationCodeProperties\nOAuth2Credentials?: GlueOAuth2Credentials\n}\n/**\n * OAuth2 Client Application\n */\nexport interface OAuth2ClientApplication {\nUserManagedClientApplicationClientId?: string\nAWSManagedClientApplicationReference?: string\n}\n/**\n * The token URL parameters.\n */\nexport interface TokenUrlParametersMap {\n/**\n * This interface was referenced by `TokenUrlParametersMap`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\n/**\n * Authorization Code Properties\n */\nexport interface AuthorizationCodeProperties {\nAuthorizationCode?: string\nRedirectUri?: string\n}\n/**\n * Glue OAuth2 Credentials\n */\nexport interface GlueOAuth2Credentials {\nUserManagedClientApplicationClientSecret?: string\nAccessToken?: string\nRefreshToken?: string\nJwtToken?: string\n}\n/**\n * Basic Authentication Credentials\n */\nexport interface BasicAuthenticationCredentials {\nUserName?: string\nPassword?: string\n}\n/**\n * Credential Map\n */\nexport interface CredentialMap {\n/**\n * This interface was referenced by `CredentialMap`'s JSON-Schema definition\n * via the `patternProperty` \".+\".\n */\n[k: string]: string\n}\nexport interface HyperPodProperties {\nHyperPodProperties: HyperPodPropertiesInput\n}\n/**\n * HyperPod Properties Input\n */\nexport interface HyperPodPropertiesInput {\nClusterName: string\n}\nexport interface IamProperties {\nIamProperties: IamPropertiesInput\n}\n/**\n * IAM Properties Input\n */\nexport interface IamPropertiesInput {\nGlueLineageSyncEnabled?: boolean\n}\nexport interface RedshiftProperties {\nRedshiftProperties: RedshiftPropertiesInput\n}\n/**\n * Redshift Properties Input\n */\nexport interface RedshiftPropertiesInput {\nStorage?: RedshiftStorageProperties\nDatabaseName?: string\nHost?: string\nPort?: number\nCredentials?: RedshiftCredentials\nLineageSync?: RedshiftLineageSyncConfigurationInput\n}\nexport interface ClusterName {\nClusterName: string\n}\nexport interface WorkgroupName {\nWorkgroupName: string\n}\nexport interface SecretArn {\nSecretArn: string\n}\nexport interface UsernamePassword {\nUsernamePassword: UsernamePassword1\n}\n/**\n * The username and password to be used for authentication.\n */\nexport interface UsernamePassword1 {\nPassword: string\nUsername: string\n}\n/**\n * Redshift Lineage Sync Configuration Input\n */\nexport interface RedshiftLineageSyncConfigurationInput {\nEnabled?: boolean\nSchedule?: LineageSyncSchedule\n}\n/**\n * Lineage Sync Schedule\n */\nexport interface LineageSyncSchedule {\nSchedule?: string\n}\nexport interface SparkEmrProperties {\nSparkEmrProperties: SparkEmrPropertiesInput\n}\n/**\n * Spark EMR Properties Input.\n */\nexport interface SparkEmrPropertiesInput {\nComputeArn?: string\nInstanceProfileArn?: string\nJavaVirtualEnv?: string\nLogUri?: string\nPythonVirtualEnv?: string\nRuntimeRole?: string\nTrustedCertificatesS3Uri?: string\nManagedEndpointArn?: string\n}\nexport interface AmazonQProperties {\nAmazonQProperties: AmazonQPropertiesInput\n}\n/**\n * Amazon Q properties of the connection.\n */\nexport interface AmazonQPropertiesInput {\n/**\n * Specifies whether Amazon Q is enabled for the connection\n */\nIsEnabled?: boolean\n/**\n * The authentication mode of the connection's AmazonQ properties\n */\nAuthMode?: string\nProfileArn?: string\n}\nexport interface SparkGlueProperties {\nSparkGlueProperties: SparkGluePropertiesInput\n}\n/**\n * Spark Glue Properties Input.\n */\nexport interface SparkGluePropertiesInput {\nAdditionalArgs?: SparkGlueArgs\nGlueConnectionName?: string\nGlueVersion?: string\nIdleTimeout?: number\nJavaVirtualEnv?: string\nNumberOfWorkers?: number\nPythonVirtualEnv?: string\nWorkerType?: string\n}\n/**\n * Spark Glue Args.\n */\nexport interface SparkGlueArgs {\nConnection?: string\n}\nexport interface S3Properties {\nS3Properties: S3PropertiesInput\n}\n/**\n * S3 Properties Input\n */\nexport interface S3PropertiesInput {\n/**\n * The Amazon S3 URI that's part of the Amazon S3 properties of a connection.\n */\nS3Uri: string\n/**\n * The Amazon S3 Access Grant location ID that's part of the Amazon S3 properties of a connection.\n */\nS3AccessGrantLocationId?: string\n}\nexport interface MlflowProperties {\nMlflowProperties: MlflowPropertiesInput\n}\n/**\n * MLflow Properties Input\n */\nexport interface MlflowPropertiesInput {\n/**\n * The ARN of the MLflow tracking server\n */\nTrackingServerArn?: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-devopsagent-association.d.ts

@@ -34,6 +34,10 @@ export type AWSResourceList = AWSResource[];
  * List of AWS tags as key-value pairs
  */
 export type AWSTagList = KeyValuePair[];
+/**
+ * The unique identifier of the association
+ */
+export type AssociationId = string;
 /**
  * Resource Type definition for AWS::DevOpsAgent::Association defining how the AgentSpace interacts with external services like GitHub, Slack, AWS accounts, and others.
  */
@@ -59,6 +63,10 @@ export interface _AWS_DEVOPSAGENT_ASSOCIATION {
      * The timestamp when the association was last updated
      */
     UpdatedAt?: string;
+    /**
+     * Set of linked association IDs for parent-child relationships
+     */
+    LinkedAssociationIds?: AssociationId[];
 }
 /**
  * AWS association for 'source' account

package/lib/types/cfn-resource-types/aws-devopsagent-association.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-devopsagent-association.js","sourceRoot":"","sources":["aws-devopsagent-association.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The configuration that directs how AgentSpace interacts with the given service\n */\nexport type ServiceConfiguration = ({\nSourceAws: SourceAwsConfiguration\n} | {\nAws: AWSConfiguration\n} | {\nGitHub: GitHubConfiguration\n} | {\nSlack: SlackConfiguration\n} | {\nDynatrace: DynatraceConfiguration\n} | {\nServiceNow: ServiceNowConfiguration\n} | {\nMCPServer: MCPServerConfiguration\n} | {\nGitLab: GitLabConfiguration\n} | {\nMCPServerDatadog: MCPServerDatadogConfiguration\n} | {\nMCPServerSplunk: MCPServerSplunkConfiguration\n} | {\nMCPServerNewRelic: MCPServerNewRelicConfiguration\n} | {\nEventChannel: EventChannelConfiguration\n})\n/**\n * List of AWS resources\n */\nexport type AWSResourceList = AWSResource[]\n/**\n * List of AWS tags as key-value pairs\n */\nexport type AWSTagList = KeyValuePair[]\n\n/**\n * Resource Type definition for AWS::DevOpsAgent::Association defining how the AgentSpace interacts with external services like GitHub, Slack, AWS accounts, and others.\n */\nexport interface _AWS_DEVOPSAGENT_ASSOCIATION {\n/**\n * The unique identifier of the AgentSpace\n */\nAgentSpaceId: string\n/**\n * The unique identifier of the association\n */\nAssociationId?: string\n/**\n * The identifier for the associated service\n */\nServiceId: string\nConfiguration: ServiceConfiguration\n/**\n * The timestamp when the association was created\n */\nCreatedAt?: string\n/**\n * The timestamp when the association was last updated\n */\nUpdatedAt?: string\n}\n/**\n * AWS association for 'source' account\n */\nexport interface SourceAwsConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'source' for DevOpsAgent monitoring\n */\nAccountType: \"source\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * AWS resource definition\n */\nexport interface AWSResource {\n/**\n * Resource type\n */\nResourceType?: (\"AWS::CloudFormation::Stack\" | \"AWS::ECR::Repository\" | \"AWS::S3::Bucket\" | \"AWS::S3::Object\")\n/**\n * The Amazon Resource Name (ARN) of the resource\n */\nResourceArn: string\n/**\n * Additional metadata for the resource\n */\nResourceMetadata?: {\n[k: string]: unknown\n}\n}\n/**\n * A key-value pair for tags\n */\nexport interface KeyValuePair {\nKey: string\nValue: string\n}\n/**\n * AWS association for 'monitor' account\n */\nexport interface AWSConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'monitor' for DevOpsAgent monitoring\n */\nAccountType: \"monitor\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * GitHub repository integration configuration\n */\nexport interface GitHubConfiguration {\n/**\n * Associated Github repo name\n */\nRepoName: string\n/**\n * Associated Github repo ID\n */\nRepoId: string\n/**\n * Repository owner\n */\nOwner: string\n/**\n * Type of repository owner\n */\nOwnerType: (\"organization\" | \"user\")\n}\n/**\n * Slack workspace integration configuration\n */\nexport interface SlackConfiguration {\n/**\n * Associated Slack workspace ID\n */\nWorkspaceId: string\n/**\n * Associated Slack workspace name\n */\nWorkspaceName: string\nTransmissionTarget: SlackTransmissionTarget\n}\n/**\n * Transmission targets for agent notifications\n */\nexport interface SlackTransmissionTarget {\nIncidentResponseTarget: SlackChannel\n}\n/**\n * Destination for IncidentResponse agent.\n */\nexport interface SlackChannel {\n/**\n * Slack channel name\n */\nChannelName?: string\n/**\n * Slack channel ID\n */\nChannelId: string\n}\n/**\n * Dynatrace monitoring configuration\n */\nexport interface DynatraceConfiguration {\n/**\n * Dynatrace environment id\n */\nEnvId: string\n/**\n * List of Dynatrace resources to monitor\n */\nResources?: string[]\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * ServiceNow integration configuration\n */\nexport interface ServiceNowConfiguration {\n/**\n * ServiceNow instance ID\n */\nInstanceId?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * MCP server configuration\n */\nexport interface MCPServerConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * List of MCP tools that can be used with the association\n */\nTools: string[]\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * GitLab project integration configuration\n */\nexport interface GitLabConfiguration {\n/**\n * GitLab numeric project ID\n */\nProjectId: string\n/**\n * Full GitLab project path (e.g., namespace/project-name)\n */\nProjectPath: string\n/**\n * GitLab instance identifier\n */\nInstanceIdentifier?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Datadog MCP server configuration\n */\nexport interface MCPServerDatadogConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Splunk MCP server configuration\n */\nexport interface MCPServerSplunkConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * NewRelic MCP server configuration\n */\nexport interface MCPServerNewRelicConfiguration {\n/**\n * New Relic Account ID\n */\nAccountId: string\n/**\n * MCP server endpoint URL (e.g., https://mcp.newrelic.com/mcp/)\n */\nEndpoint: string\n}\n/**\n * EventChannelconfiguration\n */\nexport interface EventChannelConfiguration {\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-devopsagent-association.js","sourceRoot":"","sources":["aws-devopsagent-association.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The configuration that directs how AgentSpace interacts with the given service\n */\nexport type ServiceConfiguration = ({\nSourceAws: SourceAwsConfiguration\n} | {\nAws: AWSConfiguration\n} | {\nGitHub: GitHubConfiguration\n} | {\nSlack: SlackConfiguration\n} | {\nDynatrace: DynatraceConfiguration\n} | {\nServiceNow: ServiceNowConfiguration\n} | {\nMCPServer: MCPServerConfiguration\n} | {\nGitLab: GitLabConfiguration\n} | {\nMCPServerDatadog: MCPServerDatadogConfiguration\n} | {\nMCPServerSplunk: MCPServerSplunkConfiguration\n} | {\nMCPServerNewRelic: MCPServerNewRelicConfiguration\n} | {\nEventChannel: EventChannelConfiguration\n})\n/**\n * List of AWS resources\n */\nexport type AWSResourceList = AWSResource[]\n/**\n * List of AWS tags as key-value pairs\n */\nexport type AWSTagList = KeyValuePair[]\n/**\n * The unique identifier of the association\n */\nexport type AssociationId = string\n\n/**\n * Resource Type definition for AWS::DevOpsAgent::Association defining how the AgentSpace interacts with external services like GitHub, Slack, AWS accounts, and others.\n */\nexport interface _AWS_DEVOPSAGENT_ASSOCIATION {\n/**\n * The unique identifier of the AgentSpace\n */\nAgentSpaceId: string\n/**\n * The unique identifier of the association\n */\nAssociationId?: string\n/**\n * The identifier for the associated service\n */\nServiceId: string\nConfiguration: ServiceConfiguration\n/**\n * The timestamp when the association was created\n */\nCreatedAt?: string\n/**\n * The timestamp when the association was last updated\n */\nUpdatedAt?: string\n/**\n * Set of linked association IDs for parent-child relationships\n */\nLinkedAssociationIds?: AssociationId[]\n}\n/**\n * AWS association for 'source' account\n */\nexport interface SourceAwsConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'source' for DevOpsAgent monitoring\n */\nAccountType: \"source\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * AWS resource definition\n */\nexport interface AWSResource {\n/**\n * Resource type\n */\nResourceType?: (\"AWS::CloudFormation::Stack\" | \"AWS::ECR::Repository\" | \"AWS::S3::Bucket\" | \"AWS::S3::Object\")\n/**\n * The Amazon Resource Name (ARN) of the resource\n */\nResourceArn: string\n/**\n * Additional metadata for the resource\n */\nResourceMetadata?: {\n[k: string]: unknown\n}\n}\n/**\n * A key-value pair for tags\n */\nexport interface KeyValuePair {\nKey: string\nValue: string\n}\n/**\n * AWS association for 'monitor' account\n */\nexport interface AWSConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'monitor' for DevOpsAgent monitoring\n */\nAccountType: \"monitor\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * GitHub repository integration configuration\n */\nexport interface GitHubConfiguration {\n/**\n * Associated Github repo name\n */\nRepoName: string\n/**\n * Associated Github repo ID\n */\nRepoId: string\n/**\n * Repository owner\n */\nOwner: string\n/**\n * Type of repository owner\n */\nOwnerType: (\"organization\" | \"user\")\n}\n/**\n * Slack workspace integration configuration\n */\nexport interface SlackConfiguration {\n/**\n * Associated Slack workspace ID\n */\nWorkspaceId: string\n/**\n * Associated Slack workspace name\n */\nWorkspaceName: string\nTransmissionTarget: SlackTransmissionTarget\n}\n/**\n * Transmission targets for agent notifications\n */\nexport interface SlackTransmissionTarget {\nIncidentResponseTarget: SlackChannel\n}\n/**\n * Destination for IncidentResponse agent.\n */\nexport interface SlackChannel {\n/**\n * Slack channel name\n */\nChannelName?: string\n/**\n * Slack channel ID\n */\nChannelId: string\n}\n/**\n * Dynatrace monitoring configuration\n */\nexport interface DynatraceConfiguration {\n/**\n * Dynatrace environment id\n */\nEnvId: string\n/**\n * List of Dynatrace resources to monitor\n */\nResources?: string[]\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * ServiceNow integration configuration\n */\nexport interface ServiceNowConfiguration {\n/**\n * ServiceNow instance ID\n */\nInstanceId?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * MCP server configuration\n */\nexport interface MCPServerConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * List of MCP tools that can be used with the association\n */\nTools: string[]\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * GitLab project integration configuration\n */\nexport interface GitLabConfiguration {\n/**\n * GitLab numeric project ID\n */\nProjectId: string\n/**\n * Full GitLab project path (e.g., namespace/project-name)\n */\nProjectPath: string\n/**\n * GitLab instance identifier\n */\nInstanceIdentifier?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Datadog MCP server configuration\n */\nexport interface MCPServerDatadogConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Splunk MCP server configuration\n */\nexport interface MCPServerSplunkConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * NewRelic MCP server configuration\n */\nexport interface MCPServerNewRelicConfiguration {\n/**\n * New Relic Account ID\n */\nAccountId: string\n/**\n * MCP server endpoint URL (e.g., https://mcp.newrelic.com/mcp/)\n */\nEndpoint: string\n}\n/**\n * EventChannelconfiguration\n */\nexport interface EventChannelConfiguration {\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n"]}

package/lib/types/cfn-resource-types/aws-dsql-cluster.d.ts

@@ -62,6 +62,10 @@ export interface _AWS_DSQL_CLUSTER {
      * The DSQL cluster endpoint.
      */
     Endpoint?: string;
+    /**
+     * The DSQL cluster VPC endpoint.
+     */
+    VpcEndpoint?: string;
     /**
      * The version number of the cluster's resource based policy
      */

package/lib/types/cfn-resource-types/aws-dsql-cluster.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/cfn-resource-types/aws-ec2-ec2fleet.d.ts

@@ -109,6 +109,7 @@ export interface EbsBlockDevice {
 }
 export interface InstanceRequirementsRequest {
     InstanceGenerations?: ("current" | "previous")[];
+    RequireEncryptionInTransit?: boolean;
     MemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest;
     AcceleratorTypes?: ("gpu" | "fpga" | "inference" | "media")[];
     VCpuCount?: VCpuCountRangeRequest;

package/lib/types/cfn-resource-types/aws-ec2-ec2fleet.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-ec2fleet.js","sourceRoot":"","sources":["aws-ec2-ec2fleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::EC2Fleet\n */\nexport interface _AWS_EC2_EC2FLEET {\nContext?: string\nTargetCapacitySpecification: TargetCapacitySpecificationRequest\nOnDemandOptions?: OnDemandOptionsRequest\nExcessCapacityTerminationPolicy?: (\"termination\" | \"no-termination\")\nTagSpecifications?: TagSpecification[]\nSpotOptions?: SpotOptionsRequest\n/**\n * @maxItems 50\n */\nLaunchTemplateConfigs: FleetLaunchTemplateConfigRequest[]\nTerminateInstancesWithExpiration?: boolean\nValidUntil?: string\nType?: (\"maintain\" | \"request\" | \"instant\")\nFleetId?: string\nValidFrom?: string\nReplaceUnhealthyInstances?: boolean\n}\nexport interface TargetCapacitySpecificationRequest {\nDefaultTargetCapacityType?: (\"on-demand\" | \"spot\")\nTotalTargetCapacity: number\nOnDemandTargetCapacity?: number\nSpotTargetCapacity?: number\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\n}\nexport interface OnDemandOptionsRequest {\nSingleAvailabilityZone?: boolean\nAllocationStrategy?: string\nSingleInstanceType?: boolean\nMinTargetCapacity?: number\nMaxTotalPrice?: string\nCapacityReservationOptions?: CapacityReservationOptionsRequest\n}\nexport interface CapacityReservationOptionsRequest {\nUsageStrategy?: \"use-capacity-reservations-first\"\n}\nexport interface TagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nValue: string\nKey: string\n}\nexport interface SpotOptionsRequest {\nSingleAvailabilityZone?: boolean\nAllocationStrategy?: (\"lowest-price\" | \"lowestPrice\" | \"diversified\" | \"capacityOptimized\" | \"capacity-optimized\" | \"capacityOptimizedPrioritized\" | \"capacity-optimized-prioritized\" | \"priceCapacityOptimized\" | \"price-capacity-optimized\")\nSingleInstanceType?: boolean\nMinTargetCapacity?: number\nMaxTotalPrice?: string\nMaintenanceStrategies?: MaintenanceStrategies\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nInstancePoolsToUseCount?: number\n}\nexport interface MaintenanceStrategies {\nCapacityRebalance?: CapacityRebalance\n}\nexport interface CapacityRebalance {\nTerminationDelay?: number\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\n}\nexport interface FleetLaunchTemplateConfigRequest {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecificationRequest\nOverrides?: FleetLaunchTemplateOverridesRequest[]\n}\nexport interface FleetLaunchTemplateSpecificationRequest {\nLaunchTemplateName?: string\nVersion: string\nLaunchTemplateId?: string\n}\nexport interface FleetLaunchTemplateOverridesRequest {\nWeightedCapacity?: number\nPlacement?: Placement\nPriority?: number\nBlockDeviceMappings?: BlockDeviceMapping[]\nAvailabilityZone?: string\nSubnetId?: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\nMaxPrice?: string\n}\nexport interface Placement {\nGroupName?: string\nTenancy?: string\nSpreadDomain?: string\nPartitionNumber?: number\nAvailabilityZone?: string\nAffinity?: string\nHostId?: string\nHostResourceGroupArn?: string\n}\nexport interface BlockDeviceMapping {\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\nDeviceName?: string\n}\nexport interface EbsBlockDevice {\nSnapshotId?: string\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\nKmsKeyId?: string\nEncrypted?: boolean\nIops?: number\nVolumeSize?: number\nDeleteOnTermination?: boolean\n}\nexport interface InstanceRequirementsRequest {\nInstanceGenerations?: (\"current\" | \"previous\")[]\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nVCpuCount?: VCpuCountRangeRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMemoryMiB?: MemoryMiBRequest\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nExcludedInstanceTypes?: string[]\nAllowedInstanceTypes?: string[]\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nAcceleratorCount?: AcceleratorCountRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nSpotMaxPricePercentageOverLowestPrice?: number\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-ec2fleet.js","sourceRoot":"","sources":["aws-ec2-ec2fleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::EC2Fleet\n */\nexport interface _AWS_EC2_EC2FLEET {\nContext?: string\nTargetCapacitySpecification: TargetCapacitySpecificationRequest\nOnDemandOptions?: OnDemandOptionsRequest\nExcessCapacityTerminationPolicy?: (\"termination\" | \"no-termination\")\nTagSpecifications?: TagSpecification[]\nSpotOptions?: SpotOptionsRequest\n/**\n * @maxItems 50\n */\nLaunchTemplateConfigs: FleetLaunchTemplateConfigRequest[]\nTerminateInstancesWithExpiration?: boolean\nValidUntil?: string\nType?: (\"maintain\" | \"request\" | \"instant\")\nFleetId?: string\nValidFrom?: string\nReplaceUnhealthyInstances?: boolean\n}\nexport interface TargetCapacitySpecificationRequest {\nDefaultTargetCapacityType?: (\"on-demand\" | \"spot\")\nTotalTargetCapacity: number\nOnDemandTargetCapacity?: number\nSpotTargetCapacity?: number\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\n}\nexport interface OnDemandOptionsRequest {\nSingleAvailabilityZone?: boolean\nAllocationStrategy?: string\nSingleInstanceType?: boolean\nMinTargetCapacity?: number\nMaxTotalPrice?: string\nCapacityReservationOptions?: CapacityReservationOptionsRequest\n}\nexport interface CapacityReservationOptionsRequest {\nUsageStrategy?: \"use-capacity-reservations-first\"\n}\nexport interface TagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nValue: string\nKey: string\n}\nexport interface SpotOptionsRequest {\nSingleAvailabilityZone?: boolean\nAllocationStrategy?: (\"lowest-price\" | \"lowestPrice\" | \"diversified\" | \"capacityOptimized\" | \"capacity-optimized\" | \"capacityOptimizedPrioritized\" | \"capacity-optimized-prioritized\" | \"priceCapacityOptimized\" | \"price-capacity-optimized\")\nSingleInstanceType?: boolean\nMinTargetCapacity?: number\nMaxTotalPrice?: string\nMaintenanceStrategies?: MaintenanceStrategies\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nInstancePoolsToUseCount?: number\n}\nexport interface MaintenanceStrategies {\nCapacityRebalance?: CapacityRebalance\n}\nexport interface CapacityRebalance {\nTerminationDelay?: number\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\n}\nexport interface FleetLaunchTemplateConfigRequest {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecificationRequest\nOverrides?: FleetLaunchTemplateOverridesRequest[]\n}\nexport interface FleetLaunchTemplateSpecificationRequest {\nLaunchTemplateName?: string\nVersion: string\nLaunchTemplateId?: string\n}\nexport interface FleetLaunchTemplateOverridesRequest {\nWeightedCapacity?: number\nPlacement?: Placement\nPriority?: number\nBlockDeviceMappings?: BlockDeviceMapping[]\nAvailabilityZone?: string\nSubnetId?: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\nMaxPrice?: string\n}\nexport interface Placement {\nGroupName?: string\nTenancy?: string\nSpreadDomain?: string\nPartitionNumber?: number\nAvailabilityZone?: string\nAffinity?: string\nHostId?: string\nHostResourceGroupArn?: string\n}\nexport interface BlockDeviceMapping {\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\nDeviceName?: string\n}\nexport interface EbsBlockDevice {\nSnapshotId?: string\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\nKmsKeyId?: string\nEncrypted?: boolean\nIops?: number\nVolumeSize?: number\nDeleteOnTermination?: boolean\n}\nexport interface InstanceRequirementsRequest {\nInstanceGenerations?: (\"current\" | \"previous\")[]\nRequireEncryptionInTransit?: boolean\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nVCpuCount?: VCpuCountRangeRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMemoryMiB?: MemoryMiBRequest\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nExcludedInstanceTypes?: string[]\nAllowedInstanceTypes?: string[]\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nAcceleratorCount?: AcceleratorCountRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nSpotMaxPricePercentageOverLowestPrice?: number\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\n"]}

package/lib/types/cfn-resource-types/aws-ec2-spotfleet.d.ts

@@ -4,6 +4,10 @@
 export interface _AWS_EC2_SPOTFLEET {
     SpotFleetRequestConfigData: SpotFleetRequestConfigData;
     Id?: string;
+    /**
+     * The tags to specify in SpotFleetRequestConfigData
+     */
+    Tags?: Tag[];
 }
 export interface SpotFleetRequestConfigData {
     Context?: string;
@@ -58,6 +62,7 @@ export interface LaunchTemplateOverrides {
 }
 export interface InstanceRequirementsRequest {
     InstanceGenerations?: ("current" | "previous")[];
+    RequireEncryptionInTransit?: boolean;
     MemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest;
     AcceleratorTypes?: ("gpu" | "fpga" | "inference" | "media")[];
     VCpuCount?: VCpuCountRangeRequest;

package/lib/types/cfn-resource-types/aws-ec2-spotfleet.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-spotfleet.js","sourceRoot":"","sources":["aws-ec2-spotfleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::SpotFleet\n */\nexport interface _AWS_EC2_SPOTFLEET {\nSpotFleetRequestConfigData: SpotFleetRequestConfigData\nId?: string\n}\nexport interface SpotFleetRequestConfigData {\nContext?: string\nSpotMaxTotalPrice?: string\nExcessCapacityTerminationPolicy?: (\"Default\" | \"NoTermination\" | \"default\" | \"noTermination\")\nTagSpecifications?: SpotFleetTagSpecification[]\nInstancePoolsToUseCount?: number\nLaunchTemplateConfigs?: LaunchTemplateConfig[]\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\nIamFleetRole: string\nSpotMaintenanceStrategies?: SpotMaintenanceStrategies\nTerminateInstancesWithExpiration?: boolean\nValidUntil?: string\nOnDemandMaxTotalPrice?: string\nOnDemandAllocationStrategy?: string\nSpotPrice?: string\nAllocationStrategy?: (\"capacityOptimized\" | \"capacityOptimizedPrioritized\" | \"diversified\" | \"lowestPrice\" | \"priceCapacityOptimized\")\nOnDemandTargetCapacity?: number\nType?: (\"maintain\" | \"request\")\nLaunchSpecifications?: SpotFleetLaunchSpecification[]\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nLoadBalancersConfig?: LoadBalancersConfig\nValidFrom?: string\nReplaceUnhealthyInstances?: boolean\nTargetCapacity: number\n}\nexport interface SpotFleetTagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nValue: string\nKey: string\n}\nexport interface LaunchTemplateConfig {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecification\nOverrides?: LaunchTemplateOverrides[]\n}\nexport interface FleetLaunchTemplateSpecification {\nLaunchTemplateName?: string\nVersion: string\nLaunchTemplateId?: string\n}\nexport interface LaunchTemplateOverrides {\nSpotPrice?: string\nWeightedCapacity?: number\nPriority?: number\nAvailabilityZone?: string\nSubnetId?: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\n}\nexport interface InstanceRequirementsRequest {\nInstanceGenerations?: (\"current\" | \"previous\")[]\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nVCpuCount?: VCpuCountRangeRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMemoryMiB?: MemoryMiBRequest\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nExcludedInstanceTypes?: string[]\nAllowedInstanceTypes?: string[]\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nAcceleratorCount?: AcceleratorCountRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nSpotMaxPricePercentageOverLowestPrice?: number\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\nexport interface SpotMaintenanceStrategies {\nCapacityRebalance?: SpotCapacityRebalance\n}\nexport interface SpotCapacityRebalance {\nTerminationDelay?: number\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\n}\nexport interface SpotFleetLaunchSpecification {\nSecurityGroups?: GroupIdentifier[]\nTagSpecifications?: SpotFleetTagSpecification[]\nUserData?: string\nBlockDeviceMappings?: BlockDeviceMapping[]\nIamInstanceProfile?: IamInstanceProfileSpecification\nKernelId?: string\nSubnetId?: string\nEbsOptimized?: boolean\nKeyName?: string\nRamdiskId?: string\nSpotPrice?: string\nWeightedCapacity?: number\nPlacement?: SpotPlacement\nNetworkInterfaces?: InstanceNetworkInterfaceSpecification[]\nImageId: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\nMonitoring?: SpotFleetMonitoring\n}\nexport interface GroupIdentifier {\nGroupId: string\n}\nexport interface BlockDeviceMapping {\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\nDeviceName: string\n}\nexport interface EbsBlockDevice {\nSnapshotId?: string\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\nEncrypted?: boolean\nIops?: number\nVolumeSize?: number\nDeleteOnTermination?: boolean\n}\nexport interface IamInstanceProfileSpecification {\nArn?: string\n}\nexport interface SpotPlacement {\nGroupName?: string\nTenancy?: (\"dedicated\" | \"default\" | \"host\")\nAvailabilityZone?: string\n}\nexport interface InstanceNetworkInterfaceSpecification {\nDescription?: string\nPrivateIpAddresses?: PrivateIpAddressSpecification[]\nSecondaryPrivateIpAddressCount?: number\nDeviceIndex?: number\nGroups?: string[]\nIpv6AddressCount?: number\nIpv6Addresses?: InstanceIpv6Address[]\nSubnetId?: string\nAssociatePublicIpAddress?: boolean\nNetworkInterfaceId?: string\nDeleteOnTermination?: boolean\n}\nexport interface PrivateIpAddressSpecification {\nPrivateIpAddress: string\nPrimary?: boolean\n}\nexport interface InstanceIpv6Address {\nIpv6Address: string\n}\nexport interface SpotFleetMonitoring {\nEnabled?: boolean\n}\nexport interface LoadBalancersConfig {\nClassicLoadBalancersConfig?: ClassicLoadBalancersConfig\nTargetGroupsConfig?: TargetGroupsConfig\n}\nexport interface ClassicLoadBalancersConfig {\nClassicLoadBalancers: ClassicLoadBalancer[]\n}\nexport interface ClassicLoadBalancer {\nName: string\n}\nexport interface TargetGroupsConfig {\nTargetGroups: TargetGroup[]\n}\nexport interface TargetGroup {\nArn: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-ec2-spotfleet.js","sourceRoot":"","sources":["aws-ec2-spotfleet.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for AWS::EC2::SpotFleet\n */\nexport interface _AWS_EC2_SPOTFLEET {\nSpotFleetRequestConfigData: SpotFleetRequestConfigData\nId?: string\n/**\n * The tags to specify in SpotFleetRequestConfigData\n */\nTags?: Tag[]\n}\nexport interface SpotFleetRequestConfigData {\nContext?: string\nSpotMaxTotalPrice?: string\nExcessCapacityTerminationPolicy?: (\"Default\" | \"NoTermination\" | \"default\" | \"noTermination\")\nTagSpecifications?: SpotFleetTagSpecification[]\nInstancePoolsToUseCount?: number\nLaunchTemplateConfigs?: LaunchTemplateConfig[]\nTargetCapacityUnitType?: (\"vcpu\" | \"memory-mib\" | \"units\")\nIamFleetRole: string\nSpotMaintenanceStrategies?: SpotMaintenanceStrategies\nTerminateInstancesWithExpiration?: boolean\nValidUntil?: string\nOnDemandMaxTotalPrice?: string\nOnDemandAllocationStrategy?: string\nSpotPrice?: string\nAllocationStrategy?: (\"capacityOptimized\" | \"capacityOptimizedPrioritized\" | \"diversified\" | \"lowestPrice\" | \"priceCapacityOptimized\")\nOnDemandTargetCapacity?: number\nType?: (\"maintain\" | \"request\")\nLaunchSpecifications?: SpotFleetLaunchSpecification[]\nInstanceInterruptionBehavior?: (\"hibernate\" | \"stop\" | \"terminate\")\nLoadBalancersConfig?: LoadBalancersConfig\nValidFrom?: string\nReplaceUnhealthyInstances?: boolean\nTargetCapacity: number\n}\nexport interface SpotFleetTagSpecification {\nResourceType?: (\"client-vpn-endpoint\" | \"customer-gateway\" | \"dedicated-host\" | \"dhcp-options\" | \"egress-only-internet-gateway\" | \"elastic-gpu\" | \"elastic-ip\" | \"export-image-task\" | \"export-instance-task\" | \"fleet\" | \"fpga-image\" | \"host-reservation\" | \"image\" | \"import-image-task\" | \"import-snapshot-task\" | \"instance\" | \"internet-gateway\" | \"key-pair\" | \"launch-template\" | \"local-gateway-route-table-vpc-association\" | \"natgateway\" | \"network-acl\" | \"network-insights-analysis\" | \"network-insights-path\" | \"network-interface\" | \"placement-group\" | \"reserved-instances\" | \"route-table\" | \"security-group\" | \"snapshot\" | \"spot-fleet-request\" | \"spot-instances-request\" | \"subnet\" | \"traffic-mirror-filter\" | \"traffic-mirror-session\" | \"traffic-mirror-target\" | \"transit-gateway\" | \"transit-gateway-attachment\" | \"transit-gateway-connect-peer\" | \"transit-gateway-multicast-domain\" | \"transit-gateway-route-table\" | \"volume\" | \"vpc\" | \"vpc-flow-log\" | \"vpc-peering-connection\" | \"vpn-connection\" | \"vpn-gateway\")\nTags?: Tag[]\n}\nexport interface Tag {\nValue: string\nKey: string\n}\nexport interface LaunchTemplateConfig {\nLaunchTemplateSpecification?: FleetLaunchTemplateSpecification\nOverrides?: LaunchTemplateOverrides[]\n}\nexport interface FleetLaunchTemplateSpecification {\nLaunchTemplateName?: string\nVersion: string\nLaunchTemplateId?: string\n}\nexport interface LaunchTemplateOverrides {\nSpotPrice?: string\nWeightedCapacity?: number\nPriority?: number\nAvailabilityZone?: string\nSubnetId?: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\n}\nexport interface InstanceRequirementsRequest {\nInstanceGenerations?: (\"current\" | \"previous\")[]\nRequireEncryptionInTransit?: boolean\nMemoryGiBPerVCpu?: MemoryGiBPerVCpuRequest\nAcceleratorTypes?: (\"gpu\" | \"fpga\" | \"inference\" | \"media\")[]\nVCpuCount?: VCpuCountRangeRequest\nAcceleratorManufacturers?: (\"amazon-web-services\" | \"amd\" | \"habana\" | \"nvidia\" | \"xilinx\")[]\nLocalStorage?: (\"included\" | \"required\" | \"excluded\")\nCpuManufacturers?: (\"intel\" | \"amd\" | \"amazon-web-services\" | \"apple\")[]\nBareMetal?: (\"included\" | \"required\" | \"excluded\")\nRequireHibernateSupport?: boolean\nMaxSpotPriceAsPercentageOfOptimalOnDemandPrice?: number\nOnDemandMaxPricePercentageOverLowestPrice?: number\nMemoryMiB?: MemoryMiBRequest\nLocalStorageTypes?: (\"hdd\" | \"ssd\")[]\nNetworkInterfaceCount?: NetworkInterfaceCountRequest\nExcludedInstanceTypes?: string[]\nAllowedInstanceTypes?: string[]\nNetworkBandwidthGbps?: NetworkBandwidthGbpsRequest\nAcceleratorCount?: AcceleratorCountRequest\nBaselinePerformanceFactors?: BaselinePerformanceFactorsRequest\nSpotMaxPricePercentageOverLowestPrice?: number\nBaselineEbsBandwidthMbps?: BaselineEbsBandwidthMbpsRequest\nAcceleratorNames?: (\"a10g\" | \"a100\" | \"h100\" | \"inferentia\" | \"k520\" | \"k80\" | \"m60\" | \"radeon-pro-v520\" | \"t4\" | \"t4g\" | \"vu9p\" | \"v100\" | \"l40s\" | \"l4\" | \"gaudi-hl-205\" | \"inferentia2\" | \"trainium\" | \"trainium2\" | \"u30\")[]\nAcceleratorTotalMemoryMiB?: AcceleratorTotalMemoryMiBRequest\nBurstablePerformance?: (\"included\" | \"required\" | \"excluded\")\nTotalLocalStorageGB?: TotalLocalStorageGBRequest\n}\nexport interface MemoryGiBPerVCpuRequest {\nMin?: number\nMax?: number\n}\nexport interface VCpuCountRangeRequest {\nMin?: number\nMax?: number\n}\nexport interface MemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkInterfaceCountRequest {\nMin?: number\nMax?: number\n}\nexport interface NetworkBandwidthGbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorCountRequest {\nMin?: number\nMax?: number\n}\nexport interface BaselinePerformanceFactorsRequest {\nCpu?: CpuPerformanceFactorRequest\n}\nexport interface CpuPerformanceFactorRequest {\nReferences?: PerformanceFactorReferenceRequest[]\n}\nexport interface PerformanceFactorReferenceRequest {\nInstanceFamily?: string\n}\nexport interface BaselineEbsBandwidthMbpsRequest {\nMin?: number\nMax?: number\n}\nexport interface AcceleratorTotalMemoryMiBRequest {\nMin?: number\nMax?: number\n}\nexport interface TotalLocalStorageGBRequest {\nMin?: number\nMax?: number\n}\nexport interface SpotMaintenanceStrategies {\nCapacityRebalance?: SpotCapacityRebalance\n}\nexport interface SpotCapacityRebalance {\nTerminationDelay?: number\nReplacementStrategy?: (\"launch\" | \"launch-before-terminate\")\n}\nexport interface SpotFleetLaunchSpecification {\nSecurityGroups?: GroupIdentifier[]\nTagSpecifications?: SpotFleetTagSpecification[]\nUserData?: string\nBlockDeviceMappings?: BlockDeviceMapping[]\nIamInstanceProfile?: IamInstanceProfileSpecification\nKernelId?: string\nSubnetId?: string\nEbsOptimized?: boolean\nKeyName?: string\nRamdiskId?: string\nSpotPrice?: string\nWeightedCapacity?: number\nPlacement?: SpotPlacement\nNetworkInterfaces?: InstanceNetworkInterfaceSpecification[]\nImageId: string\nInstanceRequirements?: InstanceRequirementsRequest\nInstanceType?: string\nMonitoring?: SpotFleetMonitoring\n}\nexport interface GroupIdentifier {\nGroupId: string\n}\nexport interface BlockDeviceMapping {\nEbs?: EbsBlockDevice\nNoDevice?: string\nVirtualName?: string\nDeviceName: string\n}\nexport interface EbsBlockDevice {\nSnapshotId?: string\nVolumeType?: (\"gp2\" | \"gp3\" | \"io1\" | \"io2\" | \"sc1\" | \"st1\" | \"standard\")\nEncrypted?: boolean\nIops?: number\nVolumeSize?: number\nDeleteOnTermination?: boolean\n}\nexport interface IamInstanceProfileSpecification {\nArn?: string\n}\nexport interface SpotPlacement {\nGroupName?: string\nTenancy?: (\"dedicated\" | \"default\" | \"host\")\nAvailabilityZone?: string\n}\nexport interface InstanceNetworkInterfaceSpecification {\nDescription?: string\nPrivateIpAddresses?: PrivateIpAddressSpecification[]\nSecondaryPrivateIpAddressCount?: number\nDeviceIndex?: number\nGroups?: string[]\nIpv6AddressCount?: number\nIpv6Addresses?: InstanceIpv6Address[]\nSubnetId?: string\nAssociatePublicIpAddress?: boolean\nNetworkInterfaceId?: string\nDeleteOnTermination?: boolean\n}\nexport interface PrivateIpAddressSpecification {\nPrivateIpAddress: string\nPrimary?: boolean\n}\nexport interface InstanceIpv6Address {\nIpv6Address: string\n}\nexport interface SpotFleetMonitoring {\nEnabled?: boolean\n}\nexport interface LoadBalancersConfig {\nClassicLoadBalancersConfig?: ClassicLoadBalancersConfig\nTargetGroupsConfig?: TargetGroupsConfig\n}\nexport interface ClassicLoadBalancersConfig {\nClassicLoadBalancers: ClassicLoadBalancer[]\n}\nexport interface ClassicLoadBalancer {\nName: string\n}\nexport interface TargetGroupsConfig {\nTargetGroups: TargetGroup[]\n}\nexport interface TargetGroup {\nArn: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-ecs-expressgatewayservice.d.ts

@@ -14,11 +14,13 @@ export interface _AWS_ECS_EXPRESSGATEWAYSERVICE {
     Cluster?: string;
     Cpu?: string;
     ServiceArn?: string;
+    ECSManagedResourceArns?: ECSManagedResourceArns;
     UpdatedAt?: string;
     ExecutionRoleArn: string;
     InfrastructureRoleArn: string;
     ScalingTarget?: ExpressGatewayScalingTarget;
     ActiveConfigurations?: ExpressGatewayServiceConfiguration[];
+    Endpoint?: string;
     ServiceName?: string;
     NetworkConfiguration?: ExpressGatewayServiceNetworkConfiguration;
     Tags?: Tag[];
@@ -50,6 +52,25 @@ export interface KeyValuePair {
     Value: string;
     Name: string;
 }
+export interface ECSManagedResourceArns {
+    LogGroups?: string[];
+    ServiceSecurityGroups?: string[];
+    MetricAlarms?: string[];
+    IngressPath?: IngressPathArns;
+    AutoScaling?: AutoScalingArns;
+}
+export interface IngressPathArns {
+    ListenerArn?: string;
+    LoadBalancerArn?: string;
+    TargetGroupArns?: string[];
+    ListenerRuleArn?: string;
+    LoadBalancerSecurityGroups?: string[];
+    CertificateArn?: string;
+}
+export interface AutoScalingArns {
+    ScalableTarget?: string;
+    ApplicationAutoScalingPolicies?: string[];
+}
 export interface ExpressGatewayScalingTarget {
     MinTaskCount?: number;
     MaxTaskCount?: number;