@horietakehiro/aws-cdk-utul 0.41.49 → 0.41.51

package/lib/types/cfn-resource-types/aws-cloudfront-truststore.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Resource Type definition for AWS::CloudFront::TrustStore. TrustStores contain CA certificates for mTLS authentication and can be associated with CloudFront distributions.
+ */
+export interface _AWS_CLOUDFRONT_TRUSTSTORE {
+    /**
+     * The unique identifier for the trust store
+     */
+    Id?: string;
+    /**
+     * A unique name to identify the trust store
+     */
+    Name: string;
+    /**
+     * The Amazon Resource Name (ARN) of the trust store
+     */
+    Arn?: string;
+    CaCertificatesBundleSource?: CaCertificatesBundleSource;
+    /**
+     * Current status of the trust store
+     */
+    Status?: ("PENDING" | "ACTIVE" | "FAILED");
+    ETag?: string;
+    /**
+     * The last modification timestamp of the trust store PEM file
+     */
+    LastModifiedTime?: string;
+    /**
+     * The number of CA certificates in the trust store PEM file
+     */
+    NumberOfCaCertificates?: number;
+    /**
+     * Key-value pairs for resource tagging
+     */
+    Tags?: Tag[];
+}
+export interface CaCertificatesBundleSource {
+    CaCertificatesBundleS3Location: CaCertificatesBundleS3Location;
+}
+export interface CaCertificatesBundleS3Location {
+    /**
+     * The S3 bucket containing the CA certificates bundle PEM file
+     */
+    Bucket: string;
+    /**
+     * The S3 object key of the CA certificates bundle PEM file
+     */
+    Key: string;
+    /**
+     * The S3 bucket region
+     */
+    Region: string;
+    /**
+     * The S3 object version of the CA certificates bundle PEM file
+     */
+    Version?: string;
+}
+export interface Tag {
+    Key: string;
+    Value: string;
+}

package/lib/types/cfn-resource-types/aws-cloudfront-truststore.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-customerprofiles-segmentdefinition.d.ts

