@awboost/cfntypes 1.0.0-beta.3 → 1.0.0-beta.31

package/lib/cjs/DeletionPolicy.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeletionPolicy = void 0;
+/**
+ * With the `DeletionPolicy` attribute you can preserve, and in some cases,
+ * backup a resource when its stack is deleted. You specify a `DeletionPolicy`
+ * attribute for each resource that you want to control. If a resource has no
+ * `DeletionPolicy` attribute, AWS CloudFormation deletes the resource by
+ * default, except for:
+ *
+ *  - For `AWS::RDS::DBCluster resources`, the default policy is `Snapshot`.
+ *  - For `AWS::RDS::DBInstance` resources that don't specify the
+ *    `DBClusterIdentifier` property, the default policy is `Snapshot`.
+ *  - For Amazon S3 buckets, you must delete all objects in the bucket for
+ *    deletion to succeed.
+ *
+ * This capability also applies to stack update operations that lead to
+ * resources being deleted from stacks. For example, if you remove the resource
+ * from the stack template, and then update the stack with the template. This
+ * capability doesn't apply to resources whose physical instance is replaced
+ * during stack update operations. For example, if you edit a resource's
+ * properties such that CloudFormation replaces that resource during a stack
+ * update.
+ *
+ * To keep a resource when its stack is deleted, specify Retain for that
+ * resource. You can use retain for any resource. For example, you can retain a
+ * nested stack, Amazon S3 bucket, or EC2 instance so that you can continue to
+ * use or modify those resources after you delete their stacks.
+ *
+ * For resources that support snapshots, such as `AWS::EC2::Volume`, specify
+ * Snapshot to have CloudFormation create a snapshot before deleting the
+ * resource.
+ *
+ * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html | DeletionPolicy attribute}
+ */
+exports.DeletionPolicy = {
+    /**
+     * CloudFormation deletes the resource and all its content if applicable
+     * during stack deletion. You can add this deletion policy to any resource
+     * type. By default, if you don't specify a `DeletionPolicy`, CloudFormation
+     * deletes your resources. However, be aware of the following considerations:
+     *
+     *  - For `AWS::RDS::DBCluster resources`, the default policy is `Snapshot`.
+     *  - For `AWS::RDS::DBInstance` resources that don't specify the
+     *    `DBClusterIdentifier` property, the default policy is `Snapshot`.
+     *
+     * For Amazon S3 buckets, you must delete all objects in the bucket for
+     * deletion to succeed.
+     */
+    Delete: 'Delete',
+    /**
+     * CloudFormation keeps the resource without deleting the resource or its
+     * contents when its stack is deleted. You can add this deletion policy to any
+     * resource type. When CloudFormation completes the stack deletion, the stack
+     * will be in `Delete_Complete` state; however, resources that are retained
+     * continue to exist and continue to incur applicable charges until you delete
+     * those resources.
+     *
+     * For update operations, the following considerations apply:
+     *
+     *  - If a resource is deleted, the `DeletionPolicy` retains the physical
+     *    resource but ensures that it's deleted from CloudFormation's scope.
+     *  - If a resource is updated such that a new physical resource is created to
+     *    replace the old resource, then the old resource is completely deleted,
+     *    including from CloudFormation's scope.
+     */
+    Retain: 'Retain',
+    /**
+     * For resources that support snapshots, CloudFormation creates a snapshot for
+     * the resource before deleting it. When CloudFormation completes the stack
+     * deletion, the stack will be in the `Delete_Complete` state; however, the
+     * snapshots that are created with this policy continue to exist and continue
+     * to incur applicable charges until you delete those snapshots.
+     *
+     * Resources that support snapshots include:
+     *
+     * - `AWS::EC2::Volume`
+     * - `AWS::ElastiCache::CacheCluster`
+     * - `AWS::ElastiCache::ReplicationGroup`
+     * - `AWS::Neptune::DBCluster`
+     * - `AWS::RDS::DBCluster`
+     * - `AWS::RDS::DBInstance`
+     * - `AWS::Redshift::Cluster`
+     */
+    Snapshot: 'Snapshot',
+};

