agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-ssm/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.services.ssm"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.AWS.SSM"
+    },
+    "python": {
+      "module": "aws_cdk.aws_ssm"
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-ssm/README.md

@@ -0,0 +1,228 @@
+# AWS Systems Manager Construct Library
+
+This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aws-cdk) project.
+
+## Using existing SSM Parameters in your CDK app
+
+You can reference existing SSM Parameter Store values that you want to use in
+your CDK app by using `ssm.StringParameter.fromStringParameterAttributes`:
+
+```ts
+const parameterVersion = Token.asNumber({ Ref: 'MyParameter' });
+
+// Retrieve the latest value of the non-secret parameter
+// with name "/My/String/Parameter".
+const stringValue = ssm.StringParameter.fromStringParameterAttributes(this, 'MyValue', {
+  parameterName: '/My/Public/Parameter',
+  // 'version' can be specified but is optional.
+}).stringValue;
+const stringValueVersionFromToken = ssm.StringParameter.fromStringParameterAttributes(this, 'MyValueVersionFromToken', {
+  parameterName: '/My/Public/Parameter',
+  // parameter version from token
+  version: parameterVersion,
+}).stringValue;
+
+// Retrieve a specific version of the secret (SecureString) parameter.
+// 'version' is always required.
+const secretValue = ssm.StringParameter.fromSecureStringParameterAttributes(this, 'MySecureValue', {
+  parameterName: '/My/Secret/Parameter',
+  version: 5,
+});
+const secretValueVersionFromToken = ssm.StringParameter.fromSecureStringParameterAttributes(this, 'MySecureValueVersionFromToken', {
+  parameterName: '/My/Secret/Parameter',
+  // parameter version from token
+  version: parameterVersion,
+});
+```
+
+You can also reference an existing SSM Parameter Store value that matches an
+[AWS specific parameter type](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-specific-parameter-types):
+
+```ts
+ssm.StringParameter.valueForTypedStringParameterV2(this, '/My/Public/Parameter', ssm.ParameterValueType.AWS_EC2_IMAGE_ID);
+```
+
+To do the same for a SSM Parameter Store value that is stored as a list:
+
+```ts
+ssm.StringListParameter.valueForTypedListParameter(this, '/My/Public/Parameter', ssm.ParameterValueType.AWS_EC2_IMAGE_ID);
+```
+
+### Lookup existing parameters
+
+You can also use an existing parameter by looking up the parameter from the AWS environment.
+This method uses AWS API calls to lookup the value from SSM during synthesis.
+
+```ts
+const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter');
+```
+
+The result of the `StringParameter.valueFromLookup()` operation will be written to a file
+called `cdk.context.json`. You must commit this file to source control so
+that the lookup values are available in non-privileged environments such
+as CI build steps, and to ensure your template builds are repeatable.
+
+To customize the cache key, use the `additionalCacheKey` property of the `options` parameter.
+This allows you to have multiple lookups with the same parameters
+cache their values separately. This can be useful if you want to
+scope the context variable to a construct (ie, using `additionalCacheKey: this.node.path`),
+so that if the value in the cache needs to be updated, it does not need to be updated
+for all constructs at the same time.
+
+```ts
+const stringValue = ssm.StringParameter.valueFromLookup(this, '/My/Public/Parameter', undefined, { additionalCacheKey: this.node.path });
+```
+
+When using `valueFromLookup` an initial value of 'dummy-value-for-${parameterName}'
+(`dummy-value-for-/My/Public/Parameter` in the above example)
+is returned prior to the lookup being performed. This can lead to errors if you are using this
+value in places that require a certain format. For example if you have stored the ARN for a SNS
+topic in a SSM Parameter which you want to lookup and provide to `Topic.fromTopicArn()`
+
+```ts
+const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/topic/arn');
+sns.Topic.fromTopicArn(this, 'Topic', arnLookup);
+```
+
+Initially `arnLookup` will be equal to `dummy-value-for-/my/topic/arn` which will cause
+`Topic.fromTopicArn` to throw an error indicating that the value is not in `arn` format.
+
+For these use cases you need to handle the `dummy-value` in your code. For example:
+
+```ts
+const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/topic/arn');
+let arnLookupValue: string;
+if (arnLookup.includes('dummy-value')) {
+	arnLookupValue = this.formatArn({
+	service: 'sns',
+	resource: 'topic',
+	resourceName: arnLookup,
+	});
+
+} else {
+	arnLookupValue = arnLookup;
+}
+
+sns.Topic.fromTopicArn(this, 'Topic', arnLookupValue);
+```
+
+Alternatively, if the property supports tokens you can convert the parameter value into a token
+to be resolved _after_ the lookup has been completed.
+
+```ts
+const arnLookup = ssm.StringParameter.valueFromLookup(this, '/my/role/arn');
+iam.Role.fromRoleArn(this, 'role', Lazy.string({ produce: () => arnLookup }));
+```
+
+### cross-account SSM Parameters sharing
+
+AWS Systems Manager (SSM) Parameter Store supports cross-account sharing of parameters using the AWS Resource Access Manager (AWS RAM)
+service. In a multi-account environment, this feature enables accounts (referred to as "consuming accounts") to access and retrieve
+parameter values that are shared by other accounts (referred to as "sharing accounts"). To reference and use a shared SSM parameter
+in a consuming account, the `fromStringParameterArn()` method can be employed.
+
+The `fromStringParameterArn()` method provides a way for consuming accounts to create an instance of the StringParameter
+class from the Amazon Resource Name (ARN) of a shared SSM parameter. This allows the consuming account to retrieve and utilize the
+parameter value, even though the parameter itself is owned and managed by a different sharing account.
+
+```ts
+const sharingParameterArn = 'arn:aws:ssm:us-east-1:1234567890:parameter/dummyName';
+const sharedParam = ssm.StringParameter.fromStringParameterArn(this, 'SharedParam', sharingParameterArn);
+// the value can be accessed via sharedParam.stringValue
+```
+
+Things to note:
+
+- The account that owns the AWS Systems Manager (SSM) parameter and wants to share it with other accounts (referred to as the "sharing account") must create the parameter in the advanced tier. This is a prerequisite for sharing SSM parameters across accounts.
+
+- After creating the parameter in the advanced tier, the sharing account needs to set up a resource share using AWS Resource Access Manager (RAM). This resource share will specify the SSM parameter(s) to be shared and the accounts (referred to as "consuming accounts") with which the parameter(s) should be shared.
+
+- Once the resource share is created by the sharing account, the consuming account(s) will receive an invitation to join the resource share. For the consuming account(s) to access and use the shared SSM parameter(s), they must accept the resource share invitation from the sharing account.
+
+- The AWS Systems Manager Parameter Store parameter being referenced must be located in the same AWS region as the AWS CDK stack that is consuming or using the parameter.
+
+In summary, the process involves three main steps:
+
+1. The sharing account creates the SSM parameter(s) in the advanced tier.
+
+2. The sharing account creates a resource share using AWS RAM, specifying the SSM parameter(s) and the consuming account(s).
+
+3. The consuming account(s) accept the resource share invitation to gain access to the shared SSM parameter(s).
+
+This cross-account sharing mechanism allows for centralized management and distribution of configuration data (stored as SSM parameters) across multiple AWS accounts within an organization or between different organizations.
+
+Read [Working with shared parameters](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html) for more details.
+
+## Creating new SSM Parameters in your CDK app
+
+You can create either `ssm.StringParameter` or `ssm.StringListParameter`s in
+a CDK app. These are public (not secret) values. Parameters of type
+*SecureString* cannot be created directly from a CDK application; if you want
+to provision secrets automatically, use Secrets Manager Secrets (see the
+`aws-cdk-lib/aws-secretsmanager` package).
+
+```ts
+new ssm.StringParameter(this, 'Parameter', {
+  allowedPattern: '.*',
+  description: 'The value Foo',
+  parameterName: 'FooParameter',
+  stringValue: 'Foo',
+  tier: ssm.ParameterTier.ADVANCED,
+});
+```
+
+```ts
+// Create a new SSM Parameter holding a String
+const param = new ssm.StringParameter(this, 'StringParameter', {
+  // description: 'Some user-friendly description',
+  // name: 'ParameterName',
+  stringValue: 'Initial parameter value',
+  // allowedPattern: '.*',
+});
+
+// Grant read access to some Role
+declare const role: iam.IRole;
+param.grantRead(role);
+
+// Create a new SSM Parameter holding a StringList
+const listParameter = new ssm.StringListParameter(this, 'StringListParameter', {
+  // description: 'Some user-friendly description',
+  // name: 'ParameterName',
+  stringListValue: ['Initial parameter value A', 'Initial parameter value B'],
+  // allowedPattern: '.*',
+});
+```
+
+When specifying an `allowedPattern`, the values provided as string literals
+are validated against the pattern and an exception is raised if a value
+provided does not comply.
+
+## Using Tokens in parameter name
+
+When using [CDK Tokens](https://docs.aws.amazon.com/cdk/v2/guide/tokens.html) in parameter name,
+you need to explicitly set the `simpleName` property. Setting `simpleName` to an incorrect boolean
+value may result in unexpected behaviours, such as having duplicate '/' in the parameter ARN
+or missing a '/' in the parameter ARN.
+
+`simpleName` is used to indicates whether the parameter name is a simple name. A parameter name
+without any '/' is considered a simple name, thus you should set `simpleName` to `true`.
+If the parameter name includes '/', set `simpleName` to `false`.
+
+```ts
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+
+const simpleParameter = new ssm.StringParameter(this, 'StringParameter', {
+  // the parameter name doesn't contain any '/'
+  parameterName: 'parameter',
+  stringValue: 'SOME_VALUE',
+  simpleName: true, // set `simpleName` to true
+});
+
+declare const func: lambda.IFunction;
+const nonSimpleParameter = new ssm.StringParameter(this, 'StringParameter', {
+  // the parameter name contains '/'
+  parameterName: `/${func.functionName}/my/app/param`,
+  stringValue: 'SOME_VALUE',
+  simpleName: false, // set `simpleName` to false
+});
+```

cdk/node_modules/aws-cdk-lib/aws-ssm/grants.json

@@ -0,0 +1,19 @@
+{
+  "resources": {
+    "Parameter": {
+      "hasResourcePolicy": true,
+      "grants": {
+        "read": {
+          "actions": [
+            "ssm:DescribeParameters",
+            "ssm:GetParameters",
+            "ssm:GetParameter",
+            "ssm:GetParameterHistory"
+          ],
+          "keyActions": ["kms:Decrypt"],
+          "docSummary": "The encryption key that is used to encrypt this parameter."
+        }
+      }
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-ssm/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

cdk/node_modules/aws-cdk-lib/aws-ssm/index.js

@@ -0,0 +1 @@
+"use strict";var __createBinding=exports&&exports.__createBinding||(Object.create?(function(o,m,k,k2){k2===void 0&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);(!desc||("get"in desc?!m.__esModule:desc.writable||desc.configurable))&&(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}):(function(o,m,k,k2){k2===void 0&&(k2=k),o[k2]=m[k]})),__exportStar=exports&&exports.__exportStar||function(m,exports2){for(var p in m)p!=="default"&&!Object.prototype.hasOwnProperty.call(exports2,p)&&__createBinding(exports2,m,p)};Object.defineProperty(exports,"__esModule",{value:!0});var _noFold;exports.ParameterValueType=void 0,Object.defineProperty(exports,_noFold="ParameterValueType",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ParameterValueType;return Object.defineProperty(exports,_noFold="ParameterValueType",{enumerable:!0,configurable:!0,value}),value}}),exports.ParameterType=void 0,Object.defineProperty(exports,_noFold="ParameterType",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ParameterType;return Object.defineProperty(exports,_noFold="ParameterType",{enumerable:!0,configurable:!0,value}),value}}),exports.ParameterDataType=void 0,Object.defineProperty(exports,_noFold="ParameterDataType",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ParameterDataType;return Object.defineProperty(exports,_noFold="ParameterDataType",{enumerable:!0,configurable:!0,value}),value}}),exports.ParameterTier=void 0,Object.defineProperty(exports,_noFold="ParameterTier",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").ParameterTier;return Object.defineProperty(exports,_noFold="ParameterTier",{enumerable:!0,configurable:!0,value}),value}}),exports.StringParameter=void 0,Object.defineProperty(exports,_noFold="StringParameter",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").StringParameter;return Object.defineProperty(exports,_noFold="StringParameter",{enumerable:!0,configurable:!0,value}),value}}),exports.StringListParameter=void 0,Object.defineProperty(exports,_noFold="StringListParameter",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").StringListParameter;return Object.defineProperty(exports,_noFold="StringListParameter",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnAssociation=void 0,Object.defineProperty(exports,_noFold="CfnAssociation",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnAssociation;return Object.defineProperty(exports,_noFold="CfnAssociation",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnDocument=void 0,Object.defineProperty(exports,_noFold="CfnDocument",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnDocument;return Object.defineProperty(exports,_noFold="CfnDocument",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnMaintenanceWindow=void 0,Object.defineProperty(exports,_noFold="CfnMaintenanceWindow",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnMaintenanceWindow;return Object.defineProperty(exports,_noFold="CfnMaintenanceWindow",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnMaintenanceWindowTarget=void 0,Object.defineProperty(exports,_noFold="CfnMaintenanceWindowTarget",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnMaintenanceWindowTarget;return Object.defineProperty(exports,_noFold="CfnMaintenanceWindowTarget",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnMaintenanceWindowTask=void 0,Object.defineProperty(exports,_noFold="CfnMaintenanceWindowTask",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnMaintenanceWindowTask;return Object.defineProperty(exports,_noFold="CfnMaintenanceWindowTask",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnParameter=void 0,Object.defineProperty(exports,_noFold="CfnParameter",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnParameter;return Object.defineProperty(exports,_noFold="CfnParameter",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnPatchBaseline=void 0,Object.defineProperty(exports,_noFold="CfnPatchBaseline",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnPatchBaseline;return Object.defineProperty(exports,_noFold="CfnPatchBaseline",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnResourceDataSync=void 0,Object.defineProperty(exports,_noFold="CfnResourceDataSync",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnResourceDataSync;return Object.defineProperty(exports,_noFold="CfnResourceDataSync",{enumerable:!0,configurable:!0,value}),value}}),exports.CfnResourcePolicy=void 0,Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,get:()=>{var value=require("./lib").CfnResourcePolicy;return Object.defineProperty(exports,_noFold="CfnResourcePolicy",{enumerable:!0,configurable:!0,value}),value}});

cdk/node_modules/aws-cdk-lib/aws-ssm/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parameter';
+export * from './ssm.generated';

cdk/node_modules/aws-cdk-lib/aws-ssm/lib/parameter.d.ts

@@ -0,0 +1,511 @@
+import type { Construct } from 'constructs';
+import type { IParameterRef, ParameterReference } from './ssm.generated';
+import * as iam from '../../aws-iam';
+import type { GrantOnKeyResult, IEncryptedResource, IGrantable } from '../../aws-iam';
+import type * as kms from '../../aws-kms';
+import type { IResource } from '../../core';
+import { Resource } from '../../core';
+/**
+ * An SSM Parameter reference.
+ */
+export interface IParameter extends IResource, IParameterRef {
+    /**
+     * The ARN of the SSM Parameter resource.
+     * @attribute
+     */
+    readonly parameterArn: string;
+    /**
+     * The name of the SSM Parameter resource.
+     * @attribute
+     */
+    readonly parameterName: string;
+    /**
+     * The type of the SSM Parameter resource.
+     * @attribute
+     */
+    readonly parameterType: string;
+    /**
+     * Grants read (DescribeParameter, GetParameters, GetParameter, GetParameterHistory) permissions on the SSM Parameter.
+     *
+     * @param grantee the role to be granted read-only access to the parameter.
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Grants write (PutParameter) permissions on the SSM Parameter.
+     *
+     * @param grantee the role to be granted write access to the parameter.
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * A String SSM Parameter.
+ */
+export interface IStringParameter extends IParameter {
+    /**
+     * The parameter value. Value must not nest another parameter. Do not use {{}} in the value.
+     *
+     * @attribute Value
+     */
+    readonly stringValue: string;
+}
+/**
+ * A StringList SSM Parameter.
+ */
+export interface IStringListParameter extends IParameter {
+    /**
+     * The parameter value. Value must not nest another parameter. Do not use {{}} in the value. Values in the array
+     * cannot contain commas (``,``).
+     *
+     * @attribute Value
+     */
+    readonly stringListValue: string[];
+}
+/**
+ * Properties needed to create a new SSM Parameter.
+ */
+export interface ParameterOptions {
+    /**
+     * A regular expression used to validate the parameter value. For example, for String types with values restricted to
+     * numbers, you can specify the following: ``^\d+$``
+     *
+     * @default no validation is performed
+     */
+    readonly allowedPattern?: string;
+    /**
+     * Information about the parameter that you want to add to the system.
+     *
+     * @default none
+     */
+    readonly description?: string;
+    /**
+     * The name of the parameter.
+     *
+     * @default - a name will be generated by CloudFormation
+     */
+    readonly parameterName?: string;
+    /**
+     * Indicates whether the parameter name is a simple name. A parameter name
+     * without any "/" is considered a simple name. If the parameter name includes
+     * "/", setting simpleName to true might cause unintended issues such
+     * as duplicate "/" in the resulting ARN.
+     *
+     * This is required only if `parameterName` is a token, which means we
+     * are unable to detect if the name is simple or "path-like" for the purpose
+     * of rendering SSM parameter ARNs.
+     *
+     * If `parameterName` is not specified, `simpleName` must be `true` (or
+     * undefined) since the name generated by AWS CloudFormation is always a
+     * simple name.
+     *
+     * @default - auto-detect based on `parameterName`
+     */
+    readonly simpleName?: boolean;
+    /**
+     * The tier of the string parameter
+     *
+     * @default - undefined
+     */
+    readonly tier?: ParameterTier;
+}
+/**
+ * Properties needed to create a String SSM parameter.
+ */
+export interface StringParameterProps extends ParameterOptions {
+    /**
+     * The value of the parameter. It may not reference another parameter and ``{{}}`` cannot be used in the value.
+     */
+    readonly stringValue: string;
+    /**
+     * The type of the string parameter
+     *
+     * @default ParameterType.STRING
+     * @deprecated - type will always be 'String'
+     */
+    readonly type?: ParameterType;
+    /**
+     * The data type of the parameter, such as `text` or `aws:ec2:image`.
+     *
+     * @default ParameterDataType.TEXT
+     */
+    readonly dataType?: ParameterDataType;
+}
+/**
+ * Properties needed to create a StringList SSM Parameter
+ */
+export interface StringListParameterProps extends ParameterOptions {
+    /**
+     * The values of the parameter. It may not reference another parameter and ``{{}}`` cannot be used in the value.
+     */
+    readonly stringListValue: string[];
+}
+/**
+ * Basic features shared across all types of SSM Parameters.
+ */
+declare abstract class ParameterBase extends Resource implements IParameter, IEncryptedResource {
+    abstract readonly parameterArn: string;
+    abstract readonly parameterName: string;
+    abstract readonly parameterType: string;
+    /**
+     * The encryption key that is used to encrypt this parameter.
+     *
+     * @default - default master key
+     */
+    readonly encryptionKey?: kms.IKey;
+    grantOnKey(grantee: IGrantable, ...actions: string[]): GrantOnKeyResult;
+    get parameterRef(): ParameterReference;
+    /**
+     * [disable-awslint:no-grants]
+     */
+    grantRead(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * [disable-awslint:no-grants]
+     */
+    grantWrite(grantee: iam.IGrantable): iam.Grant;
+}
+/**
+ * The type of CFN SSM Parameter
+ *
+ * Using specific types can be helpful in catching invalid values
+ * at the start of creating or updating a stack. CloudFormation validates
+ * the values against existing values in the account.
+ *
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types
+ */
+export declare enum ParameterValueType {
+    /**
+     * String
+     */
+    STRING = "String",
+    /**
+     * An Availability Zone, such as us-west-2a.
+     */
+    AWS_EC2_AVAILABILITYZONE_NAME = "AWS::EC2::AvailabilityZone::Name",
+    /**
+     * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867.
+     */
+    AWS_EC2_IMAGE_ID = "AWS::EC2::Image::Id",
+    /**
+     * An Amazon EC2 instance ID, such as i-1e731a32.
+     */
+    AWS_EC2_INSTANCE_ID = "AWS::EC2::Instance::Id",
+    /**
+     * An Amazon EC2 key pair name.
+     */
+    AWS_EC2_KEYPAIR_KEYNAME = "AWS::EC2::KeyPair::KeyName",
+    /**
+     * An EC2-Classic or default VPC security group name, such as my-sg-abc.
+     */
+    AWS_EC2_SECURITYGROUP_GROUPNAME = "AWS::EC2::SecurityGroup::GroupName",
+    /**
+     * A security group ID, such as sg-a123fd85.
+     */
+    AWS_EC2_SECURITYGROUP_ID = "AWS::EC2::SecurityGroup::Id",
+    /**
+     * A subnet ID, such as subnet-123a351e.
+     */
+    AWS_EC2_SUBNET_ID = "AWS::EC2::Subnet::Id",
+    /**
+     * An Amazon EBS volume ID, such as vol-3cdd3f56.
+     */
+    AWS_EC2_VOLUME_ID = "AWS::EC2::Volume::Id",
+    /**
+     * A VPC ID, such as vpc-a123baa3.
+     */
+    AWS_EC2_VPC_ID = "AWS::EC2::VPC::Id",
+    /**
+     * An Amazon Route 53 hosted zone ID, such as Z23YXV4OVPL04A.
+     */
+    AWS_ROUTE53_HOSTEDZONE_ID = "AWS::Route53::HostedZone::Id"
+}
+/**
+ * SSM parameter type
+ * @deprecated these types are no longer used
+ */
+export declare enum ParameterType {
+    /**
+     * String
+     */
+    STRING = "String",
+    /**
+     * Secure String
+     *
+     * Parameter Store uses an AWS Key Management Service (KMS) customer master key (CMK) to encrypt the parameter value.
+     * Parameters of type SecureString cannot be created directly from a CDK application.
+     */
+    SECURE_STRING = "SecureString",
+    /**
+     * String List
+     */
+    STRING_LIST = "StringList",
+    /**
+     * An Amazon EC2 image ID, such as ami-0ff8a91507f77f867
+     */
+    AWS_EC2_IMAGE_ID = "AWS::EC2::Image::Id"
+}
+/**
+ * SSM parameter data type
+ */
+export declare enum ParameterDataType {
+    /**
+     * Text
+     */
+    TEXT = "text",
+    /**
+     * Aws Ec2 Image
+     */
+    AWS_EC2_IMAGE = "aws:ec2:image"
+}
+/**
+ * SSM parameter tier
+ */
+export declare enum ParameterTier {
+    /**
+     * String
+     */
+    ADVANCED = "Advanced",
+    /**
+     * String
+     */
+    INTELLIGENT_TIERING = "Intelligent-Tiering",
+    /**
+     * String
+     */
+    STANDARD = "Standard"
+}
+/**
+ * Common attributes for string parameters.
+ */
+export interface CommonStringParameterAttributes {
+    /**
+     * The name of the parameter store value.
+     *
+     * This value can be a token or a concrete string. If it is a concrete string
+     * and includes "/" it must also be prefixed with a "/" (fully-qualified).
+     */
+    readonly parameterName: string;
+    /**
+     * Indicates whether the parameter name is a simple name. A parameter name
+     * without any "/" is considered a simple name. If the parameter name includes
+     * "/", setting simpleName to true might cause unintended issues such
+     * as duplicate "/" in the resulting ARN.
+     *
+     * This is required only if `parameterName` is a token, which means we
+     * are unable to detect if the name is simple or "path-like" for the purpose
+     * of rendering SSM parameter ARNs.
+     *
+     * If `parameterName` is not specified, `simpleName` must be `true` (or
+     * undefined) since the name generated by AWS CloudFormation is always a
+     * simple name.
+     *
+     * @default - auto-detect based on `parameterName`
+     */
+    readonly simpleName?: boolean;
+}
+/**
+ * Attributes for parameters of various types of string.
+ *
+ * @see ParameterType
+ */
+export interface StringParameterAttributes extends CommonStringParameterAttributes {
+    /**
+     * The version number of the value you wish to retrieve.
+     *
+     * @default The latest version will be retrieved.
+     */
+    readonly version?: number;
+    /**
+     * The type of the string parameter
+     *
+     * @default ParameterType.STRING
+     * @deprecated - use valueType instead
+     */
+    readonly type?: ParameterType;
+    /**
+     * The type of the string parameter value
+     *
+     * Using specific types can be helpful in catching invalid values
+     * at the start of creating or updating a stack. CloudFormation validates
+     * the values against existing values in the account.
+     *
+     * Note - if you want to allow values from different AWS accounts, use
+     * ParameterValueType.STRING
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types
+     *
+     * @default ParameterValueType.STRING
+     */
+    readonly valueType?: ParameterValueType;
+    /**
+     * Use a dynamic reference as the representation in CloudFormation template level.
+     * By default, CDK tries to deduce an appropriate representation based on the parameter value (a CfnParameter or a dynamic reference). Use this flag to override the representation when it does not work.
+     *
+     * @default false
+     */
+    readonly forceDynamicReference?: boolean;
+}
+/**
+ * Attributes for parameters of string list type.
+ *
+ * @see ParameterType
+ */
+export interface ListParameterAttributes extends CommonStringParameterAttributes {
+    /**
+     * The version number of the value you wish to retrieve.
+     *
+     * @default The latest version will be retrieved.
+     */
+    readonly version?: number;
+    /**
+     * The type of the string list parameter value.
+     *
+     * Using specific types can be helpful in catching invalid values
+     * at the start of creating or updating a stack. CloudFormation validates
+     * the values against existing values in the account.
+     *
+     * Note - if you want to allow values from different AWS accounts, use
+     * ParameterValueType.STRING
+     *
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#aws-ssm-parameter-types
+     *
+     * @default ParameterValueType.STRING
+     */
+    readonly elementType?: ParameterValueType;
+}
+/**
+ * Attributes for secure string parameters.
+ */
+export interface SecureStringParameterAttributes extends CommonStringParameterAttributes {
+    /**
+     * The version number of the value you wish to retrieve.
+     *
+     * @default - AWS CloudFormation uses the latest version of the parameter
+     */
+    readonly version?: number;
+    /**
+     * The encryption key that is used to encrypt this parameter
+     *
+     * @default - default master key
+     */
+    readonly encryptionKey?: kms.IKey;
+}
+/**
+ * Additional properties for looking up an existing StringParameter
+ */
+export interface StringParameterLookupOptions {
+    /**
+     * Adds an additional discriminator to the `cdk.context.json` cache key.
+     *
+     * @default - no additional cache key
+     */
+    readonly additionalCacheKey?: string;
+}
+/**
+ * Creates a new String SSM Parameter.
+ * @resource AWS::SSM::Parameter
+ *
+ * @example
+ * const ssmParameter = new ssm.StringParameter(this, 'mySsmParameter', {
+ *    parameterName: 'mySsmParameter',
+ *    stringValue: 'mySsmParameterValue',
+ * });
+ */
+export declare class StringParameter extends ParameterBase implements IStringParameter {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Imports an external string parameter by name.
+     */
+    static fromStringParameterName(scope: Construct, id: string, stringParameterName: string): IStringParameter;
+    /**
+     * Imports an external string parameter by ARN.
+     */
+    static fromStringParameterArn(scope: Construct, id: string, stringParameterArn: string): IStringParameter;
+    /**
+     * Imports an external string parameter with name and optional version.
+     */
+    static fromStringParameterAttributes(scope: Construct, id: string, attrs: StringParameterAttributes): IStringParameter;
+    /**
+     * Imports a secure string parameter from the SSM parameter store.
+     */
+    static fromSecureStringParameterAttributes(scope: Construct, id: string, attrs: SecureStringParameterAttributes): IStringParameter;
+    /**
+     * Reads the value of an SSM parameter during synthesis through an
+     * environmental context provider.
+     *
+     * Requires that the stack this scope is defined in will have explicit
+     * account/region information. Otherwise, it will fail during synthesis.
+     *
+     * If defaultValue is provided, it will be used as the dummyValue
+     * and the ContextProvider will be told NOT to raise an error on synthesis
+     * if the SSM Parameter is not found in the account at synth time.
+     */
+    static valueFromLookup(scope: Construct, parameterName: string, defaultValue?: string, options?: StringParameterLookupOptions): string;
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForStringParameter(scope: Construct, parameterName: string, version?: number): string;
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type The type of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForTypedStringParameterV2(scope: Construct, parameterName: string, type?: ParameterValueType, version?: number): string;
+    /**
+     * Returns a token that will resolve (during deployment) to the string value of an SSM string parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type The type of the SSM parameter.
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     * @deprecated - use valueForTypedStringParameterV2 instead
+     */
+    static valueForTypedStringParameter(scope: Construct, parameterName: string, type?: ParameterType, version?: number): string;
+    /**
+     * Returns a token that will resolve (during deployment)
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter
+     * @param version The parameter version (required for secure strings)
+     * @deprecated Use `SecretValue.ssmSecure()` instead, it will correctly type the imported value as a `SecretValue` and allow importing without version. `SecretValue` lives in the core `aws-cdk-lib` module.
+     */
+    static valueForSecureStringParameter(scope: Construct, parameterName: string, version: number): string;
+    readonly parameterArn: string;
+    readonly parameterName: string;
+    readonly parameterType: string;
+    readonly stringValue: string;
+    constructor(scope: Construct, id: string, props: StringParameterProps);
+}
+/**
+ * Creates a new StringList SSM Parameter.
+ * @resource AWS::SSM::Parameter
+ */
+export declare class StringListParameter extends ParameterBase implements IStringListParameter {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Imports an external parameter of type string list.
+     * Returns a token and should not be parsed.
+     */
+    static fromStringListParameterName(scope: Construct, id: string, stringListParameterName: string): IStringListParameter;
+    /**
+     * Imports an external string list parameter with name and optional version.
+     */
+    static fromListParameterAttributes(scope: Construct, id: string, attrs: ListParameterAttributes): IStringListParameter;
+    /**
+     * Returns a token that will resolve (during deployment) to the list value of an SSM StringList parameter.
+     * @param scope Some scope within a stack
+     * @param parameterName The name of the SSM parameter.
+     * @param type the type of the SSM list parameter
+     * @param version The parameter version (recommended in order to ensure that the value won't change during deployment)
+     */
+    static valueForTypedListParameter(scope: Construct, parameterName: string, type?: ParameterValueType, version?: number): string[];
+    readonly parameterArn: string;
+    readonly parameterName: string;
+    readonly parameterType: string;
+    readonly stringListValue: string[];
+    constructor(scope: Construct, id: string, props: StringListParameterProps);
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-ssm/lib/util.d.ts

@@ -0,0 +1,13 @@
+import type { IConstruct } from 'constructs';
+export declare const AUTOGEN_MARKER = "$$autogen$$";
+export interface ArnForParameterNameOptions {
+    readonly physicalName?: string;
+    readonly simpleName?: boolean;
+}
+/**
+ * Renders an ARN for an SSM parameter given a parameter name.
+ * @param scope definition scope
+ * @param parameterName the parameter name to include in the ARN
+ * @param physicalName optional physical name specified by the user (to auto-detect separator)
+ */
+export declare function arnForParameterName(scope: IConstruct, parameterName: string, options?: ArnForParameterNameOptions): string;

cdk/node_modules/aws-cdk-lib/aws-ssm/lib/util.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.AUTOGEN_MARKER=void 0,exports.arnForParameterName=arnForParameterName;var core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},errors_1=()=>{var tmp=require("../../core/lib/errors");return errors_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};exports.AUTOGEN_MARKER="$$autogen$$";function arnForParameterName(scope,parameterName,options={}){const physicalName=options.physicalName,nameToValidate=physicalName||parameterName;if(!core_1().Token.isUnresolved(nameToValidate)&&nameToValidate.includes("/")&&!nameToValidate.startsWith("/"))throw new(errors_1()).ValidationError((0,literal_string_1().lit)`MustBeParameterNamesFully`,`Parameter names must be fully qualified (if they include "/" they must also begin with a "/"): ${nameToValidate}`,scope);if(isSimpleName())return core_1().Stack.of(scope).formatArn({service:"ssm",resource:"parameter",arnFormat:core_1().ArnFormat.SLASH_RESOURCE_NAME,resourceName:parameterName});return core_1().Stack.of(scope).formatArn({service:"ssm",resource:`parameter${parameterName}`});function isSimpleName(){const concreteName=core_1().Token.isUnresolved(parameterName)?physicalName:parameterName;if(!concreteName||core_1().Token.isUnresolved(concreteName)){if(options.simpleName===void 0)throw new(errors_1()).ValidationError((0,literal_string_1().lit)`UnableToUnableDetermineSeparator`,'Unable to determine ARN separator for SSM parameter since the parameter name is an unresolved token. Use "fromAttributes" and specify "simpleName" explicitly',scope);return options.simpleName}const result=!concreteName.startsWith("/");if(options.simpleName!==void 0&&options.simpleName!==result)throw concreteName===exports.AUTOGEN_MARKER?new(errors_1()).ValidationError((0,literal_string_1().lit)`ParameternameExplicitlyDefined`,'If "parameterName" is not explicitly defined, "simpleName" must be "true" or undefined since auto-generated parameter names always have simple names',scope):new(errors_1()).ValidationError((0,literal_string_1().lit)`ParameterName`,`Parameter name "${concreteName}" is ${result?"a simple name":"not a simple name"}, but "simpleName" was explicitly set to ${options.simpleName}. Either omit it or set it to ${result}`,scope);return result}}