@@ -50,11 +50,19 @@ export interface _AWS_CUSTOMERPROFILES_SEGMENTDEFINITION {
      * The unique name of the segment definition.
      */
     SegmentDefinitionName: string;
-    SegmentGroups: SegmentGroup;
+    SegmentGroups?: SegmentGroup;
+    /**
+     * The SQL query that defines the segment criteria.
+     */
+    SegmentSqlQuery?: string;
     /**
      * The Amazon Resource Name (ARN) of the segment definition.
      */
     SegmentDefinitionArn?: string;
+    /**
+     * The SQL query that defines the segment criteria.
+     */
+    SegmentType?: ("CLASSIC" | "ENHANCED");
     /**
      * The tags used to organize, track, or control access for this resource.
      *

package/lib/types/cfn-resource-types/aws-customerprofiles-segmentdefinition.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-customerprofiles-segmentdefinition.js","sourceRoot":"","sources":["aws-customerprofiles-segmentdefinition.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The criteria that define the dimensions for the segment.\n */\nexport type Dimension = (ProfileAttributes | CalculatedAttributes)\n/**\n * The type of segment dimension to use for a string dimension.\n */\nexport type StringDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\" | \"CONTAINS\" | \"BEGINS_WITH\" | \"ENDS_WITH\")\n/**\n * The type of segment dimension to use for a date dimension.\n */\nexport type DateDimensionType = (\"BEFORE\" | \"AFTER\" | \"BETWEEN\" | \"NOT_BETWEEN\" | \"ON\")\n/**\n * The type of segment dimension to use.\n */\nexport type AttributeDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\" | \"CONTAINS\" | \"BEGINS_WITH\" | \"ENDS_WITH\" | \"BEFORE\" | \"AFTER\" | \"BETWEEN\" | \"NOT_BETWEEN\" | \"ON\" | \"GREATER_THAN\" | \"LESS_THAN\" | \"GREATER_THAN_OR_EQUAL\" | \"LESS_THAN_OR_EQUAL\" | \"EQUAL\")\n/**\n * The type of segment dimension to use for a profile type dimension.\n */\nexport type ProfileTypeDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\")\n/**\n * The type of profile.\n */\nexport type ProfileType = (\"ACCOUNT_PROFILE\" | \"PROFILE\")\n/**\n * Specifies the operator on how to handle multiple groups within the same segment.\n */\nexport type IncludeOptions = (\"ALL\" | \"ANY\" | \"NONE\")\n\n/**\n * A segment definition resource of Amazon Connect Customer Profiles\n */\nexport interface _AWS_CUSTOMERPROFILES_SEGMENTDEFINITION {\n/**\n * The time of this segment definition got created.\n */\nCreatedAt?: string\n/**\n * The description of the segment definition.\n */\nDescription?: string\n/**\n * The display name of the segment definition.\n */\nDisplayName: string\n/**\n * The unique name of the domain.\n */\nDomainName: string\n/**\n * The unique name of the segment definition.\n */\nSegmentDefinitionName: string\nSegmentGroups: SegmentGroup\n/**\n * The Amazon Resource Name (ARN) of the segment definition.\n */\nSegmentDefinitionArn?: string\n/**\n * The tags used to organize, track, or control access for this resource.\n * \n * @minItems 0\n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * An array that defines the set of segment criteria to evaluate when handling segment groups for the segment.\n */\nexport interface SegmentGroup {\nGroups?: Group[]\nInclude?: IncludeOptions\n}\n/**\n * An array that defines the set of segment criteria to evaluate when handling segment groups for the segment.\n */\nexport interface Group {\nDimensions?: Dimension[]\nSourceSegments?: SourceSegment[]\nSourceType?: IncludeOptions\nType?: IncludeOptions\n}\nexport interface ProfileAttributes {\nProfileAttributes: ProfileAttributes1\n}\n/**\n * Specifies the dimension settings within profile attributes for a segment.\n */\nexport interface ProfileAttributes1 {\nAccountNumber?: ProfileDimension\nAdditionalInformation?: ExtraLengthValueProfileDimension\nFirstName?: ProfileDimension\nLastName?: ProfileDimension\nMiddleName?: ProfileDimension\nGenderString?: ProfileDimension\nPartyTypeString?: ProfileDimension\nBirthDate?: DateDimension\nPhoneNumber?: ProfileDimension\nBusinessName?: ProfileDimension\nBusinessPhoneNumber?: ProfileDimension\nHomePhoneNumber?: ProfileDimension\nMobilePhoneNumber?: ProfileDimension\nEmailAddress?: ProfileDimension\nPersonalEmailAddress?: ProfileDimension\nBusinessEmailAddress?: ProfileDimension\nAddress?: AddressDimension\nShippingAddress?: AddressDimension\nMailingAddress?: AddressDimension\nBillingAddress?: AddressDimension\nAttributes?: CustomAttributes\nProfileType?: ProfileTypeDimension\n}\n/**\n * Specifies profile based criteria for a segment.\n */\nexport interface ProfileDimension {\nDimensionType: StringDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies criteria for a segment using extended-length string values.\n */\nexport interface ExtraLengthValueProfileDimension {\nDimensionType: StringDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies date based criteria for a segment.\n */\nexport interface DateDimension {\nDimensionType: DateDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * The address based criteria for the segment.\n */\nexport interface AddressDimension {\nCity?: ProfileDimension\nCountry?: ProfileDimension\nCounty?: ProfileDimension\nPostalCode?: ProfileDimension\nProvince?: ProfileDimension\nState?: ProfileDimension\n}\n/**\n * One or more custom attributes to use as criteria for the segment.\n */\nexport interface CustomAttributes {\n[k: string]: AttributeDimension\n}\n/**\n * Specifies attribute based criteria for a segment.\n * \n * This interface was referenced by `CustomAttributes`'s JSON-Schema definition\n * via the `patternProperty` \"^[a-zA-Z_][a-zA-Z_0-9-]*$\".\n */\nexport interface AttributeDimension {\nDimensionType: AttributeDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies profile type based criteria for a segment.\n */\nexport interface ProfileTypeDimension {\nDimensionType: ProfileTypeDimensionType\n/**\n * @minItems 1\n * @maxItems 1\n */\nValues: ProfileType[]\n}\nexport interface CalculatedAttributes {\nCalculatedAttributes?: CalculatedCustomAttributes\n}\n/**\n * One or more calculated attributes to use as criteria for the segment.\n */\nexport interface CalculatedCustomAttributes {\n[k: string]: CalculatedAttributeDimension\n}\n/**\n * Specifies calculated attribute based criteria for a segment.\n * \n * This interface was referenced by `CalculatedCustomAttributes`'s JSON-Schema definition\n * via the `patternProperty` \"^[a-zA-Z_][a-zA-Z_0-9-]*$\".\n */\nexport interface CalculatedAttributeDimension {\nDimensionType: AttributeDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\nConditionOverrides?: ConditionOverrides\n}\n/**\n * Overrides the condition block within the original calculated attribute definition.\n */\nexport interface ConditionOverrides {\nRange?: RangeOverride\n}\n/**\n * Defines the range to be applied to the calculated attribute definition.\n */\nexport interface RangeOverride {\n/**\n * The starting point for this overridden range. Positive numbers indicate how many days in the past data should be included, and negative numbers indicate how many days in the future.\n */\nStart: number\n/**\n * The ending point for this overridden range. Positive numbers indicate how many days in the past data should be included, and negative numbers indicate how many days in the future.\n */\nEnd?: number\n/**\n * The unit to be applied to the range.\n */\nUnit: \"DAYS\"\n}\n/**\n * The base segment to build the segment on.\n */\nexport interface SourceSegment {\nSegmentDefinitionName?: string\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * 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 -.\n */\nKey: string\n/**\n * 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 -.\n */\nValue: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-customerprofiles-segmentdefinition.js","sourceRoot":"","sources":["aws-customerprofiles-segmentdefinition.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The criteria that define the dimensions for the segment.\n */\nexport type Dimension = (ProfileAttributes | CalculatedAttributes)\n/**\n * The type of segment dimension to use for a string dimension.\n */\nexport type StringDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\" | \"CONTAINS\" | \"BEGINS_WITH\" | \"ENDS_WITH\")\n/**\n * The type of segment dimension to use for a date dimension.\n */\nexport type DateDimensionType = (\"BEFORE\" | \"AFTER\" | \"BETWEEN\" | \"NOT_BETWEEN\" | \"ON\")\n/**\n * The type of segment dimension to use.\n */\nexport type AttributeDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\" | \"CONTAINS\" | \"BEGINS_WITH\" | \"ENDS_WITH\" | \"BEFORE\" | \"AFTER\" | \"BETWEEN\" | \"NOT_BETWEEN\" | \"ON\" | \"GREATER_THAN\" | \"LESS_THAN\" | \"GREATER_THAN_OR_EQUAL\" | \"LESS_THAN_OR_EQUAL\" | \"EQUAL\")\n/**\n * The type of segment dimension to use for a profile type dimension.\n */\nexport type ProfileTypeDimensionType = (\"INCLUSIVE\" | \"EXCLUSIVE\")\n/**\n * The type of profile.\n */\nexport type ProfileType = (\"ACCOUNT_PROFILE\" | \"PROFILE\")\n/**\n * Specifies the operator on how to handle multiple groups within the same segment.\n */\nexport type IncludeOptions = (\"ALL\" | \"ANY\" | \"NONE\")\n\n/**\n * A segment definition resource of Amazon Connect Customer Profiles\n */\nexport interface _AWS_CUSTOMERPROFILES_SEGMENTDEFINITION {\n/**\n * The time of this segment definition got created.\n */\nCreatedAt?: string\n/**\n * The description of the segment definition.\n */\nDescription?: string\n/**\n * The display name of the segment definition.\n */\nDisplayName: string\n/**\n * The unique name of the domain.\n */\nDomainName: string\n/**\n * The unique name of the segment definition.\n */\nSegmentDefinitionName: string\nSegmentGroups?: SegmentGroup\n/**\n * The SQL query that defines the segment criteria.\n */\nSegmentSqlQuery?: string\n/**\n * The Amazon Resource Name (ARN) of the segment definition.\n */\nSegmentDefinitionArn?: string\n/**\n * The SQL query that defines the segment criteria.\n */\nSegmentType?: (\"CLASSIC\" | \"ENHANCED\")\n/**\n * The tags used to organize, track, or control access for this resource.\n * \n * @minItems 0\n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * An array that defines the set of segment criteria to evaluate when handling segment groups for the segment.\n */\nexport interface SegmentGroup {\nGroups?: Group[]\nInclude?: IncludeOptions\n}\n/**\n * An array that defines the set of segment criteria to evaluate when handling segment groups for the segment.\n */\nexport interface Group {\nDimensions?: Dimension[]\nSourceSegments?: SourceSegment[]\nSourceType?: IncludeOptions\nType?: IncludeOptions\n}\nexport interface ProfileAttributes {\nProfileAttributes: ProfileAttributes1\n}\n/**\n * Specifies the dimension settings within profile attributes for a segment.\n */\nexport interface ProfileAttributes1 {\nAccountNumber?: ProfileDimension\nAdditionalInformation?: ExtraLengthValueProfileDimension\nFirstName?: ProfileDimension\nLastName?: ProfileDimension\nMiddleName?: ProfileDimension\nGenderString?: ProfileDimension\nPartyTypeString?: ProfileDimension\nBirthDate?: DateDimension\nPhoneNumber?: ProfileDimension\nBusinessName?: ProfileDimension\nBusinessPhoneNumber?: ProfileDimension\nHomePhoneNumber?: ProfileDimension\nMobilePhoneNumber?: ProfileDimension\nEmailAddress?: ProfileDimension\nPersonalEmailAddress?: ProfileDimension\nBusinessEmailAddress?: ProfileDimension\nAddress?: AddressDimension\nShippingAddress?: AddressDimension\nMailingAddress?: AddressDimension\nBillingAddress?: AddressDimension\nAttributes?: CustomAttributes\nProfileType?: ProfileTypeDimension\n}\n/**\n * Specifies profile based criteria for a segment.\n */\nexport interface ProfileDimension {\nDimensionType: StringDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies criteria for a segment using extended-length string values.\n */\nexport interface ExtraLengthValueProfileDimension {\nDimensionType: StringDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies date based criteria for a segment.\n */\nexport interface DateDimension {\nDimensionType: DateDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * The address based criteria for the segment.\n */\nexport interface AddressDimension {\nCity?: ProfileDimension\nCountry?: ProfileDimension\nCounty?: ProfileDimension\nPostalCode?: ProfileDimension\nProvince?: ProfileDimension\nState?: ProfileDimension\n}\n/**\n * One or more custom attributes to use as criteria for the segment.\n */\nexport interface CustomAttributes {\n[k: string]: AttributeDimension\n}\n/**\n * Specifies attribute based criteria for a segment.\n * \n * This interface was referenced by `CustomAttributes`'s JSON-Schema definition\n * via the `patternProperty` \"^[a-zA-Z_][a-zA-Z_0-9-]*$\".\n */\nexport interface AttributeDimension {\nDimensionType: AttributeDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\n}\n/**\n * Specifies profile type based criteria for a segment.\n */\nexport interface ProfileTypeDimension {\nDimensionType: ProfileTypeDimensionType\n/**\n * @minItems 1\n * @maxItems 1\n */\nValues: ProfileType[]\n}\nexport interface CalculatedAttributes {\nCalculatedAttributes?: CalculatedCustomAttributes\n}\n/**\n * One or more calculated attributes to use as criteria for the segment.\n */\nexport interface CalculatedCustomAttributes {\n[k: string]: CalculatedAttributeDimension\n}\n/**\n * Specifies calculated attribute based criteria for a segment.\n * \n * This interface was referenced by `CalculatedCustomAttributes`'s JSON-Schema definition\n * via the `patternProperty` \"^[a-zA-Z_][a-zA-Z_0-9-]*$\".\n */\nexport interface CalculatedAttributeDimension {\nDimensionType: AttributeDimensionType\n/**\n * @minItems 1\n * @maxItems 50\n */\nValues: string[]\nConditionOverrides?: ConditionOverrides\n}\n/**\n * Overrides the condition block within the original calculated attribute definition.\n */\nexport interface ConditionOverrides {\nRange?: RangeOverride\n}\n/**\n * Defines the range to be applied to the calculated attribute definition.\n */\nexport interface RangeOverride {\n/**\n * The starting point for this overridden range. Positive numbers indicate how many days in the past data should be included, and negative numbers indicate how many days in the future.\n */\nStart: number\n/**\n * The ending point for this overridden range. Positive numbers indicate how many days in the past data should be included, and negative numbers indicate how many days in the future.\n */\nEnd?: number\n/**\n * The unit to be applied to the range.\n */\nUnit: \"DAYS\"\n}\n/**\n * The base segment to build the segment on.\n */\nexport interface SourceSegment {\nSegmentDefinitionName?: string\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * 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 -.\n */\nKey: string\n/**\n * 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 -.\n */\nValue: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-eks-capability.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Resource Type definition for EKS Capability.
+ */
+export interface _AWS_EKS_CAPABILITY {
+    /**
+     * The name of the EKS cluster where you want to create the capability.
+     */
+    ClusterName: string;
+    /**
+     * A unique name for the capability. The name must be unique within your cluster and can contain alphanumeric characters, hyphens, and underscores.
+     */
+    CapabilityName: string;
+    /**
+     * The type of capability to create. Valid values are: ACK (AWS Controllers for Kubernetes, which lets you manage AWS resources directly from Kubernetes), ARGOCD (Argo CD for GitOps-based continuous delivery), or KRO (Kube Resource Orchestrator for composing and managing custom Kubernetes resources).
+     */
+    Type: ("ARGOCD" | "ACK" | "KRO");
+    /**
+     * The Amazon Resource Name (ARN) of the IAM role that the capability uses to interact with AWS services. This role must have a trust policy that allows the EKS service principal to assume it, and it must have the necessary permissions for the capability type you're creating.
+     */
+    RoleArn: string;
+    /**
+     * Specifies how Kubernetes resources managed by the capability should be handled when the capability is deleted. Currently, the only supported value is RETAIN which retains all Kubernetes resources managed by the capability when the capability is deleted.
+     */
+    DeletePropagationPolicy: "RETAIN";
+    Configuration?: CapabilityConfiguration;
+    /**
+     * The Amazon Resource Name (ARN) of the capability.
+     */
+    Arn?: string;
+    /**
+     * The current status of the capability. Valid values include: CREATING (the capability is being created), ACTIVE (the capability is running and available), UPDATING (the capability is being updated), DELETING (the capability is being deleted), CREATE_FAILED (the capability creation failed), UPDATE_FAILED (the capability update failed), or DELETE_FAILED (the capability deletion failed).
+     */
+    Status?: string;
+    /**
+     * The Unix epoch timestamp in seconds for when the capability was created.
+     */
+    CreatedAt?: string;
+    /**
+     * The Unix epoch timestamp in seconds for when the capability was last modified.
+     */
+    ModifiedAt?: string;
+    /**
+     * The version of the capability software that is currently running.
+     */
+    Version?: string;
+    /**
+     * An array of key-value pairs to apply to this resource.
+     */
+    Tags?: Tag[];
+}
+/**
+ * The configuration settings for the capability. The structure of this object varies depending on the capability type. For Argo CD capabilities, you can configure IAM Identity Center integration, RBAC role mappings, and network access settings.
+ */
+export interface CapabilityConfiguration {
+    ArgoCd?: ArgoCd;
+}
+/**
+ * Configuration settings for an Argo CD capability. This includes the Kubernetes namespace, IAM Identity Center integration, RBAC role mappings, and network access configuration.
+ */
+export interface ArgoCd {
+    /**
+     * The Kubernetes namespace where Argo CD resources will be created. If not specified, the default namespace is used.
+     */
+    Namespace?: string;
+    AwsIdc: AwsIdc;
+    /**
+     * A list of role mappings that define which IAM Identity Center users or groups have which Argo CD roles. Each mapping associates an Argo CD role (ADMIN, EDITOR, or VIEWER) with one or more IAM Identity Center identities.
+     */
+    RbacRoleMappings?: ArgoCdRoleMapping[];
+    NetworkAccess?: NetworkAccess;
+    /**
+     * The URL of the Argo CD server. Use this URL to access the Argo CD web interface and API.
+     */
+    ServerUrl?: string;
+}
+/**
+ * Configuration for integrating Argo CD with IAM Identity Center. This allows you to use your organization's identity provider for authentication to Argo CD.
+ */
+export interface AwsIdc {
+    /**
+     * The ARN of the IAM Identity Center instance to use for authentication.
+     */
+    IdcInstanceArn: string;
+    /**
+     * The Region where your IAM Identity Center instance is located.
+     */
+    IdcRegion?: string;
+    /**
+     * The ARN of the managed application created in IAM Identity Center for this Argo CD capability. This application is automatically created and managed by EKS.
+     */
+    IdcManagedApplicationArn?: string;
+}
+/**
+ * A mapping between an Argo CD role and IAM Identity Center identities. This defines which users or groups have specific permissions in Argo CD.
+ */
+export interface ArgoCdRoleMapping {
+    /**
+     * The Argo CD role to assign. Valid values are: ADMIN (full administrative access to Argo CD), EDITOR (edit access to Argo CD resources), or VIEWER (read-only access to Argo CD resources).
+     */
+    Role: ("ADMIN" | "EDITOR" | "VIEWER");
+    /**
+     * A list of IAM Identity Center identities (users or groups) that should be assigned this Argo CD role.
+     */
+    Identities: SsoIdentity[];
+}
+/**
+ * An IAM Identity Center identity (user or group) that can be assigned permissions in a capability.
+ */
+export interface SsoIdentity {
+    /**
+     * The unique identifier of the IAM Identity Center user or group.
+     */
+    Id: string;
+    /**
+     * The type of identity. Valid values are SSO_USER or SSO_GROUP.
+     */
+    Type: ("SSO_USER" | "SSO_GROUP");
+}
+/**
+ * Configuration for network access to the Argo CD capability's managed API server endpoint. By default, the Argo CD server is accessible via a public endpoint. You can optionally specify one or more VPC endpoint IDs to enable private connectivity from your VPCs.
+ */
+export interface NetworkAccess {
+    /**
+     * A list of VPC endpoint IDs to associate with the managed Argo CD API server endpoint. Each VPC endpoint provides private connectivity from a specific VPC to the Argo CD server. You can specify multiple VPC endpoint IDs to enable access from multiple VPCs.
+     */
+    VpceIds?: 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-eks-capability.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-eks-capability.js","sourceRoot":"","sources":["aws-eks-capability.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource Type definition for EKS Capability.\n */\nexport interface _AWS_EKS_CAPABILITY {\n/**\n * The name of the EKS cluster where you want to create the capability.\n */\nClusterName: string\n/**\n * A unique name for the capability. The name must be unique within your cluster and can contain alphanumeric characters, hyphens, and underscores.\n */\nCapabilityName: string\n/**\n * The type of capability to create. Valid values are: ACK (AWS Controllers for Kubernetes, which lets you manage AWS resources directly from Kubernetes), ARGOCD (Argo CD for GitOps-based continuous delivery), or KRO (Kube Resource Orchestrator for composing and managing custom Kubernetes resources).\n */\nType: (\"ARGOCD\" | \"ACK\" | \"KRO\")\n/**\n * The Amazon Resource Name (ARN) of the IAM role that the capability uses to interact with AWS services. This role must have a trust policy that allows the EKS service principal to assume it, and it must have the necessary permissions for the capability type you're creating.\n */\nRoleArn: string\n/**\n * Specifies how Kubernetes resources managed by the capability should be handled when the capability is deleted. Currently, the only supported value is RETAIN which retains all Kubernetes resources managed by the capability when the capability is deleted.\n */\nDeletePropagationPolicy: \"RETAIN\"\nConfiguration?: CapabilityConfiguration\n/**\n * The Amazon Resource Name (ARN) of the capability.\n */\nArn?: string\n/**\n * The current status of the capability. Valid values include: CREATING (the capability is being created), ACTIVE (the capability is running and available), UPDATING (the capability is being updated), DELETING (the capability is being deleted), CREATE_FAILED (the capability creation failed), UPDATE_FAILED (the capability update failed), or DELETE_FAILED (the capability deletion failed).\n */\nStatus?: string\n/**\n * The Unix epoch timestamp in seconds for when the capability was created.\n */\nCreatedAt?: string\n/**\n * The Unix epoch timestamp in seconds for when the capability was last modified.\n */\nModifiedAt?: string\n/**\n * The version of the capability software that is currently running.\n */\nVersion?: string\n/**\n * An array of key-value pairs to apply to this resource.\n */\nTags?: Tag[]\n}\n/**\n * The configuration settings for the capability. The structure of this object varies depending on the capability type. For Argo CD capabilities, you can configure IAM Identity Center integration, RBAC role mappings, and network access settings.\n */\nexport interface CapabilityConfiguration {\nArgoCd?: ArgoCd\n}\n/**\n * Configuration settings for an Argo CD capability. This includes the Kubernetes namespace, IAM Identity Center integration, RBAC role mappings, and network access configuration.\n */\nexport interface ArgoCd {\n/**\n * The Kubernetes namespace where Argo CD resources will be created. If not specified, the default namespace is used.\n */\nNamespace?: string\nAwsIdc: AwsIdc\n/**\n * A list of role mappings that define which IAM Identity Center users or groups have which Argo CD roles. Each mapping associates an Argo CD role (ADMIN, EDITOR, or VIEWER) with one or more IAM Identity Center identities.\n */\nRbacRoleMappings?: ArgoCdRoleMapping[]\nNetworkAccess?: NetworkAccess\n/**\n * The URL of the Argo CD server. Use this URL to access the Argo CD web interface and API.\n */\nServerUrl?: string\n}\n/**\n * Configuration for integrating Argo CD with IAM Identity Center. This allows you to use your organization's identity provider for authentication to Argo CD.\n */\nexport interface AwsIdc {\n/**\n * The ARN of the IAM Identity Center instance to use for authentication.\n */\nIdcInstanceArn: string\n/**\n * The Region where your IAM Identity Center instance is located.\n */\nIdcRegion?: string\n/**\n * The ARN of the managed application created in IAM Identity Center for this Argo CD capability. This application is automatically created and managed by EKS.\n */\nIdcManagedApplicationArn?: string\n}\n/**\n * A mapping between an Argo CD role and IAM Identity Center identities. This defines which users or groups have specific permissions in Argo CD.\n */\nexport interface ArgoCdRoleMapping {\n/**\n * The Argo CD role to assign. Valid values are: ADMIN (full administrative access to Argo CD), EDITOR (edit access to Argo CD resources), or VIEWER (read-only access to Argo CD resources).\n */\nRole: (\"ADMIN\" | \"EDITOR\" | \"VIEWER\")\n/**\n * A list of IAM Identity Center identities (users or groups) that should be assigned this Argo CD role.\n */\nIdentities: SsoIdentity[]\n}\n/**\n * An IAM Identity Center identity (user or group) that can be assigned permissions in a capability.\n */\nexport interface SsoIdentity {\n/**\n * The unique identifier of the IAM Identity Center user or group.\n */\nId: string\n/**\n * The type of identity. Valid values are SSO_USER or SSO_GROUP.\n */\nType: (\"SSO_USER\" | \"SSO_GROUP\")\n}\n/**\n * Configuration for network access to the Argo CD capability's managed API server endpoint. By default, the Argo CD server is accessible via a public endpoint. You can optionally specify one or more VPC endpoint IDs to enable private connectivity from your VPCs.\n */\nexport interface NetworkAccess {\n/**\n * A list of VPC endpoint IDs to associate with the managed Argo CD API server endpoint. Each VPC endpoint provides private connectivity from a specific VPC to the Argo CD server. You can specify multiple VPC endpoint IDs to enable access from multiple VPCs.\n */\nVpceIds?: string[]\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * 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 -.\n */\nKey: string\n/**\n * 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 -.\n */\nValue: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-rtbfabric-outboundexternallink.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Tags to assign to the Link.
+ *
+ * @minItems 0
+ * @maxItems 50
+ */
+export type Tags = Tag[];
+export type LinkId = string;
+export type GatewayId = string;
+export type PublicEndpoint = string;
+export type ResponderErrorMaskingLoggingType = ("NONE" | "METRIC" | "RESPONSE");
+export type LinkStatus = ("PENDING_CREATION" | "PENDING_REQUEST" | "REQUESTED" | "ACCEPTED" | "ACTIVE" | "REJECTED" | "FAILED" | "PENDING_DELETION" | "DELETED" | "PENDING_UPDATE" | "PENDING_ISOLATION" | "ISOLATED" | "PENDING_RESTORATION" | "UNKNOWN_TO_SDK_VERSION");
+export type CreatedTimestamp = string;
+export type UpdatedTimestamp = string;
+export type Arn = string;
+/**
+ * Resource Type definition for AWS::RTBFabric::OutboundExternalLink Resource Type
+ */
+export interface _AWS_RTBFABRIC_OUTBOUNDEXTERNALLINK {
+    Tags?: Tags;
+    LinkId?: LinkId;
+    GatewayId: GatewayId;
+    PublicEndpoint: PublicEndpoint;
+    LinkAttributes?: LinkAttributes;
+    LinkLogSettings: LinkLogSettings;
+    LinkStatus?: LinkStatus;
+    CreatedTimestamp?: CreatedTimestamp;
+    UpdatedTimestamp?: UpdatedTimestamp;
+    Arn?: Arn;
+}
+/**
+ * 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;
+}
+export interface LinkAttributes {
+    /**
+     * @minItems 1
+     * @maxItems 200
+     */
+    ResponderErrorMasking?: ResponderErrorMaskingForHttpCode[];
+    CustomerProvidedId?: string;
+}
+export interface ResponderErrorMaskingForHttpCode {
+    HttpCode: string;
+    Action: ("NO_BID" | "PASSTHROUGH");
+    /**
+     * @minItems 1
+     * @maxItems 2
+     */
+    LoggingTypes: ResponderErrorMaskingLoggingType[];
+    ResponseLoggingPercentage?: number;
+}
+export interface LinkLogSettings {
+    ApplicationLogs: {
+        LinkApplicationLogSampling: {
+            ErrorLog: number;
+            FilterLog: number;
+        };
+    };
+}

package/lib/types/cfn-resource-types/aws-rtbfabric-outboundexternallink.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLXJ0YmZhYnJpYy1vdXRib3VuZGV4dGVybmFsbGluay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImF3cy1ydGJmYWJyaWMtb3V0Ym91bmRleHRlcm5hbGxpbmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGFncyB0byBhc3NpZ24gdG8gdGhlIExpbmsuXG4gKiBcbiAqIEBtaW5JdGVtcyAwXG4gKiBAbWF4SXRlbXMgNTBcbiAqL1xuZXhwb3J0IHR5cGUgVGFncyA9IFRhZ1tdXG5leHBvcnQgdHlwZSBMaW5rSWQgPSBzdHJpbmdcbmV4cG9ydCB0eXBlIEdhdGV3YXlJZCA9IHN0cmluZ1xuZXhwb3J0IHR5cGUgUHVibGljRW5kcG9pbnQgPSBzdHJpbmdcbmV4cG9ydCB0eXBlIFJlc3BvbmRlckVycm9yTWFza2luZ0xvZ2dpbmdUeXBlID0gKFwiTk9ORVwiIHwgXCJNRVRSSUNcIiB8IFwiUkVTUE9OU0VcIilcbmV4cG9ydCB0eXBlIExpbmtTdGF0dXMgPSAoXCJQRU5ESU5HX0NSRUFUSU9OXCIgfCBcIlBFTkRJTkdfUkVRVUVTVFwiIHwgXCJSRVFVRVNURURcIiB8IFwiQUNDRVBURURcIiB8IFwiQUNUSVZFXCIgfCBcIlJFSkVDVEVEXCIgfCBcIkZBSUxFRFwiIHwgXCJQRU5ESU5HX0RFTEVUSU9OXCIgfCBcIkRFTEVURURcIiB8IFwiUEVORElOR19VUERBVEVcIiB8IFwiUEVORElOR19JU09MQVRJT05cIiB8IFwiSVNPTEFURURcIiB8IFwiUEVORElOR19SRVNUT1JBVElPTlwiIHwgXCJVTktOT1dOX1RPX1NES19WRVJTSU9OXCIpXG5leHBvcnQgdHlwZSBDcmVhdGVkVGltZXN0YW1wID0gc3RyaW5nXG5leHBvcnQgdHlwZSBVcGRhdGVkVGltZXN0YW1wID0gc3RyaW5nXG5leHBvcnQgdHlwZSBBcm4gPSBzdHJpbmdcblxuLyoqXG4gKiBSZXNvdXJjZSBUeXBlIGRlZmluaXRpb24gZm9yIEFXUzo6UlRCRmFicmljOjpPdXRib3VuZEV4dGVybmFsTGluayBSZXNvdXJjZSBUeXBlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgX0FXU19SVEJGQUJSSUNfT1VUQk9VTkRFWFRFUk5BTExJTksge1xuVGFncz86IFRhZ3NcbkxpbmtJZD86IExpbmtJZFxuR2F0ZXdheUlkOiBHYXRld2F5SWRcblB1YmxpY0VuZHBvaW50OiBQdWJsaWNFbmRwb2ludFxuTGlua0F0dHJpYnV0ZXM/OiBMaW5rQXR0cmlidXRlc1xuTGlua0xvZ1NldHRpbmdzOiBMaW5rTG9nU2V0dGluZ3NcbkxpbmtTdGF0dXM/OiBMaW5rU3RhdHVzXG5DcmVhdGVkVGltZXN0YW1wPzogQ3JlYXRlZFRpbWVzdGFtcFxuVXBkYXRlZFRpbWVzdGFtcD86IFVwZGF0ZWRUaW1lc3RhbXBcbkFybj86IEFyblxufVxuLyoqXG4gKiBBIGtleS12YWx1ZSBwYWlyIHRvIGFzc29jaWF0ZSB3aXRoIGEgcmVzb3VyY2UuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGFnIHtcbi8qKlxuICogVGhlIGtleSBuYW1lIG9mIHRoZSB0YWcuIFlvdSBjYW4gc3BlY2lmeSBhIHZhbHVlIHRoYXQgaXMgMSB0byAxMjggVW5pY29kZSBjaGFyYWN0ZXJzIGluIGxlbmd0aCBhbmQgY2Fubm90IGJlIHByZWZpeGVkIHdpdGggYXdzOi4gWW91IGNhbiB1c2UgYW55IG9mIHRoZSBmb2xsb3dpbmcgY2hhcmFjdGVyczogdGhlIHNldCBvZiBVbmljb2RlIGxldHRlcnMsIGRpZ2l0cywgd2hpdGVzcGFjZSwgXywgLiwgLywgPSwgKywgYW5kIC0uIFxuICovXG5LZXk6IHN0cmluZ1xuLyoqXG4gKiBUaGUgdmFsdWUgZm9yIHRoZSB0YWcuIFlvdSBjYW4gc3BlY2lmeSBhIHZhbHVlIHRoYXQgaXMgMCB0byAyNTYgVW5pY29kZSBjaGFyYWN0ZXJzIGluIGxlbmd0aCBhbmQgY2Fubm90IGJlIHByZWZpeGVkIHdpdGggYXdzOi4gWW91IGNhbiB1c2UgYW55IG9mIHRoZSBmb2xsb3dpbmcgY2hhcmFjdGVyczogdGhlIHNldCBvZiBVbmljb2RlIGxldHRlcnMsIGRpZ2l0cywgd2hpdGVzcGFjZSwgXywgLiwgLywgPSwgKywgYW5kIC0uIFxuICovXG5WYWx1ZT86IHN0cmluZ1xufVxuZXhwb3J0IGludGVyZmFjZSBMaW5rQXR0cmlidXRlcyB7XG4vKipcbiAqIEBtaW5JdGVtcyAxXG4gKiBAbWF4SXRlbXMgMjAwXG4gKi9cblJlc3BvbmRlckVycm9yTWFza2luZz86IFJlc3BvbmRlckVycm9yTWFza2luZ0Zvckh0dHBDb2RlW11cbkN1c3RvbWVyUHJvdmlkZWRJZD86IHN0cmluZ1xufVxuZXhwb3J0IGludGVyZmFjZSBSZXNwb25kZXJFcnJvck1hc2tpbmdGb3JIdHRwQ29kZSB7XG5IdHRwQ29kZTogc3RyaW5nXG5BY3Rpb246IChcIk5PX0JJRFwiIHwgXCJQQVNTVEhST1VHSFwiKVxuLyoqXG4gKiBAbWluSXRlbXMgMVxuICogQG1heEl0ZW1zIDJcbiAqL1xuTG9nZ2luZ1R5cGVzOiBSZXNwb25kZXJFcnJvck1hc2tpbmdMb2dnaW5nVHlwZVtdXG5SZXNwb25zZUxvZ2dpbmdQZXJjZW50YWdlPzogbnVtYmVyXG59XG5leHBvcnQgaW50ZXJmYWNlIExpbmtMb2dTZXR0aW5ncyB7XG5BcHBsaWNhdGlvbkxvZ3M6IHtcbkxpbmtBcHBsaWNhdGlvbkxvZ1NhbXBsaW5nOiB7XG5FcnJvckxvZzogbnVtYmVyXG5GaWx0ZXJMb2c6IG51bWJlclxufVxufVxufVxuIl19

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

@@ -14,6 +14,12 @@ export type ClusterInstanceStorageConfig = {
  * @maxItems 1
  */
 export type ClusterInstanceStorageConfigs = ClusterInstanceStorageConfig[];
+/**
+ * A list of Kubernetes taints to apply to cluster nodes. Maximum of 50 taints.
+ *
+ * @maxItems 50
+ */
+export type ClusterKubernetesTaints = ClusterKubernetesTaint[];
 /**
  * The type of deep health check(s) to be performed on the instances in the SageMaker HyperPod cluster instance group.
  */
@@ -122,8 +128,10 @@ export interface VpcConfig {
  * Details of an instance group in a SageMaker HyperPod cluster.
  */
 export interface ClusterInstanceGroup {
+    CapacityRequirements?: ClusterCapacityRequirements;
     InstanceGroupName: InstanceGroupName;
     InstanceStorageConfigs?: ClusterInstanceStorageConfigs;
+    KubernetesConfig?: ClusterKubernetesConfig;
     LifeCycleConfig: ClusterLifeCycleConfig;
     /**
      * The Amazon Resource Name (ARN) of the training plan to use for this cluster instance group. For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see CreateTrainingPlan.
@@ -148,6 +156,23 @@ export interface ClusterInstanceGroup {
     InstanceType: InstanceType;
     ExecutionRole: ExecutionRole;
 }
+/**
+ * Specifies the capacity requirements configuration for an instance group
+ */
+export interface ClusterCapacityRequirements {
+    Spot?: ClusterSpotOptions;
+    OnDemand?: ClusterOnDemandOptions;
+}
+/**
+ * Options for Spot capacity
+ */
+export interface ClusterSpotOptions {
+}
+/**
+ * Options for OnDemand capacity
+ */
+export interface ClusterOnDemandOptions {
+}
 /**
  * Defines the configuration for attaching additional Amazon Elastic Block Store (EBS) volumes to the instances in the SageMaker HyperPod cluster instance group. The additional EBS volume is attached to each instance within the SageMaker HyperPod cluster instance group and mounted to /opt/sagemaker.
  */
@@ -159,6 +184,40 @@ export interface ClusterEbsVolumeConfig {
     VolumeKmsKeyId?: string;
     RootVolume?: boolean;
 }
+/**
+ * Kubernetes configuration for cluster nodes including labels and taints.
+ */
+export interface ClusterKubernetesConfig {
+    Labels?: ClusterKubernetesLabels;
+    Taints?: ClusterKubernetesTaints;
+}
+/**
+ * A map of Kubernetes labels to apply to cluster nodes.
+ */
+export interface ClusterKubernetesLabels {
+    /**
+     * This interface was referenced by `ClusterKubernetesLabels`'s JSON-Schema definition
+     * via the `patternProperty` "^.+$".
+     */
+    [k: string]: string;
+}
+/**
+ * A Kubernetes taint to apply to cluster nodes.
+ */
+export interface ClusterKubernetesTaint {
+    /**
+     * The value of the taint.
+     */
+    Value?: string;
+    /**
+     * The effect of the taint.
+     */
+    Effect: ("NoSchedule" | "PreferNoSchedule" | "NoExecute");
+    /**
+     * The key of the taint.
+     */
+    Key: string;
+}
 /**
  * The lifecycle configuration for a SageMaker HyperPod cluster.
  */

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

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-sagemaker-cluster.js","sourceRoot":"","sources":["aws-sagemaker-cluster.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The name of the instance group of a SageMaker HyperPod cluster.\n */\nexport type InstanceGroupName = string\n/**\n * Defines the configuration for attaching additional storage to the instances in the SageMaker HyperPod cluster instance group.\n */\nexport type ClusterInstanceStorageConfig = {\nEbsVolumeConfig?: ClusterEbsVolumeConfig\n}\n/**\n * The instance storage configuration for the instance group.\n * \n * @maxItems 1\n */\nexport type ClusterInstanceStorageConfigs = ClusterInstanceStorageConfig[]\n/**\n * The type of deep health check(s) to be performed on the instances in the SageMaker HyperPod cluster instance group.\n */\nexport type DeepHealthCheckType = (\"InstanceStress\" | \"InstanceConnectivity\")\n/**\n * Nodes will undergo advanced stress test to detect and replace faulty instances, based on the type of deep health check(s) passed in.\n */\nexport type OnStartDeepHealthChecks = DeepHealthCheckType[]\n/**\n * AMI Id to be used for launching EC2 instances - HyperPodPublicAmiId or CustomAmiId\n */\nexport type ImageId = string\n/**\n * An array that contains the alarms that SageMaker monitors to know whether to roll back the AMI update.\n */\nexport type AutoRollbackConfiguration = AlarmDetails[]\n/**\n * The instance type of the instance group of a SageMaker HyperPod cluster.\n */\nexport type InstanceType = string\n/**\n * The execution role for the instance group to assume.\n */\nexport type ExecutionRole = string\n/**\n * The instance groups of the SageMaker HyperPod cluster.\n * \n * @minItems 1\n */\nexport type ClusterInstanceGroupsList = ClusterInstanceGroup[]\n/**\n * The restricted instance groups of the SageMaker HyperPod cluster.\n * \n * @minItems 1\n */\nexport type ClusterRestrictedInstanceGroupsList = ClusterRestrictedInstanceGroup[]\n\n/**\n * Resource Type definition for AWS::SageMaker::Cluster\n */\nexport interface _AWS_SAGEMAKER_CLUSTER {\n/**\n * The Amazon Resource Name (ARN) of the HyperPod Cluster.\n */\nClusterArn?: string\nVpcConfig?: VpcConfig\n/**\n * If node auto-recovery is set to true, faulty nodes will be replaced or rebooted when a failure is detected. If set to false, nodes will be labelled when a fault is detected.\n */\nNodeRecovery?: (\"Automatic\" | \"None\")\nInstanceGroups?: ClusterInstanceGroupsList\nRestrictedInstanceGroups?: ClusterRestrictedInstanceGroupsList\nOrchestrator?: Orchestrator\n/**\n * The cluster role for the autoscaler to assume.\n */\nClusterRole?: string\n/**\n * Determines the scaling strategy for the SageMaker HyperPod cluster. When set to 'Continuous', enables continuous scaling which dynamically manages node provisioning. If the parameter is omitted, uses the standard scaling approach in previous release.\n */\nNodeProvisioningMode?: \"Continuous\"\n/**\n * The time at which the HyperPod cluster was created.\n */\nCreationTime?: string\n/**\n * The name of the HyperPod Cluster.\n */\nClusterName?: string\n/**\n * The failure message of the HyperPod Cluster.\n */\nFailureMessage?: string\nAutoScaling?: ClusterAutoScalingConfig\n/**\n * The status of the HyperPod Cluster.\n */\nClusterStatus?: (\"Creating\" | \"Deleting\" | \"Failed\" | \"InService\" | \"RollingBack\" | \"SystemUpdating\" | \"Updating\")\n/**\n * Custom tags for managing the SageMaker HyperPod cluster as an AWS resource. You can add tags to your cluster in the same way you add them in other AWS services that support tagging.\n * \n * @maxItems 50\n */\nTags?: Tag[]\nTieredStorageConfig?: TieredStorageConfig\n}\n/**\n * Specifies an Amazon Virtual Private Cloud (VPC) that your SageMaker jobs, hosted models, and compute resources have access to. You can control access to and from your resources by configuring a VPC.\n */\nexport interface VpcConfig {\n/**\n * The ID of the subnets in the VPC to which you want to connect your training job or model.\n * \n * @minItems 1\n * @maxItems 16\n */\nSubnets: string[]\n/**\n * The VPC security group IDs, in the form sg-xxxxxxxx. Specify the security groups for the VPC that is specified in the Subnets field.\n * \n * @minItems 1\n * @maxItems 5\n */\nSecurityGroupIds: string[]\n}\n/**\n * Details of an instance group in a SageMaker HyperPod cluster.\n */\nexport interface ClusterInstanceGroup {\nInstanceGroupName: InstanceGroupName\nInstanceStorageConfigs?: ClusterInstanceStorageConfigs\nLifeCycleConfig: ClusterLifeCycleConfig\n/**\n * The Amazon Resource Name (ARN) of the training plan to use for this cluster instance group. For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see CreateTrainingPlan.\n */\nTrainingPlanArn?: string\n/**\n * The number you specified to TreadsPerCore in CreateCluster for enabling or disabling multithreading. For instance types that support multithreading, you can specify 1 for disabling multithreading and 2 for enabling multithreading.\n */\nThreadsPerCore?: number\nOverrideVpcConfig?: VpcConfig\n/**\n * The number of instances you specified to add to the instance group of a SageMaker HyperPod cluster.\n */\nInstanceCount: number\nOnStartDeepHealthChecks?: OnStartDeepHealthChecks\nImageId?: ImageId\n/**\n * The number of instances that are currently in the instance group of a SageMaker HyperPod cluster.\n */\nCurrentCount?: number\nScheduledUpdateConfig?: ScheduledUpdateConfig\nInstanceType: InstanceType\nExecutionRole: ExecutionRole\n}\n/**\n * Defines the configuration for attaching additional Amazon Elastic Block Store (EBS) volumes to the instances in the SageMaker HyperPod cluster instance group. The additional EBS volume is attached to each instance within the SageMaker HyperPod cluster instance group and mounted to /opt/sagemaker.\n */\nexport interface ClusterEbsVolumeConfig {\n/**\n * The size in gigabytes (GB) of the additional EBS volume to be attached to the instances in the SageMaker HyperPod cluster instance group. The additional EBS volume is attached to each instance within the SageMaker HyperPod cluster instance group and mounted to /opt/sagemaker.\n */\nVolumeSizeInGB?: number\nVolumeKmsKeyId?: string\nRootVolume?: boolean\n}\n/**\n * The lifecycle configuration for a SageMaker HyperPod cluster.\n */\nexport interface ClusterLifeCycleConfig {\n/**\n * An Amazon S3 bucket path where your lifecycle scripts are stored.\n */\nSourceS3Uri: string\n/**\n * The file name of the entrypoint script of lifecycle scripts under SourceS3Uri. This entrypoint script runs during cluster creation.\n */\nOnCreate: string\n}\n/**\n * The configuration object of the schedule that SageMaker follows when updating the AMI.\n */\nexport interface ScheduledUpdateConfig {\n/**\n * A cron expression that specifies the schedule that SageMaker follows when updating the AMI.\n */\nScheduleExpression: string\nDeploymentConfig?: DeploymentConfig\n}\n/**\n * The configuration to use when updating the AMI versions.\n */\nexport interface DeploymentConfig {\nAutoRollbackConfiguration?: AutoRollbackConfiguration\nRollingUpdatePolicy?: RollingUpdatePolicy\n/**\n * The duration in seconds that SageMaker waits before updating more instances in the cluster.\n */\nWaitIntervalInSeconds?: number\n}\n/**\n * The details of the alarm to monitor during the AMI update.\n */\nexport interface AlarmDetails {\n/**\n * The name of the alarm.\n */\nAlarmName: string\n}\n/**\n * The policy that SageMaker uses when updating the AMI versions of the cluster.\n */\nexport interface RollingUpdatePolicy {\nMaximumBatchSize: CapacitySizeConfig\nRollbackMaximumBatchSize?: CapacitySizeConfig\n}\n/**\n * The configuration of the size measurements of the AMI update. Using this configuration, you can specify whether SageMaker should update your instance group by an amount or percentage of instances.\n */\nexport interface CapacitySizeConfig {\n/**\n * Specifies whether SageMaker should process the update by amount or percentage of instances.\n */\nType: string\n/**\n * Specifies the amount or percentage of instances SageMaker updates at a time.\n */\nValue: number\n}\n/**\n * Details of a restricted instance group in a SageMaker HyperPod cluster.\n */\nexport interface ClusterRestrictedInstanceGroup {\nOverrideVpcConfig?: VpcConfig\n/**\n * The number of instances you specified to add to the restricted instance group of a SageMaker HyperPod cluster.\n */\nInstanceCount: number\nOnStartDeepHealthChecks?: OnStartDeepHealthChecks\nEnvironmentConfig: EnvironmentConfig\nInstanceGroupName: InstanceGroupName\nInstanceStorageConfigs?: ClusterInstanceStorageConfigs\n/**\n * The number of instances that are currently in the restricted instance group of a SageMaker HyperPod cluster.\n */\nCurrentCount?: number\n/**\n * The Amazon Resource Name (ARN) of the training plan to use for this cluster restricted instance group. For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see CreateTrainingPlan.\n */\nTrainingPlanArn?: string\nInstanceType: InstanceType\n/**\n * The number you specified to TreadsPerCore in CreateCluster for enabling or disabling multithreading. For instance types that support multithreading, you can specify 1 for disabling multithreading and 2 for enabling multithreading.\n */\nThreadsPerCore?: number\nExecutionRole: ExecutionRole\n}\n/**\n * The configuration for the restricted instance groups (RIG) environment.\n */\nexport interface EnvironmentConfig {\nFSxLustreConfig?: FSxLustreConfig\n}\n/**\n * Configuration settings for an Amazon FSx for Lustre file system to be used with the cluster.\n */\nexport interface FSxLustreConfig {\n/**\n * The storage capacity of the FSx for Lustre file system, specified in gibibytes (GiB).\n */\nSizeInGiB: number\n/**\n * The throughput capacity of the FSx for Lustre file system, measured in MB/s per TiB of storage.\n */\nPerUnitStorageThroughput: number\n}\n/**\n * Specifies parameter(s) specific to the orchestrator, e.g. specify the EKS cluster.\n */\nexport interface Orchestrator {\nEks: ClusterOrchestratorEksConfig\n}\n/**\n * Specifies parameter(s) related to EKS as orchestrator, e.g. the EKS cluster nodes will attach to,\n */\nexport interface ClusterOrchestratorEksConfig {\n/**\n * The ARN of the EKS cluster, such as arn:aws:eks:us-west-2:123456789012:cluster/my-eks-cluster\n */\nClusterArn: string\n}\n/**\n * Configuration for cluster auto-scaling\n */\nexport interface ClusterAutoScalingConfig {\n/**\n * The auto-scaling mode for the cluster\n */\nMode: (\"Enable\" | \"Disable\")\n/**\n * The type of auto-scaler to use\n */\nAutoScalerType?: \"Karpenter\"\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * 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 -.\n */\nValue: string\n/**\n * 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 -.\n */\nKey: string\n}\n/**\n * Configuration for tiered storage in the SageMaker HyperPod cluster.\n */\nexport interface TieredStorageConfig {\n/**\n * The mode of tiered storage.\n */\nMode: (\"Enable\" | \"Disable\")\n/**\n * The percentage of instance memory to allocate for tiered storage.\n */\nInstanceMemoryAllocationPercentage?: number\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-sagemaker-cluster.js","sourceRoot":"","sources":["aws-sagemaker-cluster.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The name of the instance group of a SageMaker HyperPod cluster.\n */\nexport type InstanceGroupName = string\n/**\n * Defines the configuration for attaching additional storage to the instances in the SageMaker HyperPod cluster instance group.\n */\nexport type ClusterInstanceStorageConfig = {\nEbsVolumeConfig?: ClusterEbsVolumeConfig\n}\n/**\n * The instance storage configuration for the instance group.\n * \n * @maxItems 1\n */\nexport type ClusterInstanceStorageConfigs = ClusterInstanceStorageConfig[]\n/**\n * A list of Kubernetes taints to apply to cluster nodes. Maximum of 50 taints.\n * \n * @maxItems 50\n */\nexport type ClusterKubernetesTaints = ClusterKubernetesTaint[]\n/**\n * The type of deep health check(s) to be performed on the instances in the SageMaker HyperPod cluster instance group.\n */\nexport type DeepHealthCheckType = (\"InstanceStress\" | \"InstanceConnectivity\")\n/**\n * Nodes will undergo advanced stress test to detect and replace faulty instances, based on the type of deep health check(s) passed in.\n */\nexport type OnStartDeepHealthChecks = DeepHealthCheckType[]\n/**\n * AMI Id to be used for launching EC2 instances - HyperPodPublicAmiId or CustomAmiId\n */\nexport type ImageId = string\n/**\n * An array that contains the alarms that SageMaker monitors to know whether to roll back the AMI update.\n */\nexport type AutoRollbackConfiguration = AlarmDetails[]\n/**\n * The instance type of the instance group of a SageMaker HyperPod cluster.\n */\nexport type InstanceType = string\n/**\n * The execution role for the instance group to assume.\n */\nexport type ExecutionRole = string\n/**\n * The instance groups of the SageMaker HyperPod cluster.\n * \n * @minItems 1\n */\nexport type ClusterInstanceGroupsList = ClusterInstanceGroup[]\n/**\n * The restricted instance groups of the SageMaker HyperPod cluster.\n * \n * @minItems 1\n */\nexport type ClusterRestrictedInstanceGroupsList = ClusterRestrictedInstanceGroup[]\n\n/**\n * Resource Type definition for AWS::SageMaker::Cluster\n */\nexport interface _AWS_SAGEMAKER_CLUSTER {\n/**\n * The Amazon Resource Name (ARN) of the HyperPod Cluster.\n */\nClusterArn?: string\nVpcConfig?: VpcConfig\n/**\n * If node auto-recovery is set to true, faulty nodes will be replaced or rebooted when a failure is detected. If set to false, nodes will be labelled when a fault is detected.\n */\nNodeRecovery?: (\"Automatic\" | \"None\")\nInstanceGroups?: ClusterInstanceGroupsList\nRestrictedInstanceGroups?: ClusterRestrictedInstanceGroupsList\nOrchestrator?: Orchestrator\n/**\n * The cluster role for the autoscaler to assume.\n */\nClusterRole?: string\n/**\n * Determines the scaling strategy for the SageMaker HyperPod cluster. When set to 'Continuous', enables continuous scaling which dynamically manages node provisioning. If the parameter is omitted, uses the standard scaling approach in previous release.\n */\nNodeProvisioningMode?: \"Continuous\"\n/**\n * The time at which the HyperPod cluster was created.\n */\nCreationTime?: string\n/**\n * The name of the HyperPod Cluster.\n */\nClusterName?: string\n/**\n * The failure message of the HyperPod Cluster.\n */\nFailureMessage?: string\nAutoScaling?: ClusterAutoScalingConfig\n/**\n * The status of the HyperPod Cluster.\n */\nClusterStatus?: (\"Creating\" | \"Deleting\" | \"Failed\" | \"InService\" | \"RollingBack\" | \"SystemUpdating\" | \"Updating\")\n/**\n * Custom tags for managing the SageMaker HyperPod cluster as an AWS resource. You can add tags to your cluster in the same way you add them in other AWS services that support tagging.\n * \n * @maxItems 50\n */\nTags?: Tag[]\nTieredStorageConfig?: TieredStorageConfig\n}\n/**\n * Specifies an Amazon Virtual Private Cloud (VPC) that your SageMaker jobs, hosted models, and compute resources have access to. You can control access to and from your resources by configuring a VPC.\n */\nexport interface VpcConfig {\n/**\n * The ID of the subnets in the VPC to which you want to connect your training job or model.\n * \n * @minItems 1\n * @maxItems 16\n */\nSubnets: string[]\n/**\n * The VPC security group IDs, in the form sg-xxxxxxxx. Specify the security groups for the VPC that is specified in the Subnets field.\n * \n * @minItems 1\n * @maxItems 5\n */\nSecurityGroupIds: string[]\n}\n/**\n * Details of an instance group in a SageMaker HyperPod cluster.\n */\nexport interface ClusterInstanceGroup {\nCapacityRequirements?: ClusterCapacityRequirements\nInstanceGroupName: InstanceGroupName\nInstanceStorageConfigs?: ClusterInstanceStorageConfigs\nKubernetesConfig?: ClusterKubernetesConfig\nLifeCycleConfig: ClusterLifeCycleConfig\n/**\n * The Amazon Resource Name (ARN) of the training plan to use for this cluster instance group. For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see CreateTrainingPlan.\n */\nTrainingPlanArn?: string\n/**\n * The number you specified to TreadsPerCore in CreateCluster for enabling or disabling multithreading. For instance types that support multithreading, you can specify 1 for disabling multithreading and 2 for enabling multithreading.\n */\nThreadsPerCore?: number\nOverrideVpcConfig?: VpcConfig\n/**\n * The number of instances you specified to add to the instance group of a SageMaker HyperPod cluster.\n */\nInstanceCount: number\nOnStartDeepHealthChecks?: OnStartDeepHealthChecks\nImageId?: ImageId\n/**\n * The number of instances that are currently in the instance group of a SageMaker HyperPod cluster.\n */\nCurrentCount?: number\nScheduledUpdateConfig?: ScheduledUpdateConfig\nInstanceType: InstanceType\nExecutionRole: ExecutionRole\n}\n/**\n * Specifies the capacity requirements configuration for an instance group\n */\nexport interface ClusterCapacityRequirements {\nSpot?: ClusterSpotOptions\nOnDemand?: ClusterOnDemandOptions\n}\n/**\n * Options for Spot capacity\n */\nexport interface ClusterSpotOptions {\n\n}\n/**\n * Options for OnDemand capacity\n */\nexport interface ClusterOnDemandOptions {\n\n}\n/**\n * Defines the configuration for attaching additional Amazon Elastic Block Store (EBS) volumes to the instances in the SageMaker HyperPod cluster instance group. The additional EBS volume is attached to each instance within the SageMaker HyperPod cluster instance group and mounted to /opt/sagemaker.\n */\nexport interface ClusterEbsVolumeConfig {\n/**\n * The size in gigabytes (GB) of the additional EBS volume to be attached to the instances in the SageMaker HyperPod cluster instance group. The additional EBS volume is attached to each instance within the SageMaker HyperPod cluster instance group and mounted to /opt/sagemaker.\n */\nVolumeSizeInGB?: number\nVolumeKmsKeyId?: string\nRootVolume?: boolean\n}\n/**\n * Kubernetes configuration for cluster nodes including labels and taints.\n */\nexport interface ClusterKubernetesConfig {\nLabels?: ClusterKubernetesLabels\nTaints?: ClusterKubernetesTaints\n}\n/**\n * A map of Kubernetes labels to apply to cluster nodes.\n */\nexport interface ClusterKubernetesLabels {\n/**\n * This interface was referenced by `ClusterKubernetesLabels`'s JSON-Schema definition\n * via the `patternProperty` \"^.+$\".\n */\n[k: string]: string\n}\n/**\n * A Kubernetes taint to apply to cluster nodes.\n */\nexport interface ClusterKubernetesTaint {\n/**\n * The value of the taint.\n */\nValue?: string\n/**\n * The effect of the taint.\n */\nEffect: (\"NoSchedule\" | \"PreferNoSchedule\" | \"NoExecute\")\n/**\n * The key of the taint.\n */\nKey: string\n}\n/**\n * The lifecycle configuration for a SageMaker HyperPod cluster.\n */\nexport interface ClusterLifeCycleConfig {\n/**\n * An Amazon S3 bucket path where your lifecycle scripts are stored.\n */\nSourceS3Uri: string\n/**\n * The file name of the entrypoint script of lifecycle scripts under SourceS3Uri. This entrypoint script runs during cluster creation.\n */\nOnCreate: string\n}\n/**\n * The configuration object of the schedule that SageMaker follows when updating the AMI.\n */\nexport interface ScheduledUpdateConfig {\n/**\n * A cron expression that specifies the schedule that SageMaker follows when updating the AMI.\n */\nScheduleExpression: string\nDeploymentConfig?: DeploymentConfig\n}\n/**\n * The configuration to use when updating the AMI versions.\n */\nexport interface DeploymentConfig {\nAutoRollbackConfiguration?: AutoRollbackConfiguration\nRollingUpdatePolicy?: RollingUpdatePolicy\n/**\n * The duration in seconds that SageMaker waits before updating more instances in the cluster.\n */\nWaitIntervalInSeconds?: number\n}\n/**\n * The details of the alarm to monitor during the AMI update.\n */\nexport interface AlarmDetails {\n/**\n * The name of the alarm.\n */\nAlarmName: string\n}\n/**\n * The policy that SageMaker uses when updating the AMI versions of the cluster.\n */\nexport interface RollingUpdatePolicy {\nMaximumBatchSize: CapacitySizeConfig\nRollbackMaximumBatchSize?: CapacitySizeConfig\n}\n/**\n * The configuration of the size measurements of the AMI update. Using this configuration, you can specify whether SageMaker should update your instance group by an amount or percentage of instances.\n */\nexport interface CapacitySizeConfig {\n/**\n * Specifies whether SageMaker should process the update by amount or percentage of instances.\n */\nType: string\n/**\n * Specifies the amount or percentage of instances SageMaker updates at a time.\n */\nValue: number\n}\n/**\n * Details of a restricted instance group in a SageMaker HyperPod cluster.\n */\nexport interface ClusterRestrictedInstanceGroup {\nOverrideVpcConfig?: VpcConfig\n/**\n * The number of instances you specified to add to the restricted instance group of a SageMaker HyperPod cluster.\n */\nInstanceCount: number\nOnStartDeepHealthChecks?: OnStartDeepHealthChecks\nEnvironmentConfig: EnvironmentConfig\nInstanceGroupName: InstanceGroupName\nInstanceStorageConfigs?: ClusterInstanceStorageConfigs\n/**\n * The number of instances that are currently in the restricted instance group of a SageMaker HyperPod cluster.\n */\nCurrentCount?: number\n/**\n * The Amazon Resource Name (ARN) of the training plan to use for this cluster restricted instance group. For more information about how to reserve GPU capacity for your SageMaker HyperPod clusters using Amazon SageMaker Training Plan, see CreateTrainingPlan.\n */\nTrainingPlanArn?: string\nInstanceType: InstanceType\n/**\n * The number you specified to TreadsPerCore in CreateCluster for enabling or disabling multithreading. For instance types that support multithreading, you can specify 1 for disabling multithreading and 2 for enabling multithreading.\n */\nThreadsPerCore?: number\nExecutionRole: ExecutionRole\n}\n/**\n * The configuration for the restricted instance groups (RIG) environment.\n */\nexport interface EnvironmentConfig {\nFSxLustreConfig?: FSxLustreConfig\n}\n/**\n * Configuration settings for an Amazon FSx for Lustre file system to be used with the cluster.\n */\nexport interface FSxLustreConfig {\n/**\n * The storage capacity of the FSx for Lustre file system, specified in gibibytes (GiB).\n */\nSizeInGiB: number\n/**\n * The throughput capacity of the FSx for Lustre file system, measured in MB/s per TiB of storage.\n */\nPerUnitStorageThroughput: number\n}\n/**\n * Specifies parameter(s) specific to the orchestrator, e.g. specify the EKS cluster.\n */\nexport interface Orchestrator {\nEks: ClusterOrchestratorEksConfig\n}\n/**\n * Specifies parameter(s) related to EKS as orchestrator, e.g. the EKS cluster nodes will attach to,\n */\nexport interface ClusterOrchestratorEksConfig {\n/**\n * The ARN of the EKS cluster, such as arn:aws:eks:us-west-2:123456789012:cluster/my-eks-cluster\n */\nClusterArn: string\n}\n/**\n * Configuration for cluster auto-scaling\n */\nexport interface ClusterAutoScalingConfig {\n/**\n * The auto-scaling mode for the cluster\n */\nMode: (\"Enable\" | \"Disable\")\n/**\n * The type of auto-scaler to use\n */\nAutoScalerType?: \"Karpenter\"\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * 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 -.\n */\nValue: string\n/**\n * 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 -.\n */\nKey: string\n}\n/**\n * Configuration for tiered storage in the SageMaker HyperPod cluster.\n */\nexport interface TieredStorageConfig {\n/**\n * The mode of tiered storage.\n */\nMode: (\"Enable\" | \"Disable\")\n/**\n * The percentage of instance memory to allocate for tiered storage.\n */\nInstanceMemoryAllocationPercentage?: number\n}\n"]}

package/lib/types/cfn-resource-types/aws-secretsmanager-rotationschedule.d.ts

@@ -7,10 +7,18 @@ export interface _AWS_SECRETSMANAGER_ROTATIONSCHEDULE {
      * The ARN or name of the secret to rotate.
      */
     SecretId: string;
+    /**
+     * The list of metadata needed to successfully rotate a managed external secret.
+     */
+    ExternalSecretRotationMetadata?: ExternalSecretRotationMetadataItem[];
     /**
      * The ARN of the secret.
      */
     Id?: string;
+    /**
+     * The ARN of the IAM role that is used by Secrets Manager to rotate a managed external secret.
+     */
+    ExternalSecretRotationRoleArn?: string;
     /**
      * Specifies whether to rotate the secret immediately or wait until the next scheduled rotation window.
      */
@@ -70,6 +78,19 @@ export interface HostedRotationLambda {
      */
     VpcSubnetIds?: string;
 }
+/**
+ * The metadata needed to successfully rotate a managed external secret. Each metadata item is a key and value pair of strings in a JSON text string.
+ */
+export interface ExternalSecretRotationMetadataItem {
+    /**
+     * The value for the metadata item. You can specify a value that's 1 to 2048 characters in length.
+     */
+    Value: string;
+    /**
+     * The key name of the metadata item. You can specify a value that's 1 to 256 characters in length.
+     */
+    Key: string;
+}
 /**
  * A structure that defines the rotation configuration for this secret.
  */

package/lib/types/cfn-resource-types/aws-secretsmanager-rotationschedule.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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