package/lib/cjs/Fn.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fn = void 0;
+/**
+ * You can use intrinsic functions, such as `Fn::If`, `Fn::Equals`, and
+ * `Fn::Not`, to conditionally create stack resources. These conditions are
+ * evaluated based on input parameters that you declare when you create or
+ * update a stack. After you define all your conditions, you can associate them
+ * with resources or resource properties in the Resources and Outputs sections
+ * of a template.
+ *
+ * You define all conditions in the Conditions section of a template except for
+ * `Fn::If conditions`. You can use the `Fn::If` condition in the metadata
+ * attribute, update policy attribute, and property values in the Resources
+ * section and Outputs sections of a template.
+ *
+ * You might use conditions when you want to reuse a template that can create
+ * resources in different contexts, such as a test environment versus a
+ * production environment. In your template, you can add an EnvironmentType
+ * input parameter, which accepts either prod or test as inputs. For the
+ * production environment, you might include Amazon EC2 instances with certain
+ * capabilities; however, for the test environment, you want to use less
+ * capabilities to save costs. With conditions, you can define which resources
+ * are created and how they're configured for each environment type.
+ */
+class Fn {
+    /**
+     * Constructs a string value using {@link Fn.Join} from a tagged template
+     * literal.
+     */
+    static fmt(literals, ...values) {
+        const parts = [];
+        for (let i = 0; i < literals.length; ++i) {
+            if (literals[i]) {
+                parts.push(literals[i]);
+            }
+            if (i < values.length) {
+                parts.push(values[i]);
+            }
+        }
+        return Fn.Join('', parts);
+    }
+    /**
+     * Returns true if all the specified conditions evaluate to true, or returns
+     * false if any one of the conditions evaluates to false. `Fn::And` acts as an
+     * AND operator. The minimum number of conditions that you can include is 2,
+     * and the maximum is 10.
+     *
+     * @param conditions A condition that evaluates to true or false.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and | Fn::And}
+     */
+    static And(...conditions) {
+        return new this('Fn::And', conditions);
+    }
+    /**
+     * The intrinsic function `Fn::Base64` returns the Base64 representation of
+     * the input string. This function is typically used to pass encoded data to
+     * Amazon EC2 instances by way of the UserData property.
+     *
+     * @param valueToEncode The string value you want to convert to Base64.
+     * @returns The original string, in Base64 representation.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-base64.html | Fn::Base64}
+     */
+    static Base64(valueToEncode) {
+        return new this('Fn::Base64', valueToEncode);
+    }
+    /**
+     * The intrinsic function `Fn::Cidr` returns an array of CIDR address blocks.
+     * The number of CIDR blocks returned is dependent on the count parameter.
+     *
+     * @param ipBlock The user-specified CIDR address block to be split into
+     * smaller CIDR blocks.
+     * @param count The number of CIDRs to generate. Valid range is between 1 and
+     * 256.
+     * @param cidrBits The number of subnet bits for the CIDR. For example,
+     * specifying a value "8" for this parameter will create a CIDR with a mask of
+     * "/24".
+     * @returns An array of CIDR address blocks.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-cidr.html | Fn::Cidr}
+     */
+    static Cidr(ipBlock, count, cidrBits) {
+        return new this('Fn::Cidr', [ipBlock, count, cidrBits]);
+    }
+    /**
+     * Returns `true` if a specified string matches at least one value in a list
+     * of strings.
+     *
+     * @param listOfStrings A list of strings, such as `"A", "B", "C"`.
+     * @param string A string, such as `"A"`, that you want to compare against a
+     * list of strings.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-contains | Fn::Contains}
+     */
+    static Contains(listOfStrings, string) {
+        return new this('Fn::Contains', [listOfStrings, string]);
+    }
+    /**
+     * Returns `true` if a specified string matches all values in a list.
+     *
+     * @param listOfStrings A list of strings, such as `"A", "B", "C"`.
+     * @param string A string, such as `"A"`, that you want to compare against a
+     * list of strings.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-eachmemberequals | Fn::EachMemberEquals}
+     */
+    static EachMemberEquals(listOfStrings, string) {
+        return new this('Fn::EachMemberEquals', [listOfStrings, string]);
+    }
+    /**
+     * Returns `true` if a specified string matches all values in a list.
+     *
+     * @param stringsToCheck A list of strings, such as `"A", "B", "C"`.
+     * CloudFormation checks whether each member in the stringsToC`heck parameter
+     * is in the `stringsToMap` parameter.
+     * @param stringsToMatch A list of strings, such as `"A", "B", "C"`. Each
+     * member in the `stringsToMatch` parameter is compared against the members of
+     * the `stringsToCheck` parameter.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-eachmemberin | Fn::EachMemberIn}
+     */
+    static EachMemberIn(stringsToCheck, stringsToMatch) {
+        return new this('Fn::EachMemberIn', [stringsToCheck, stringsToMatch]);
+    }
+    /**
+     * Compares if two values are equal. Returns true if the two values are equal
+     * or false if they aren't.
+     *
+     * @param value1 A value of any type that you want to compare.
+     * @param value2 A value of any type that you want to compare.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals | Fn::Equals}
+     */
+    static Equals(value1, value2) {
+        return new this('Fn::Equals', [value1, value2]);
+    }
+    /**
+     * The intrinsic function `Fn::FindInMap` returns the value corresponding to
+     * keys in a two-level map that is declared in the Mappings section.
+     *
+     * @param mapName The logical name of a mapping declared in the Mappings
+     * section that contains the keys and values.
+     * @param topLevelKey The top-level key name. Its value is a list of key-value pairs.
+     * @param secondLevelKey The second-level key name, which is set to one of the keys from the list assigned to TopLevelKey.
+     * @returns The value that is assigned to SecondLevelKey.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-findinmap.html | Fn::FindInMap}
+     */
+    static FindInMap(mapName, topLevelKey, secondLevelKey) {
+        return new this('Fn::FindInMap', [mapName, topLevelKey, secondLevelKey]);
+    }
+    /**
+     * The `Fn::GetAtt` intrinsic function returns the value of an attribute from
+     * a resource in the template. For more information about GetAtt return values
+     * for a particular resource, refer to the documentation for that resource in
+     * the Resource and Property Reference.
+     *
+     * @param logicalNameOfResource The logical name (also called logical ID) of
+     * the resource that contains the attribute that you want.
+     * @param attributeName The name of the resource-specific attribute whose
+     * value you want. See the resource's reference page for details about the
+     * attributes available for that resource type.
+     * @returns The attribute value.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html | Fn::GetAtt}
+     */
+    static GetAtt(logicalNameOfResource, attributeName) {
+        return new this('Fn::GetAtt', [logicalNameOfResource, attributeName]);
+    }
+    /**
+     * The intrinsic function `Fn::GetAZs` returns an array that lists
+     * Availability Zones for a specified region. Because customers have access to
+     * different Availability Zones, the intrinsic function `Fn::GetAZs` enables
+     * template authors to write templates that adapt to the calling user's
+     * access. That way you don't have to hard-code a full list of Availability
+     * Zones for a specified region.
+     *
+     * @param region The name of the region for which you want to get the
+     * Availability Zones. You can use the AWS::Region pseudo parameter to
+     * specify the region in which the stack is created. Specifying an empty
+     * string is equivalent to specifying AWS::Region.
+     * @returns The list of Availability Zones for the region.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getavailabilityzones.html | Fn::GetAZs}
+     */
+    static GetAZs(region) {
+        return new this('Fn::GetAZs', region);
+    }
+    /**
+     * Returns one value if the specified condition evaluates to true and another
+     * value if the specified condition evaluates to false. Currently, AWS
+     * CloudFormation supports the Fn::If intrinsic function in the metadata
+     * attribute, update policy attribute, and property values in the Resources
+     * section and Outputs sections of a template. You can use the `AWS::NoValue`
+     * pseudo parameter as a return value to remove the corresponding property.
+     *
+     * @param conditionName A reference to a condition in the Conditions section.
+     * Use the condition's name to reference it.
+     * @param valueIfTrue A value to be returned if the specified condition
+     * evaluates to true.
+     * @param valueIfFalse A value to be returned if the specified condition
+     * evaluates to false.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if | Fn::If}
+     */
+    static IfThen(conditionName, valueIfTrue, valueIfFalse) {
+        return new this('Fn::If', [conditionName, valueIfTrue, valueIfFalse]);
+    }
+    /**
+     * The intrinsic function `Fn::ImportValue` returns the value of an output
+     * exported by another stack. You typically use this function to create
+     * cross-stack references. In the following example template snippets, Stack A
+     * exports VPC security group values and Stack B imports them.
+     *
+     * @param sharedValueToImport The stack output value that you want to import.
+     * @returns The stack output value.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-importvalue.html | Fn::ImportValue}
+     */
+    static ImportValue(sharedValueToImport) {
+        return new this('Fn::ImportValue', sharedValueToImport);
+    }
+    /**
+     * The intrinsic function `Fn::Join` appends a set of values into a single
+     * value, separated by the specified delimiter. If a delimiter is the empty
+     * string, the set of values are concatenated with no delimiter.
+     *
+     * @param delimiter The value you want to occur between fragments. The
+     * delimiter will occur between fragments only. It will not terminate the
+     * final value.
+     * @param listOfValues The list of values you want combined.
+     * @returns The combined string.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-join.html | Fn::Join}
+     */
+    static Join(delimiter, listOfValues) {
+        return new this('Fn::Join', [delimiter, listOfValues]);
+    }
+    /**
+     * Returns true for a condition that evaluates to false or returns false for a
+     * condition that evaluates to true. `Fn::Not` acts as a NOT operator.
+     *
+     * @param condition A condition such as `Fn::Equals` that evaluates to true or
+     * false.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not | Fn::Not}
+     */
+    static Not(condition) {
+        return new this('Fn::Not', [condition]);
+    }
+    /**
+     * Returns true if any one of the specified conditions evaluate to true, or
+     * returns false if all of the conditions evaluates to false. `Fn::Or` acts as
+     * an OR operator. The minimum number of conditions that you can include is 2,
+     * and the maximum is 10.
+     *
+     * @param conditions A condition that evaluates to true or false.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or | Fn::Or}
+     */
+    static Or(...conditions) {
+        return new this('Fn::Or', conditions);
+    }
+    /**
+     * The intrinsic function Ref returns the value of the specified parameter or
+     * resource.
+     *
+     * - When you specify a parameter's logical name, it returns the value of the
+     * parameter.
+     *
+     * - When you specify a resource's logical name, it returns a value that you
+     * can typically use to refer to that resource, such as a physical ID.
+     *
+     * When you are declaring a resource in a template and you need to specify
+     * another template resource by name, you can use the Ref to refer to that
+     * other resource. In general, Ref returns the name of the resource. For
+     * example, a reference to an AWS::AutoScaling::AutoScalingGroup returns the
+     * name of that Auto Scaling group resource.
+     *
+     * @param logicalName The logical name of the resource or parameter you want
+     * to dereference.
+     *
+     * @returns The physical ID of the resource or the value of the parameter.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-ref.html | Ref}
+     */
+    static Ref(logicalName) {
+        return new this('Ref', logicalName);
+    }
+    /**
+     * Returns all values for a specified parameter type.
+     *
+     * @param parameterType An AWS-specific parameter type, such as
+     * `AWS::EC2::SecurityGroup::Id` or `AWS::EC2::VPC::Id`. For more information,
+     * see Parameters in the AWS CloudFormation User Guide.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-refall | Fn::RefAll}
+     */
+    static RefAll(parameterType) {
+        return new this('Fn::RefAll', parameterType);
+    }
+    /**
+     * The intrinsic function `Fn::Select` returns a single object from a list of
+     * objects by index.
+     *
+     * @param index The index of the object to retrieve. This must be a value from
+     * zero to N-1, where N represents the number of elements in the array.
+     * @param listOfObjects The list of objects to select from. This list must not
+     * be null, nor can it have null entries.
+     * @returns The selected object.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-select.html | Fn::Select}
+     */
+    static Select(index, listOfObjects) {
+        return new this('Fn::Select', [index, listOfObjects]);
+    }
+    /**
+     * To split a string into a list of string values so that you can select an
+     * element from the resulting string list, use the `Fn::Split` intrinsic
+     * function. Specify the location of splits with a delimiter, such as , (a
+     * comma). After you split a string, use the `Fn::Select` function to pick a
+     * specific element.
+     *
+     * @param delimiter A string value that determines where the source string is
+     * divided.
+     * @param sourceString The string value that you want to split.
+     * @returns A list of string values.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-split.html | Fn::Split}
+     */
+    static Split(delimiter, sourceString) {
+        return new this('Fn::Split', [delimiter, sourceString]);
+    }
+    /**
+     * The intrinsic function `Fn::Sub` substitutes variables in an input string
+     * with values that you specify. In your templates, you can use this function
+     * to construct commands or outputs that include values that aren't available
+     * until you create or update a stack.
+     *
+     * @param text A string with variables that AWS CloudFormation substitutes
+     * with their associated values at runtime. Write variables as `${MyVarName}`.
+     * Variables can be template parameter names, resource logical IDs,
+     * resource attributes, or a variable in a key-value map. If you specify only
+     * template parameter names, resource logical IDs, and resource attributes,
+     * don't specify a key-value map.
+     *
+     * If you specify template parameter names or resource logical IDs, such as
+     * `${InstanceTypeParameter}` AWS CloudFormation returns the same values as if
+     * you used the Ref intrinsic function. If you specify resource attributes,
+     * such as `${MyInstance.PublicIp}` AWS CloudFormation returns the same values
+     * as if you used the `Fn::GetAtt` intrinsic function.
+     *
+     * To write a dollar sign and curly braces (`${}`) literally, add an
+     * exclamation point (!) after the open curly brace, such as `${!Literal}`.
+     * AWS CloudFormation resolves this text as `${Literal}`.
+     *
+     * @param values A map of values that AWS CloudFormation substitutes for the
+     * associated variable names at runtime.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-sub.html | Fn::Sub}
+     */
+    static Sub(text, values) {
+        return new this('Fn::Sub', [text, values]);
+    }
+    /**
+     * Returns an attribute value or list of values for a specific parameter and
+     * attribute.
+     *
+     * @param attribute The name of an attribute from which you want to retrieve a
+     * value.
+     * @param parameterLogicalId The name of a parameter for which you want to
+     * retrieve attribute values. The parameter must be declared in the
+     * `Parameters` section of the template.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-valueof | Fn::ValueOf}
+     */
+    static ValueOf(attribute, parameterLogicalId) {
+        return new this('Fn::ValueOf', [attribute, parameterLogicalId]);
+    }
+    /**
+     * Returns a list of all attribute values for a given parameter type and
+     * attribute.
+     *
+     * @param parameterType An AWS-specific parameter type, such as
+     * `AWS::EC2::SecurityGroup::Id` or `AWS::EC2::VPC::Id`. For more information,
+     * see Parameters in the AWS CloudFormation User Guide.
+     * @param attribute The name of an attribute from which you want to retrieve a
+     * value.
+     *
+     * @see {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-rules.html#fn-valueofall | Fn::ValueOfAll}
+     */
+    static ValueOfAll(parameterType, attribute) {
+        return new this('Fn::ValueOfAll', [parameterType, attribute]);
+    }
+    /**
+     * Create an arbitrary intrinsic function value.
+     *
+     * @param fn The name of the intrinsic function.
+     * @param args The arguments for the intrinsic function.
+     */
+    constructor(fn, args) {
+        this.fn = fn;
+        this.args = args;
+    }
+    /**
+     * Get the JSON representation for this instance.
+     */
+    toJSON() {
+        return { [this.fn]: this.args };
+    }
+}
+exports.Fn = Fn;

package/lib/cjs/OutputDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/ParameterDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/ResourceDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/RuleDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/Template.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/TemplateMap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/UpdatePolicy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// AUTO-GENERATED node ../makeIndex.js
+__exportStar(require("./AutoScalingReplacingUpdatePolicy.js"), exports);
+__exportStar(require("./AutoScalingRollingUpdatePolicy.js"), exports);
+__exportStar(require("./AutoScalingScheduledActionPolicy.js"), exports);
+__exportStar(require("./AwsParam.js"), exports);
+__exportStar(require("./CodeDeployLambdaAliasUpdatePolicy.js"), exports);
+__exportStar(require("./CreationPolicy.js"), exports);
+__exportStar(require("./DeletionPolicy.js"), exports);
+__exportStar(require("./Fn.js"), exports);
+__exportStar(require("./OutputDefinition.js"), exports);
+__exportStar(require("./ParameterDefinition.js"), exports);
+__exportStar(require("./ResourceDefinition.js"), exports);
+__exportStar(require("./RuleDefinition.js"), exports);
+__exportStar(require("./Template.js"), exports);
+__exportStar(require("./TemplateMap.js"), exports);
+__exportStar(require("./types.generated.js"), exports);
+__exportStar(require("./UpdatePolicy.js"), exports);