@aws-cdk/core/lib/cfn-fn.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Fn = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const cloudformation_lang_1 = require("./private/cloudformation-lang");
const intrinsic_1 = require("./private/intrinsic");
const reference_1 = require("./reference");
const stack_trace_1 = require("./stack-trace");
const token_1 = require("./token");
/* eslint-disable max-len */
/**
 * CloudFormation intrinsic functions.
 * http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html
 */
class Fn {
    constructor() { }
    /**
     * The ``Ref`` intrinsic function returns the value of the specified parameter or resource.
     * Note that it doesn't validate the logicalName, it mainly serves paremeter/resource reference defined in a ``CfnInclude`` template.
     * @param logicalName The logical name of a parameter/resource for which you want to retrieve its value.
     */
    static ref(logicalName) {
        return new FnRef(logicalName).toString();
    }
    /**
     * The ``Fn::GetAtt`` intrinsic function returns the value of an attribute
     * from a resource in the template.
     * @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 an IResolvable object
     */
    static getAtt(logicalNameOfResource, attributeName) {
        return new FnGetAtt(logicalNameOfResource, attributeName);
    }
    /**
     * 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 a token represented as a string
     */
    static join(delimiter, listOfValues) {
        if (listOfValues.length === 0) {
            throw new Error('FnJoin requires at least one value to be provided');
        }
        return new FnJoin(delimiter, listOfValues).toString();
    }
    /**
     * Split a string token into a token list of string values.
     *
     * Specify the location of splits with a delimiter such as ',' (a comma).
     * Renders to the `Fn::Split` intrinsic function.
     *
     * Lists with unknown lengths (default)
     * -------------------------------------
     *
     * Since this function is used to work with deploy-time values, if `assumedLength`
     * is not given the CDK cannot know the length of the resulting list at synthesis time.
     * This brings the following restrictions:
     *
     * - You must use `Fn.select(i, list)` to pick elements out of the list (you must not use
     *   `list[i]`).
     * - You cannot add elements to the list, remove elements from the list,
     *   combine two such lists together, or take a slice of the list.
     * - You cannot pass the list to constructs that do any of the above.
     *
     * The only valid operation with such a tokenized list is to pass it unmodified to a
     * CloudFormation Resource construct.
     *
     * Lists with assumed lengths
     * --------------------------
     *
     * Pass `assumedLength` if you know the length of the list that will be
     * produced by splitting. The actual list length at deploy time may be
     * *longer* than the number you pass, but not *shorter*.
     *
     * The returned list will look like:
     *
     * ```
     * [Fn.select(0, split), Fn.select(1, split), Fn.select(2, split), ...]
     * ```
     *
     * The restrictions from the section "Lists with unknown lengths" will now be lifted,
     * at the expense of having to know and fix the length of the list.
     *
     * @param delimiter A string value that determines where the source string is divided.
     * @param source The string value that you want to split.
     * @param assumedLength The length of the list that will be produced by splitting
     * @returns a token represented as a string array
     */
    static split(delimiter, source, assumedLength) {
        // short-circut if source is not a token
        if (!token_1.Token.isUnresolved(source)) {
            return source.split(delimiter);
        }
        if (token_1.Token.isUnresolved(delimiter)) {
            // Limitation of CloudFormation
            throw new Error('Fn.split: \'delimiter\' may not be a token value');
        }
        const split = token_1.Token.asList(new FnSplit(delimiter, source));
        if (assumedLength === undefined) {
            return split;
        }
        if (token_1.Token.isUnresolved(assumedLength)) {
            throw new Error('Fn.split: \'assumedLength\' may not be a token value');
        }
        return range(assumedLength).map(i => Fn.select(i, split));
    }
    /**
     * 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 array The list of objects to select from. This list must not be null, nor can it have null entries.
     * @returns a token represented as a string
     */
    static select(index, array) {
        if (!token_1.Token.isUnresolved(index) && !token_1.Token.isUnresolved(array) && !array.some(token_1.Token.isUnresolved)) {
            return array[index];
        }
        return new FnSelect(index, array).toString();
    }
    /**
     * 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 body 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.
     * @param variables The name of a variable that you included in the String
     * parameter. The value that AWS CloudFormation substitutes for the associated
     * variable name at runtime.
     * @returns a token represented as a string
     */
    static sub(body, variables) {
        return new FnSub(body, variables).toString();
    }
    /**
     * 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 data The string value you want to convert to Base64.
     * @returns a token represented as a string
     */
    static base64(data) {
        return new FnBase64(data).toString();
    }
    /**
     * The intrinsic function ``Fn::Cidr`` returns the specified Cidr address block.
     * @param ipBlock  The user-specified default Cidr address block.
     * @param count  The number of subnets' Cidr block wanted. Count can be 1 to 256.
     * @param sizeMask The digit covered in the subnet.
     * @returns a token represented as a string
     */
    static cidr(ipBlock, count, sizeMask) {
        return token_1.Token.asList(new FnCidr(ipBlock, count, sizeMask));
    }
    /**
     * Given an url, parse the domain name
     * @param url the url to parse
     */
    static parseDomainName(url) {
        const noHttps = Fn.select(1, Fn.split('//', url));
        return Fn.select(0, Fn.split('/', noHttps));
    }
    /**
     * 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 a token represented as a string array
     */
    static getAzs(region) {
        return token_1.Token.asList(new FnGetAZs(region));
    }
    /**
     * 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 a token represented as a string
     */
    static importValue(sharedValueToImport) {
        return new FnImportValue(sharedValueToImport).toString();
    }
    /**
     * Like `Fn.importValue`, but import a list with a known length
     *
     * If you explicitly want a list with an unknown length, call `Fn.split(',',
     * Fn.importValue(exportName))`. See the documentation of `Fn.split` to read
     * more about the limitations of using lists of unknown length.
     *
     * `Fn.importListValue(exportName, assumedLength)` is the same as
     * `Fn.split(',', Fn.importValue(exportName), assumedLength)`,
     * but easier to read and impossible to forget to pass `assumedLength`.
     */
    static importListValue(sharedValueToImport, assumedLength, delimiter = ',') {
        return Fn.split(delimiter, Fn.importValue(sharedValueToImport), assumedLength);
    }
    /**
     * The intrinsic function ``Fn::FindInMap`` returns the value corresponding to
     * keys in a two-level map that is declared in the Mappings section.
     * @returns a token represented as a string
     */
    static findInMap(mapName, topLevelKey, secondLevelKey) {
        return Fn._findInMap(mapName, topLevelKey, secondLevelKey).toString();
    }
    /**
     * An additional function used in CfnParser,
     * as Fn::FindInMap does not always return a string.
     *
     * @internal
     */
    static _findInMap(mapName, topLevelKey, secondLevelKey) {
        return new FnFindInMap(mapName, topLevelKey, secondLevelKey);
    }
    /**
     * Creates a token representing the ``Fn::Transform`` expression
     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-transform.html
     * @param macroName The name of the macro to perform the processing
     * @param parameters The parameters to be passed to the macro
     * @returns a token representing the transform expression
     */
    static transform(macroName, parameters) {
        return new FnTransform(macroName, parameters);
    }
    /**
     * 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
     * 1.
     * @param conditions conditions to AND
     * @returns an FnCondition token
     */
    static conditionAnd(...conditions) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ICfnConditionExpression(conditions);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.conditionAnd);
            }
            throw error;
        }
        if (conditions.length === 0) {
            throw new Error('Fn.conditionAnd() needs at least one argument');
        }
        if (conditions.length === 1) {
            return conditions[0];
        }
        return Fn.conditionAnd(..._inGroupsOf(conditions, 10).map(group => new FnAnd(...group)));
    }
    /**
     * Compares if two values are equal. Returns true if the two values are equal
     * or false if they aren't.
     * @param lhs A value of any type that you want to compare.
     * @param rhs A value of any type that you want to compare.
     * @returns an FnCondition token
     */
    static conditionEquals(lhs, rhs) {
        return new FnEquals(lhs, rhs);
    }
    /**
     * 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 conditionId 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.
     * @returns an FnCondition token
     */
    static conditionIf(conditionId, valueIfTrue, valueIfFalse) {
        return new FnIf(conditionId, valueIfTrue, valueIfFalse);
    }
    /**
     * 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.
     * @returns an FnCondition token
     */
    static conditionNot(condition) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ICfnConditionExpression(condition);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.conditionNot);
            }
            throw error;
        }
        return new FnNot(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
     * 1.
     * @param conditions conditions that evaluates to true or false.
     * @returns an FnCondition token
     */
    static conditionOr(...conditions) {
        try {
            jsiiDeprecationWarnings._aws_cdk_core_ICfnConditionExpression(conditions);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.conditionOr);
            }
            throw error;
        }
        if (conditions.length === 0) {
            throw new Error('Fn.conditionOr() needs at least one argument');
        }
        if (conditions.length === 1) {
            return conditions[0];
        }
        return Fn.conditionOr(..._inGroupsOf(conditions, 10).map(group => new FnOr(...group)));
    }
    /**
     * 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 value A string, such as "A", that you want to compare against a list of strings.
     * @returns an FnCondition token
     */
    static conditionContains(listOfStrings, value) {
        return new FnContains(listOfStrings, value);
    }
    /**
     * Returns true if a specified string matches all values in a list.
     * @param listOfStrings A list of strings, such as "A", "B", "C".
     * @param value A string, such as "A", that you want to compare against a list
     * of strings.
     * @returns an FnCondition token
     */
    static conditionEachMemberEquals(listOfStrings, value) {
        return new FnEachMemberEquals(listOfStrings, value);
    }
    /**
     * Returns true if each member in a list of strings matches at least one value
     * in a second list of strings.
     * @param stringsToCheck A list of strings, such as "A", "B", "C". AWS
     * CloudFormation checks whether each member in the strings_to_check parameter
     * is in the strings_to_match parameter.
     * @param stringsToMatch A list of strings, such as "A", "B", "C". Each member
     * in the strings_to_match parameter is compared against the members of the
     * strings_to_check parameter.
     * @returns an FnCondition token
     */
    static conditionEachMemberIn(stringsToCheck, stringsToMatch) {
        return new FnEachMemberIn(stringsToCheck, stringsToMatch);
    }
    /**
     * 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.
     * @returns a token represented as a string array
     */
    static refAll(parameterType) {
        return token_1.Token.asList(new FnRefAll(parameterType));
    }
    /**
     * Returns an attribute value or list of values for a specific parameter and
     * attribute.
     * @param parameterOrLogicalId 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.
     * @param attribute The name of an attribute from which you want to retrieve a
     * value.
     * @returns a token represented as a string
     */
    static valueOf(parameterOrLogicalId, attribute) {
        return new FnValueOf(parameterOrLogicalId, attribute).toString();
    }
    /**
     * 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. For more information about attributes, see Supported Attributes.
     * @returns a token represented as a string array
     */
    static valueOfAll(parameterType, attribute) {
        return token_1.Token.asList(new FnValueOfAll(parameterType, attribute));
    }
}
exports.Fn = Fn;
_a = JSII_RTTI_SYMBOL_1;
Fn[_a] = { fqn: "@aws-cdk/core.Fn", version: "1.204.0" };
/**
 * Base class for tokens that represent CloudFormation intrinsic functions.
 */
class FnBase extends intrinsic_1.Intrinsic {
    constructor(name, value) {
        super({ [name]: value });
    }
}
/**
 * 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.
 */
class FnRef extends FnBase {
    /**
     * Creates an ``Ref`` function.
     * @param logicalName The logical name of a parameter/resource for which you want to retrieve its value.
     */
    constructor(logicalName) {
        super('Ref', logicalName);
    }
}
/**
 * The intrinsic function ``Fn::FindInMap`` returns the value corresponding to keys in a two-level
 * map that is declared in the Mappings section.
 */
class FnFindInMap extends FnBase {
    /**
     * Creates an ``Fn::FindInMap`` function.
     * @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.
     */
    constructor(mapName, topLevelKey, secondLevelKey) {
        super('Fn::FindInMap', [mapName, topLevelKey, secondLevelKey]);
    }
}
/**
 * The intrinsic function ``Fn::Transform`` specifies a macro to perform custom processing on part of a stack template.
 */
class FnTransform extends FnBase {
    /**
     * creates an ``Fn::Transform`` function.
     * @param macroName The name of the macro to be invoked
     * @param parameters the parameters to pass to it
     */
    constructor(macroName, parameters) {
        super('Fn::Transform', { Name: macroName, Parameters: parameters });
    }
}
/**
 * The ``Fn::GetAtt`` intrinsic function returns the value of an attribute from a resource in the template.
 */
class FnGetAtt extends FnBase {
    /**
     * Creates a ``Fn::GetAtt`` function.
     * @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.
     */
    constructor(logicalNameOfResource, attributeName) {
        super('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.
 */
class FnGetAZs extends FnBase {
    /**
     * Creates an ``Fn::GetAZs`` function.
     * @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.
     */
    constructor(region) {
        super('Fn::GetAZs', region || '');
    }
}
/**
 * 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.
 */
class FnImportValue extends FnBase {
    /**
     * Creates an ``Fn::ImportValue`` function.
     * @param sharedValueToImport The stack output value that you want to import.
     */
    constructor(sharedValueToImport) {
        super('Fn::ImportValue', sharedValueToImport);
    }
}
/**
 * The intrinsic function ``Fn::Select`` returns a single object from a list of objects by index.
 */
class FnSelect extends FnBase {
    /**
     * Creates an ``Fn::Select`` function.
     * @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 array The list of objects to select from. This list must not be null, nor can it have null entries.
     */
    constructor(index, array) {
        super('Fn::Select', [index, array]);
    }
}
/**
 * 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.
 */
class FnSplit extends FnBase {
    /**
     * Create an ``Fn::Split`` function.
     * @param delimiter A string value that determines where the source string is divided.
     * @param source The string value that you want to split.
     */
    constructor(delimiter, source) {
        super('Fn::Split', [delimiter, source]);
    }
}
/**
 * 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.
 */
class FnSub extends FnBase {
    /**
     * Creates an ``Fn::Sub`` function.
     * @param body 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.
     * @param variables The name of a variable that you included in the String parameter.
     *          The value that AWS CloudFormation substitutes for the associated variable name at runtime.
     */
    constructor(body, variables) {
        super('Fn::Sub', variables ? [body, variables] : body);
    }
}
/**
 * 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.
 */
class FnBase64 extends FnBase {
    /**
     * Creates an ``Fn::Base64`` function.
     * @param data The string value you want to convert to Base64.
     */
    constructor(data) {
        super('Fn::Base64', data);
    }
}
/**
 * The intrinsic function ``Fn::Cidr`` returns the specified Cidr address block.
 */
class FnCidr extends FnBase {
    /**
     * Creates an ``Fn::Cidr`` function.
     * @param ipBlock  The user-specified default Cidr address block.
     * @param count  The number of subnets' Cidr block wanted. Count can be 1 to 256.
     * @param sizeMask The digit covered in the subnet.
     */
    constructor(ipBlock, count, sizeMask) {
        if (count < 1 || count > 256) {
            throw new Error(`Fn::Cidr's count attribute must be betwen 1 and 256, ${count} was provided.`);
        }
        super('Fn::Cidr', [ipBlock, count, sizeMask]);
    }
}
class FnConditionBase extends intrinsic_1.Intrinsic {
    constructor(type, value) {
        super({ [type]: value });
        this.disambiguator = true;
    }
}
/**
 * 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.
 */
class FnAnd extends FnConditionBase {
    constructor(...condition) {
        super('Fn::And', condition);
    }
}
/**
 * Compares if two values are equal. Returns true if the two values are equal or false
 * if they aren't.
 */
class FnEquals extends FnConditionBase {
    /**
     * Creates an ``Fn::Equals`` condition function.
     * @param lhs A value of any type that you want to compare.
     * @param rhs A value of any type that you want to compare.
     */
    constructor(lhs, rhs) {
        super('Fn::Equals', [lhs, rhs]);
    }
}
/**
 * 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.
 */
class FnIf extends FnConditionBase {
    /**
     * Creates an ``Fn::If`` condition function.
     * @param condition 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.
     */
    constructor(condition, valueIfTrue, valueIfFalse) {
        super('Fn::If', [condition, valueIfTrue, valueIfFalse]);
    }
}
/**
 * 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.
 */
class FnNot extends FnConditionBase {
    /**
     * Creates an ``Fn::Not`` condition function.
     * @param condition A condition such as ``Fn::Equals`` that evaluates to true or false.
     */
    constructor(condition) {
        super('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.
 */
class FnOr extends FnConditionBase {
    /**
     * Creates an ``Fn::Or`` condition function.
     * @param condition A condition that evaluates to true or false.
     */
    constructor(...condition) {
        super('Fn::Or', condition);
    }
}
/**
 * Returns true if a specified string matches at least one value in a list of strings.
 */
class FnContains extends FnConditionBase {
    /**
     * Creates an ``Fn::Contains`` function.
     * @param listOfStrings A list of strings, such as "A", "B", "C".
     * @param value A string, such as "A", that you want to compare against a list of strings.
     */
    constructor(listOfStrings, value) {
        super('Fn::Contains', [listOfStrings, value]);
    }
}
/**
 * Returns true if a specified string matches all values in a list.
 */
class FnEachMemberEquals extends FnConditionBase {
    /**
     * Creates an ``Fn::EachMemberEquals`` function.
     * @param listOfStrings A list of strings, such as "A", "B", "C".
     * @param value A string, such as "A", that you want to compare against a list of strings.
     */
    constructor(listOfStrings, value) {
        super('Fn::EachMemberEquals', [listOfStrings, value]);
    }
}
/**
 * Returns true if each member in a list of strings matches at least one value in a second
 * list of strings.
 */
class FnEachMemberIn extends FnConditionBase {
    /**
     * Creates an ``Fn::EachMemberIn`` function.
     * @param stringsToCheck A list of strings, such as "A", "B", "C". AWS CloudFormation checks whether each member in the strings_to_check parameter is in the strings_to_match parameter.
     * @param stringsToMatch A list of strings, such as "A", "B", "C". Each member in the strings_to_match parameter is compared against the members of the strings_to_check parameter.
     */
    constructor(stringsToCheck, stringsToMatch) {
        super('Fn::EachMemberIn', [stringsToCheck, stringsToMatch]);
    }
}
/**
 * Returns all values for a specified parameter type.
 */
class FnRefAll extends FnBase {
    /**
     * Creates an ``Fn::RefAll`` function.
     * @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.
     */
    constructor(parameterType) {
        super('Fn::RefAll', parameterType);
    }
}
/**
 * Returns an attribute value or list of values for a specific parameter and attribute.
 */
class FnValueOf extends FnBase {
    /**
     * Creates an ``Fn::ValueOf`` function.
     * @param parameterOrLogicalId 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.
     * @param attribute The name of an attribute from which you want to retrieve a value.
     */
    constructor(parameterOrLogicalId, attribute) {
        super('Fn::ValueOf', [parameterOrLogicalId, attribute]);
    }
}
/**
 * Returns a list of all attribute values for a given parameter type and attribute.
 */
class FnValueOfAll extends FnBase {
    /**
     * Creates an ``Fn::ValueOfAll`` function.
     * @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. For more information about attributes, see Supported Attributes.
     */
    constructor(parameterType, attribute) {
        super('Fn::ValueOfAll', [parameterType, attribute]);
    }
}
/**
 * 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.
 */
class FnJoin {
    /**
     * Creates an ``Fn::Join`` function.
     * @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.
     */
    constructor(delimiter, listOfValues) {
        if (listOfValues.length === 0) {
            throw new Error('FnJoin requires at least one value to be provided');
        }
        this.delimiter = delimiter;
        this.listOfValues = listOfValues;
        this.creationStack = stack_trace_1.captureStackTrace();
    }
    resolve(context) {
        if (token_1.Token.isUnresolved(this.listOfValues)) {
            // This is a list token, don't try to do smart things with it.
            return { 'Fn::Join': [this.delimiter, this.listOfValues] };
        }
        const resolved = this.resolveValues(context);
        if (resolved.length === 1) {
            return resolved[0];
        }
        return { 'Fn::Join': [this.delimiter, resolved] };
    }
    toString() {
        return token_1.Token.asString(this, { displayHint: 'Fn::Join' });
    }
    toJSON() {
        return '<Fn::Join>';
    }
    /**
     * Optimization: if an Fn::Join is nested in another one and they share the same delimiter, then flatten it up. Also,
     * if two concatenated elements are literal strings (not tokens), then pre-concatenate them with the delimiter, to
     * generate shorter output.
     */
    resolveValues(context) {
        const resolvedValues = this.listOfValues.map(x => reference_1.Reference.isReference(x) ? x : context.resolve(x));
        return cloudformation_lang_1.minimalCloudFormationJoin(this.delimiter, resolvedValues);
    }
}
function _inGroupsOf(array, maxGroup) {
    const result = new Array();
    for (let i = 0; i < array.length; i += maxGroup) {
        result.push(array.slice(i, i + maxGroup));
    }
    return result;
}
function range(n) {
    const ret = [];
    for (let i = 0; i < n; i++) {
        ret.push(i);
    }
    return ret;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cfn-fn.js","sourceRoot":"","sources":["cfn-fn.ts"],"names":[],"mappings":";;;;;;AACA,uEAA0E;AAC1E,mDAAgD;AAChD,2CAAwC;AAExC,+CAAkD;AAClD,mCAAgC;AAEhC,4BAA4B;AAE5B;;;GAGG;AACH,MAAa,EAAE;IAgZb,iBAAyB;IA/YzB;;;;OAIG;IACI,MAAM,CAAC,GAAG,CAAC,WAAmB;QACnC,OAAO,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,CAAC;KAC1C;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,MAAM,CAAC,qBAA6B,EAAE,aAAqB;QACvE,OAAO,IAAI,QAAQ,CAAC,qBAAqB,EAAE,aAAa,CAAC,CAAC;KAC3D;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,IAAI,CAAC,SAAiB,EAAE,YAAsB;QAC1D,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;SACtE;QAED,OAAO,IAAI,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC;KACvD;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACI,MAAM,CAAC,KAAK,CAAC,SAAiB,EAAE,MAAc,EAAE,aAAsB;QAC3E,wCAAwC;QACxC,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE;YAC/B,OAAO,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;SAChC;QAED,IAAI,aAAK,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE;YACjC,+BAA+B;YAC/B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACrE;QAED,MAAM,KAAK,GAAG,aAAK,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;QAC3D,IAAI,aAAa,KAAK,SAAS,EAAE;YAC/B,OAAO,KAAK,CAAC;SACd;QAED,IAAI,aAAK,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE;YACrC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;SACzE;QAED,OAAO,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;KAC3D;IAED;;;;;OAKG;IACI,MAAM,CAAC,MAAM,CAAC,KAAa,EAAE,KAAe;QACjD,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,EAAE;YAC/F,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;SACrB;QAED,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;KAC9C;IAED;;;;;;;;;;;;;;;OAeG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,SAAqC;QACnE,OAAO,IAAI,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;KAC9C;IAED;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,IAAY;QAC/B,OAAO,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;KACtC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,IAAI,CAAC,OAAe,EAAE,KAAa,EAAE,QAAiB;QAClE,OAAO,aAAK,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;KAC3D;IAED;;;OAGG;IACI,MAAM,CAAC,eAAe,CAAC,GAAW;QACvC,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;QAClD,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC;KAC7C;IAED;;;;;;;;;;;;OAYG;IACI,MAAM,CAAC,MAAM,CAAC,MAAe;QAClC,OAAO,aAAK,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;KAC3C;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,WAAW,CAAC,mBAA2B;QACnD,OAAO,IAAI,aAAa,CAAC,mBAAmB,CAAC,CAAC,QAAQ,EAAE,CAAC;KAC1D;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,eAAe,CAAC,mBAA2B,EAAE,aAAqB,EAAE,SAAS,GAAG,GAAG;QAC/F,OAAO,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,CAAC,WAAW,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,CAAC;KAChF;IAED;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,OAAe,EAAE,WAAmB,EAAE,cAAsB;QAClF,OAAO,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;KACvE;IAED;;;;;OAKG;IACI,MAAM,CAAC,UAAU,CAAC,OAAe,EAAE,WAAmB,EAAE,cAAsB;QACnF,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;KAC9D;IAED;;;;;;OAMG;IACI,MAAM,CAAC,SAAS,CAAC,SAAiB,EAAE,UAAmC;QAC5E,OAAO,IAAI,WAAW,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;KAC/C;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,YAAY,CAAC,GAAG,UAAqC;;;;;;;;;;QACjE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;SAClE;QACD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,UAAU,CAAC,CAAC,CAAgC,CAAC;SACrD;QACD,OAAO,EAAE,CAAC,YAAY,CAAC,GAAG,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;KAC1F;IAED;;;;;;OAMG;IACI,MAAM,CAAC,eAAe,CAAC,GAAQ,EAAE,GAAQ;QAC9C,OAAO,IAAI,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;KAC/B;IAED;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,WAAW,CAAC,WAAmB,EAAE,WAAgB,EAAE,YAAiB;QAChF,OAAO,IAAI,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;KACzD;IAED;;;;;;OAMG;IACI,MAAM,CAAC,YAAY,CAAC,SAAkC;;;;;;;;;;QAC3D,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;KAC7B;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,WAAW,CAAC,GAAG,UAAqC;;;;;;;;;;QAChE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;SACjE;QACD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,OAAO,UAAU,CAAC,CAAC,CAAgC,CAAC;SACrD;QACD,OAAO,EAAE,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;KACxF;IAED;;;;;;OAMG;IACI,MAAM,CAAC,iBAAiB,CAAC,aAAuB,EAAE,KAAa;QACpE,OAAO,IAAI,UAAU,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;KAC7C;IAED;;;;;;OAMG;IACI,MAAM,CAAC,yBAAyB,CAAC,aAAuB,EAAE,KAAa;QAC5E,OAAO,IAAI,kBAAkB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;KACrD;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,qBAAqB,CAAC,cAAwB,EAAE,cAAwB;QACpF,OAAO,IAAI,cAAc,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;KAC3D;IAED;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,aAAqB;QACxC,OAAO,aAAK,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC;KAClD;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,OAAO,CAAC,oBAA4B,EAAE,SAAiB;QACnE,OAAO,IAAI,SAAS,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;KAClE;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,UAAU,CAAC,aAAqB,EAAE,SAAiB;QAC/D,OAAO,aAAK,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC;KACjE;;AA9YH,gBAiZC;;;AAED;;GAEG;AACH,MAAM,MAAO,SAAQ,qBAAS;IAC5B,YAAY,IAAY,EAAE,KAAU;QAClC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;KAC1B;CACF;AAED;;;;GAIG;AACH,MAAM,KAAM,SAAQ,MAAM;IACxB;;;OAGG;IACH,YAAY,WAAmB;QAC7B,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;KAC3B;CACF;AAED;;;GAGG;AACH,MAAM,WAAY,SAAQ,MAAM;IAC9B;;;;;OAKG;IACH,YAAY,OAAe,EAAE,WAAgB,EAAE,cAAmB;QAChE,KAAK,CAAC,eAAe,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;KAChE;CACF;AAED;;GAEG;AACH,MAAM,WAAY,SAAQ,MAAM;IAC9B;;;;OAIG;IACH,YAAY,SAAiB,EAAE,UAAmC;QAChE,KAAK,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;KACrE;CACF;AAED;;GAEG;AACH,MAAM,QAAS,SAAQ,MAAM;IAC3B;;;;OAIG;IACH,YAAY,qBAA6B,EAAE,aAAqB;QAC9D,KAAK,CAAC,YAAY,EAAE,CAAC,qBAAqB,EAAE,aAAa,CAAC,CAAC,CAAC;KAC7D;CACF;AAED;;;;;;GAMG;AACH,MAAM,QAAS,SAAQ,MAAM;IAC3B;;;;;;OAMG;IACH,YAAY,MAAe;QACzB,KAAK,CAAC,YAAY,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC;KACnC;CACF;AAED;;;;GAIG;AACH,MAAM,aAAc,SAAQ,MAAM;IAChC;;;OAGG;IACH,YAAY,mBAA2B;QACrC,KAAK,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;KAC/C;CACF;AAED;;GAEG;AACH,MAAM,QAAS,SAAQ,MAAM;IAC3B;;;;OAIG;IACH,YAAY,KAAa,EAAE,KAAU;QACnC,KAAK,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;KACrC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAQ,SAAQ,MAAM;IAC1B;;;;OAIG;IACH,YAAY,SAAiB,EAAE,MAAW;QACxC,KAAK,CAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC;KACzC;CACF;AAED;;;;GAIG;AACH,MAAM,KAAM,SAAQ,MAAM;IACxB;;;;;;;;;OASG;IACH,YAAY,IAAY,EAAE,SAAkC;QAC1D,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;KACxD;CACF;AAED;;;;GAIG;AACH,MAAM,QAAS,SAAQ,MAAM;IAE3B;;;OAGG;IACH,YAAY,IAAS;QACnB,KAAK,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;KAC3B;CACF;AAED;;GAEG;AACH,MAAM,MAAO,SAAQ,MAAM;IACzB;;;;;OAKG;IACH,YAAY,OAAY,EAAE,KAAU,EAAE,QAAc;QAClD,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,GAAG,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,wDAAwD,KAAK,gBAAgB,CAAC,CAAC;SAChG;QACD,KAAK,CAAC,UAAU,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;KAC/C;CACF;AAED,MAAM,eAAgB,SAAQ,qBAAS;IAErC,YAAY,IAAY,EAAE,KAAU;QAClC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAFlB,kBAAa,GAAG,IAAI,CAAC;KAG7B;CACF;AAED;;;;GAIG;AACH,MAAM,KAAM,SAAQ,eAAe;IACjC,YAAY,GAAG,SAAoC;QACjD,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;KAC7B;CACF;AAED;;;GAGG;AACH,MAAM,QAAS,SAAQ,eAAe;IACpC;;;;OAIG;IACH,YAAY,GAAQ,EAAE,GAAQ;QAC5B,KAAK,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;KACjC;CACF;AAED;;;;;;GAMG;AACH,MAAM,IAAK,SAAQ,eAAe;IAChC;;;;;OAKG;IACH,YAAY,SAAiB,EAAE,WAAgB,EAAE,YAAiB;QAChE,KAAK,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC;KACzD;CACF;AAED;;;GAGG;AACH,MAAM,KAAM,SAAQ,eAAe;IACjC;;;OAGG;IACH,YAAY,SAAkC;QAC5C,KAAK,CAAC,SAAS,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;KAC/B;CACF;AAED;;;;GAIG;AACH,MAAM,IAAK,SAAQ,eAAe;IAChC;;;OAGG;IACH,YAAY,GAAG,SAAoC;QACjD,KAAK,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;KAC5B;CACF;AAED;;GAEG;AACH,MAAM,UAAW,SAAQ,eAAe;IACtC;;;;OAIG;IACH,YAAY,aAAkB,EAAE,KAAa;QAC3C,KAAK,CAAC,cAAc,EAAE,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC;KAC/C;CACF;AAED;;GAEG;AACH,MAAM,kBAAmB,SAAQ,eAAe;IAC9C;;;;OAIG;IACH,YAAY,aAAkB,EAAE,KAAa;QAC3C,KAAK,CAAC,sBAAsB,EAAE,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC;KACvD;CACF;AAED;;;GAGG;AACH,MAAM,cAAe,SAAQ,eAAe;IAC1C;;;;OAIG;IACH,YAAY,cAAwB,EAAE,cAAwB;QAC5D,KAAK,CAAC,kBAAkB,EAAE,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;KAC7D;CACF;AAED;;GAEG;AACH,MAAM,QAAS,SAAQ,MAAM;IAC3B;;;;;OAKG;IACH,YAAY,aAAqB;QAC/B,KAAK,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;KACpC;CACF;AAED;;GAEG;AACH,MAAM,SAAU,SAAQ,MAAM;IAC5B;;;;OAIG;IACH,YAAY,oBAA4B,EAAE,SAAiB;QACzD,KAAK,CAAC,aAAa,EAAE,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAC,CAAC;KACzD;CACF;AAED;;GAEG;AACH,MAAM,YAAa,SAAQ,MAAM;IAC/B;;;;OAIG;IACH,YAAY,aAAqB,EAAE,SAAiB;QAClD,KAAK,CAAC,gBAAgB,EAAE,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC;KACrD;CACF;AAED;;;;GAIG;AACH,MAAM,MAAM;IAMV;;;;;OAKG;IACH,YAAY,SAAiB,EAAE,YAAmB;QAChD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7B,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;SACtE;QAED,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,+BAAiB,EAAE,CAAC;KAC1C;IAEM,OAAO,CAAC,OAAwB;QACrC,IAAI,aAAK,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;YACzC,8DAA8D;YAC9D,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;SAC5D;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YACzB,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;SACpB;QACD,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC;KACnD;IAEM,QAAQ;QACb,OAAO,aAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;KAC1D;IAEM,MAAM;QACX,OAAO,YAAY,CAAC;KACrB;IAED;;;;OAIG;IACK,aAAa,CAAC,OAAwB;QAC5C,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,qBAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACrG,OAAO,+CAAyB,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;KAClE;CACF;AAED,SAAS,WAAW,CAAI,KAAU,EAAE,QAAgB;IAClD,MAAM,MAAM,GAAG,IAAI,KAAK,EAAO,CAAC;IAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,QAAQ,EAAE;QAC/C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;KAC3C;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,KAAK,CAAC,CAAS;IACtB,MAAM,GAAG,GAAG,EAAE,CAAC;IACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QAC1B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;KACb;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import { ICfnConditionExpression, ICfnRuleConditionExpression } from './cfn-condition';\nimport { minimalCloudFormationJoin } from './private/cloudformation-lang';\nimport { Intrinsic } from './private/intrinsic';\nimport { Reference } from './reference';\nimport { IResolvable, IResolveContext } from './resolvable';\nimport { captureStackTrace } from './stack-trace';\nimport { Token } from './token';\n\n/* eslint-disable max-len */\n\n/**\n * CloudFormation intrinsic functions.\n * http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html\n */\nexport class Fn {\n  /**\n   * The ``Ref`` intrinsic function returns the value of the specified parameter or resource.\n   * Note that it doesn't validate the logicalName, it mainly serves paremeter/resource reference defined in a ``CfnInclude`` template.\n   * @param logicalName The logical name of a parameter/resource for which you want to retrieve its value.\n   */\n  public static ref(logicalName: string): string {\n    return new FnRef(logicalName).toString();\n  }\n\n  /**\n   * The ``Fn::GetAtt`` intrinsic function returns the value of an attribute\n   * from a resource in the template.\n   * @param logicalNameOfResource The logical name (also called logical ID) of\n   * the resource that contains the attribute that you want.\n   * @param attributeName The name of the resource-specific attribute whose\n   * value you want. See the resource's reference page for details about the\n   * attributes available for that resource type.\n   * @returns an IResolvable object\n   */\n  public static getAtt(logicalNameOfResource: string, attributeName: string): IResolvable {\n    return new FnGetAtt(logicalNameOfResource, attributeName);\n  }\n\n  /**\n   * The intrinsic function ``Fn::Join`` appends a set of values into a single\n   * value, separated by the specified delimiter. If a delimiter is the empty\n   * string, the set of values are concatenated with no delimiter.\n   * @param delimiter The value you want to occur between fragments. The\n   * delimiter will occur between fragments only. It will not terminate the\n   * final value.\n   * @param listOfValues The list of values you want combined.\n   * @returns a token represented as a string\n   */\n  public static join(delimiter: string, listOfValues: string[]): string {\n    if (listOfValues.length === 0) {\n      throw new Error('FnJoin requires at least one value to be provided');\n    }\n\n    return new FnJoin(delimiter, listOfValues).toString();\n  }\n\n  /**\n   * Split a string token into a token list of string values.\n   *\n   * Specify the location of splits with a delimiter such as ',' (a comma).\n   * Renders to the `Fn::Split` intrinsic function.\n   *\n   * Lists with unknown lengths (default)\n   * -------------------------------------\n   *\n   * Since this function is used to work with deploy-time values, if `assumedLength`\n   * is not given the CDK cannot know the length of the resulting list at synthesis time.\n   * This brings the following restrictions:\n   *\n   * - You must use `Fn.select(i, list)` to pick elements out of the list (you must not use\n   *   `list[i]`).\n   * - You cannot add elements to the list, remove elements from the list,\n   *   combine two such lists together, or take a slice of the list.\n   * - You cannot pass the list to constructs that do any of the above.\n   *\n   * The only valid operation with such a tokenized list is to pass it unmodified to a\n   * CloudFormation Resource construct.\n   *\n   * Lists with assumed lengths\n   * --------------------------\n   *\n   * Pass `assumedLength` if you know the length of the list that will be\n   * produced by splitting. The actual list length at deploy time may be\n   * *longer* than the number you pass, but not *shorter*.\n   *\n   * The returned list will look like:\n   *\n   * ```\n   * [Fn.select(0, split), Fn.select(1, split), Fn.select(2, split), ...]\n   * ```\n   *\n   * The restrictions from the section \"Lists with unknown lengths\" will now be lifted,\n   * at the expense of having to know and fix the length of the list.\n   *\n   * @param delimiter A string value that determines where the source string is divided.\n   * @param source The string value that you want to split.\n   * @param assumedLength The length of the list that will be produced by splitting\n   * @returns a token represented as a string array\n   */\n  public static split(delimiter: string, source: string, assumedLength?: number): string[] {\n    // short-circut if source is not a token\n    if (!Token.isUnresolved(source)) {\n      return source.split(delimiter);\n    }\n\n    if (Token.isUnresolved(delimiter)) {\n      // Limitation of CloudFormation\n      throw new Error('Fn.split: \\'delimiter\\' may not be a token value');\n    }\n\n    const split = Token.asList(new FnSplit(delimiter, source));\n    if (assumedLength === undefined) {\n      return split;\n    }\n\n    if (Token.isUnresolved(assumedLength)) {\n      throw new Error('Fn.split: \\'assumedLength\\' may not be a token value');\n    }\n\n    return range(assumedLength).map(i => Fn.select(i, split));\n  }\n\n  /**\n   * The intrinsic function ``Fn::Select`` returns a single object from a list of objects by index.\n   * @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.\n   * @param array The list of objects to select from. This list must not be null, nor can it have null entries.\n   * @returns a token represented as a string\n   */\n  public static select(index: number, array: string[]): string {\n    if (!Token.isUnresolved(index) && !Token.isUnresolved(array) && !array.some(Token.isUnresolved)) {\n      return array[index];\n    }\n\n    return new FnSelect(index, array).toString();\n  }\n\n  /**\n   * The intrinsic function ``Fn::Sub`` substitutes variables in an input string\n   * with values that you specify. In your templates, you can use this function\n   * to construct commands or outputs that include values that aren't available\n   * until you create or update a stack.\n   * @param body A string with variables that AWS CloudFormation substitutes\n   * with their associated values at runtime. Write variables as ${MyVarName}.\n   * Variables can be template parameter names, resource logical IDs, resource\n   * attributes, or a variable in a key-value map. If you specify only template\n   * parameter names, resource logical IDs, and resource attributes, don't\n   * specify a key-value map.\n   * @param variables The name of a variable that you included in the String\n   * parameter. The value that AWS CloudFormation substitutes for the associated\n   * variable name at runtime.\n   * @returns a token represented as a string\n   */\n  public static sub(body: string, variables?: { [key: string]: string }): string {\n    return new FnSub(body, variables).toString();\n  }\n\n  /**\n   * The intrinsic function ``Fn::Base64`` returns the Base64 representation of\n   * the input string. This function is typically used to pass encoded data to\n   * Amazon EC2 instances by way of the UserData property.\n   * @param data The string value you want to convert to Base64.\n   * @returns a token represented as a string\n   */\n  public static base64(data: string): string {\n    return new FnBase64(data).toString();\n  }\n\n  /**\n   * The intrinsic function ``Fn::Cidr`` returns the specified Cidr address block.\n   * @param ipBlock  The user-specified default Cidr address block.\n   * @param count  The number of subnets' Cidr block wanted. Count can be 1 to 256.\n   * @param sizeMask The digit covered in the subnet.\n   * @returns a token represented as a string\n   */\n  public static cidr(ipBlock: string, count: number, sizeMask?: string): string[] {\n    return Token.asList(new FnCidr(ipBlock, count, sizeMask));\n  }\n\n  /**\n   * Given an url, parse the domain name\n   * @param url the url to parse\n   */\n  public static parseDomainName(url: string): string {\n    const noHttps = Fn.select(1, Fn.split('//', url));\n    return Fn.select(0, Fn.split('/', noHttps));\n  }\n\n  /**\n   * The intrinsic function ``Fn::GetAZs`` returns an array that lists\n   * Availability Zones for a specified region. Because customers have access to\n   * different Availability Zones, the intrinsic function ``Fn::GetAZs`` enables\n   * template authors to write templates that adapt to the calling user's\n   * access. That way you don't have to hard-code a full list of Availability\n   * Zones for a specified region.\n   * @param region The name of the region for which you want to get the\n   * Availability Zones. You can use the AWS::Region pseudo parameter to specify\n   * the region in which the stack is created. Specifying an empty string is\n   * equivalent to specifying AWS::Region.\n   * @returns a token represented as a string array\n   */\n  public static getAzs(region?: string): string[] {\n    return Token.asList(new FnGetAZs(region));\n  }\n\n  /**\n   * The intrinsic function ``Fn::ImportValue`` returns the value of an output\n   * exported by another stack. You typically use this function to create\n   * cross-stack references. In the following example template snippets, Stack A\n   * exports VPC security group values and Stack B imports them.\n   * @param sharedValueToImport The stack output value that you want to import.\n   * @returns a token represented as a string\n   */\n  public static importValue(sharedValueToImport: string): string {\n    return new FnImportValue(sharedValueToImport).toString();\n  }\n\n  /**\n   * Like `Fn.importValue`, but import a list with a known length\n   *\n   * If you explicitly want a list with an unknown length, call `Fn.split(',',\n   * Fn.importValue(exportName))`. See the documentation of `Fn.split` to read\n   * more about the limitations of using lists of unknown length.\n   *\n   * `Fn.importListValue(exportName, assumedLength)` is the same as\n   * `Fn.split(',', Fn.importValue(exportName), assumedLength)`,\n   * but easier to read and impossible to forget to pass `assumedLength`.\n   */\n  public static importListValue(sharedValueToImport: string, assumedLength: number, delimiter = ','): string[] {\n    return Fn.split(delimiter, Fn.importValue(sharedValueToImport), assumedLength);\n  }\n\n  /**\n   * The intrinsic function ``Fn::FindInMap`` returns the value corresponding to\n   * keys in a two-level map that is declared in the Mappings section.\n   * @returns a token represented as a string\n   */\n  public static findInMap(mapName: string, topLevelKey: string, secondLevelKey: string): string {\n    return Fn._findInMap(mapName, topLevelKey, secondLevelKey).toString();\n  }\n\n  /**\n   * An additional function used in CfnParser,\n   * as Fn::FindInMap does not always return a string.\n   *\n   * @internal\n   */\n  public static _findInMap(mapName: string, topLevelKey: string, secondLevelKey: string): IResolvable {\n    return new FnFindInMap(mapName, topLevelKey, secondLevelKey);\n  }\n\n  /**\n   * Creates a token representing the ``Fn::Transform`` expression\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-transform.html\n   * @param macroName The name of the macro to perform the processing\n   * @param parameters The parameters to be passed to the macro\n   * @returns a token representing the transform expression\n   */\n  public static transform(macroName: string, parameters: { [name: string]: any }): IResolvable {\n    return new FnTransform(macroName, parameters);\n  }\n\n  /**\n   * Returns true if all the specified conditions evaluate to true, or returns\n   * false if any one of the conditions evaluates to false. ``Fn::And`` acts as\n   * an AND operator. The minimum number of conditions that you can include is\n   * 1.\n   * @param conditions conditions to AND\n   * @returns an FnCondition token\n   */\n  public static conditionAnd(...conditions: ICfnConditionExpression[]): ICfnRuleConditionExpression {\n    if (conditions.length === 0) {\n      throw new Error('Fn.conditionAnd() needs at least one argument');\n    }\n    if (conditions.length === 1) {\n      return conditions[0] as ICfnRuleConditionExpression;\n    }\n    return Fn.conditionAnd(..._inGroupsOf(conditions, 10).map(group => new FnAnd(...group)));\n  }\n\n  /**\n   * Compares if two values are equal. Returns true if the two values are equal\n   * or false if they aren't.\n   * @param lhs A value of any type that you want to compare.\n   * @param rhs A value of any type that you want to compare.\n   * @returns an FnCondition token\n   */\n  public static conditionEquals(lhs: any, rhs: any): ICfnRuleConditionExpression {\n    return new FnEquals(lhs, rhs);\n  }\n\n  /**\n   * Returns one value if the specified condition evaluates to true and another\n   * value if the specified condition evaluates to false. Currently, AWS\n   * CloudFormation supports the ``Fn::If`` intrinsic function in the metadata\n   * attribute, update policy attribute, and property values in the Resources\n   * section and Outputs sections of a template. You can use the AWS::NoValue\n   * pseudo parameter as a return value to remove the corresponding property.\n   * @param conditionId A reference to a condition in the Conditions section. Use\n   * the condition's name to reference it.\n   * @param valueIfTrue A value to be returned if the specified condition\n   * evaluates to true.\n   * @param valueIfFalse A value to be returned if the specified condition\n   * evaluates to false.\n   * @returns an FnCondition token\n   */\n  public static conditionIf(conditionId: string, valueIfTrue: any, valueIfFalse: any): ICfnRuleConditionExpression {\n    return new FnIf(conditionId, valueIfTrue, valueIfFalse);\n  }\n\n  /**\n   * Returns true for a condition that evaluates to false or returns false for a\n   * condition that evaluates to true. ``Fn::Not`` acts as a NOT operator.\n   * @param condition A condition such as ``Fn::Equals`` that evaluates to true\n   * or false.\n   * @returns an FnCondition token\n   */\n  public static conditionNot(condition: ICfnConditionExpression): ICfnRuleConditionExpression {\n    return new FnNot(condition);\n  }\n\n  /**\n   * Returns true if any one of the specified conditions evaluate to true, or\n   * returns false if all of the conditions evaluates to false. ``Fn::Or`` acts\n   * as an OR operator. The minimum number of conditions that you can include is\n   * 1.\n   * @param conditions conditions that evaluates to true or false.\n   * @returns an FnCondition token\n   */\n  public static conditionOr(...conditions: ICfnConditionExpression[]): ICfnRuleConditionExpression {\n    if (conditions.length === 0) {\n      throw new Error('Fn.conditionOr() needs at least one argument');\n    }\n    if (conditions.length === 1) {\n      return conditions[0] as ICfnRuleConditionExpression;\n    }\n    return Fn.conditionOr(..._inGroupsOf(conditions, 10).map(group => new FnOr(...group)));\n  }\n\n  /**\n   * Returns true if a specified string matches at least one value in a list of\n   * strings.\n   * @param listOfStrings A list of strings, such as \"A\", \"B\", \"C\".\n   * @param value A string, such as \"A\", that you want to compare against a list of strings.\n   * @returns an FnCondition token\n   */\n  public static conditionContains(listOfStrings: string[], value: string): ICfnRuleConditionExpression {\n    return new FnContains(listOfStrings, value);\n  }\n\n  /**\n   * Returns true if a specified string matches all values in a list.\n   * @param listOfStrings A list of strings, such as \"A\", \"B\", \"C\".\n   * @param value A string, such as \"A\", that you want to compare against a list\n   * of strings.\n   * @returns an FnCondition token\n   */\n  public static conditionEachMemberEquals(listOfStrings: string[], value: string): ICfnRuleConditionExpression {\n    return new FnEachMemberEquals(listOfStrings, value);\n  }\n\n  /**\n   * Returns true if each member in a list of strings matches at least one value\n   * in a second list of strings.\n   * @param stringsToCheck A list of strings, such as \"A\", \"B\", \"C\". AWS\n   * CloudFormation checks whether each member in the strings_to_check parameter\n   * is in the strings_to_match parameter.\n   * @param stringsToMatch A list of strings, such as \"A\", \"B\", \"C\". Each member\n   * in the strings_to_match parameter is compared against the members of the\n   * strings_to_check parameter.\n   * @returns an FnCondition token\n   */\n  public static conditionEachMemberIn(stringsToCheck: string[], stringsToMatch: string[]): ICfnRuleConditionExpression {\n    return new FnEachMemberIn(stringsToCheck, stringsToMatch);\n  }\n\n  /**\n   * Returns all values for a specified parameter type.\n   * @param parameterType An AWS-specific parameter type, such as\n   * AWS::EC2::SecurityGroup::Id or AWS::EC2::VPC::Id. For more information, see\n   * Parameters in the AWS CloudFormation User Guide.\n   * @returns a token represented as a string array\n   */\n  public static refAll(parameterType: string): string[] {\n    return Token.asList(new FnRefAll(parameterType));\n  }\n\n  /**\n   * Returns an attribute value or list of values for a specific parameter and\n   * attribute.\n   * @param parameterOrLogicalId The name of a parameter for which you want to\n   * retrieve attribute values. The parameter must be declared in the Parameters\n   * section of the template.\n   * @param attribute The name of an attribute from which you want to retrieve a\n   * value.\n   * @returns a token represented as a string\n   */\n  public static valueOf(parameterOrLogicalId: string, attribute: string): string {\n    return new FnValueOf(parameterOrLogicalId, attribute).toString();\n  }\n\n  /**\n   * Returns a list of all attribute values for a given parameter type and\n   * attribute.\n   * @param parameterType An AWS-specific parameter type, such as\n   * AWS::EC2::SecurityGroup::Id or AWS::EC2::VPC::Id. For more information, see\n   * Parameters in the AWS CloudFormation User Guide.\n   * @param attribute The name of an attribute from which you want to retrieve a\n   * value. For more information about attributes, see Supported Attributes.\n   * @returns a token represented as a string array\n   */\n  public static valueOfAll(parameterType: string, attribute: string): string[] {\n    return Token.asList(new FnValueOfAll(parameterType, attribute));\n  }\n\n  private constructor() { }\n}\n\n/**\n * Base class for tokens that represent CloudFormation intrinsic functions.\n */\nclass FnBase extends Intrinsic {\n  constructor(name: string, value: any) {\n    super({ [name]: value });\n  }\n}\n\n/**\n * The intrinsic function ``Ref`` returns the value of the specified parameter or resource.\n * When you specify a parameter's logical name, it returns the value of the parameter.\n * 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.\n */\nclass FnRef extends FnBase {\n  /**\n   * Creates an ``Ref`` function.\n   * @param logicalName The logical name of a parameter/resource for which you want to retrieve its value.\n   */\n  constructor(logicalName: string) {\n    super('Ref', logicalName);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::FindInMap`` returns the value corresponding to keys in a two-level\n * map that is declared in the Mappings section.\n */\nclass FnFindInMap extends FnBase {\n  /**\n   * Creates an ``Fn::FindInMap`` function.\n   * @param mapName The logical name of a mapping declared in the Mappings section that contains the keys and values.\n   * @param topLevelKey The top-level key name. Its value is a list of key-value pairs.\n   * @param secondLevelKey The second-level key name, which is set to one of the keys from the list assigned to TopLevelKey.\n   */\n  constructor(mapName: string, topLevelKey: any, secondLevelKey: any) {\n    super('Fn::FindInMap', [mapName, topLevelKey, secondLevelKey]);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Transform`` specifies a macro to perform custom processing on part of a stack template.\n */\nclass FnTransform extends FnBase {\n  /**\n   * creates an ``Fn::Transform`` function.\n   * @param macroName The name of the macro to be invoked\n   * @param parameters the parameters to pass to it\n   */\n  constructor(macroName: string, parameters: { [name: string]: any }) {\n    super('Fn::Transform', { Name: macroName, Parameters: parameters });\n  }\n}\n\n/**\n * The ``Fn::GetAtt`` intrinsic function returns the value of an attribute from a resource in the template.\n */\nclass FnGetAtt extends FnBase {\n  /**\n   * Creates a ``Fn::GetAtt`` function.\n   * @param logicalNameOfResource The logical name (also called logical ID) of the resource that contains the attribute that you want.\n   * @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.\n   */\n  constructor(logicalNameOfResource: string, attributeName: string) {\n    super('Fn::GetAtt', [logicalNameOfResource, attributeName]);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::GetAZs`` returns an array that lists Availability Zones for a\n * specified region. Because customers have access to different Availability Zones, the intrinsic\n * function ``Fn::GetAZs`` enables template authors to write templates that adapt to the calling\n * user's access. That way you don't have to hard-code a full list of Availability Zones for a\n * specified region.\n */\nclass FnGetAZs extends FnBase {\n  /**\n   * Creates an ``Fn::GetAZs`` function.\n   * @param region The name of the region for which you want to get the Availability Zones.\n   *         You can use the AWS::Region pseudo parameter to specify the region in\n   *         which the stack is created. Specifying an empty string is equivalent to\n   *         specifying AWS::Region.\n   */\n  constructor(region?: string) {\n    super('Fn::GetAZs', region || '');\n  }\n}\n\n/**\n * The intrinsic function ``Fn::ImportValue`` returns the value of an output exported by another stack.\n * You typically use this function to create cross-stack references. In the following example\n * template snippets, Stack A exports VPC security group values and Stack B imports them.\n */\nclass FnImportValue extends FnBase {\n  /**\n   * Creates an ``Fn::ImportValue`` function.\n   * @param sharedValueToImport The stack output value that you want to import.\n   */\n  constructor(sharedValueToImport: string) {\n    super('Fn::ImportValue', sharedValueToImport);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Select`` returns a single object from a list of objects by index.\n */\nclass FnSelect extends FnBase {\n  /**\n   * Creates an ``Fn::Select`` function.\n   * @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.\n   * @param array The list of objects to select from. This list must not be null, nor can it have null entries.\n   */\n  constructor(index: number, array: any) {\n    super('Fn::Select', [index, array]);\n  }\n}\n\n/**\n * To split a string into a list of string values so that you can select an element from the\n * resulting string list, use the ``Fn::Split`` intrinsic function. Specify the location of splits\n * with a delimiter, such as , (a comma). After you split a string, use the ``Fn::Select`` function\n * to pick a specific element.\n */\nclass FnSplit extends FnBase {\n  /**\n   * Create an ``Fn::Split`` function.\n   * @param delimiter A string value that determines where the source string is divided.\n   * @param source The string value that you want to split.\n   */\n  constructor(delimiter: string, source: any) {\n    super('Fn::Split', [delimiter, source]);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Sub`` substitutes variables in an input string with values that\n * you specify. In your templates, you can use this function to construct commands or outputs\n * that include values that aren't available until you create or update a stack.\n */\nclass FnSub extends FnBase {\n  /**\n   * Creates an ``Fn::Sub`` function.\n   * @param body A string with variables that AWS CloudFormation substitutes with their\n   *       associated values at runtime. Write variables as ${MyVarName}. Variables\n   *       can be template parameter names, resource logical IDs, resource attributes,\n   *       or a variable in a key-value map. If you specify only template parameter names,\n   *       resource logical IDs, and resource attributes, don't specify a key-value map.\n   * @param variables The name of a variable that you included in the String parameter.\n   *          The value that AWS CloudFormation substitutes for the associated variable name at runtime.\n   */\n  constructor(body: string, variables?: { [key: string]: any }) {\n    super('Fn::Sub', variables ? [body, variables] : body);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Base64`` returns the Base64 representation of the input string.\n * This function is typically used to pass encoded data to Amazon EC2 instances by way of\n * the UserData property.\n */\nclass FnBase64 extends FnBase {\n\n  /**\n   * Creates an ``Fn::Base64`` function.\n   * @param data The string value you want to convert to Base64.\n   */\n  constructor(data: any) {\n    super('Fn::Base64', data);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Cidr`` returns the specified Cidr address block.\n */\nclass FnCidr extends FnBase {\n  /**\n   * Creates an ``Fn::Cidr`` function.\n   * @param ipBlock  The user-specified default Cidr address block.\n   * @param count  The number of subnets' Cidr block wanted. Count can be 1 to 256.\n   * @param sizeMask The digit covered in the subnet.\n   */\n  constructor(ipBlock: any, count: any, sizeMask?: any) {\n    if (count < 1 || count > 256) {\n      throw new Error(`Fn::Cidr's count attribute must be betwen 1 and 256, ${count} was provided.`);\n    }\n    super('Fn::Cidr', [ipBlock, count, sizeMask]);\n  }\n}\n\nclass FnConditionBase extends Intrinsic implements ICfnRuleConditionExpression {\n  readonly disambiguator = true;\n  constructor(type: string, value: any) {\n    super({ [type]: value });\n  }\n}\n\n/**\n * Returns true if all the specified conditions evaluate to true, or returns false if any one\n *  of the conditions evaluates to false. ``Fn::And`` acts as an AND operator. The minimum number of\n * conditions that you can include is 2, and the maximum is 10.\n */\nclass FnAnd extends FnConditionBase {\n  constructor(...condition: ICfnConditionExpression[]) {\n    super('Fn::And', condition);\n  }\n}\n\n/**\n * Compares if two values are equal. Returns true if the two values are equal or false\n * if they aren't.\n */\nclass FnEquals extends FnConditionBase {\n  /**\n   * Creates an ``Fn::Equals`` condition function.\n   * @param lhs A value of any type that you want to compare.\n   * @param rhs A value of any type that you want to compare.\n   */\n  constructor(lhs: any, rhs: any) {\n    super('Fn::Equals', [lhs, rhs]);\n  }\n}\n\n/**\n * Returns one value if the specified condition evaluates to true and another value if the\n * specified condition evaluates to false. Currently, AWS CloudFormation supports the ``Fn::If``\n * intrinsic function in the metadata attribute, update policy attribute, and property values\n * in the Resources section and Outputs sections of a template. You can use the AWS::NoValue\n * pseudo parameter as a return value to remove the corresponding property.\n */\nclass FnIf extends FnConditionBase {\n  /**\n   * Creates an ``Fn::If`` condition function.\n   * @param condition A reference to a condition in the Conditions section. Use the condition's name to reference it.\n   * @param valueIfTrue A value to be returned if the specified condition evaluates to true.\n   * @param valueIfFalse A value to be returned if the specified condition evaluates to false.\n   */\n  constructor(condition: string, valueIfTrue: any, valueIfFalse: any) {\n    super('Fn::If', [condition, valueIfTrue, valueIfFalse]);\n  }\n}\n\n/**\n * Returns true for a condition that evaluates to false or returns false for a condition that evaluates to true.\n * ``Fn::Not`` acts as a NOT operator.\n */\nclass FnNot extends FnConditionBase {\n  /**\n   * Creates an ``Fn::Not`` condition function.\n   * @param condition A condition such as ``Fn::Equals`` that evaluates to true or false.\n   */\n  constructor(condition: ICfnConditionExpression) {\n    super('Fn::Not', [condition]);\n  }\n}\n\n/**\n * Returns true if any one of the specified conditions evaluate to true, or returns false if\n * all of the conditions evaluates to false. ``Fn::Or`` acts as an OR operator. The minimum number\n * of conditions that you can include is 2, and the maximum is 10.\n */\nclass FnOr extends FnConditionBase {\n  /**\n   * Creates an ``Fn::Or`` condition function.\n   * @param condition A condition that evaluates to true or false.\n   */\n  constructor(...condition: ICfnConditionExpression[]) {\n    super('Fn::Or', condition);\n  }\n}\n\n/**\n * Returns true if a specified string matches at least one value in a list of strings.\n */\nclass FnContains extends FnConditionBase {\n  /**\n   * Creates an ``Fn::Contains`` function.\n   * @param listOfStrings A list of strings, such as \"A\", \"B\", \"C\".\n   * @param value A string, such as \"A\", that you want to compare against a list of strings.\n   */\n  constructor(listOfStrings: any, value: string) {\n    super('Fn::Contains', [listOfStrings, value]);\n  }\n}\n\n/**\n * Returns true if a specified string matches all values in a list.\n */\nclass FnEachMemberEquals extends FnConditionBase {\n  /**\n   * Creates an ``Fn::EachMemberEquals`` function.\n   * @param listOfStrings A list of strings, such as \"A\", \"B\", \"C\".\n   * @param value A string, such as \"A\", that you want to compare against a list of strings.\n   */\n  constructor(listOfStrings: any, value: string) {\n    super('Fn::EachMemberEquals', [listOfStrings, value]);\n  }\n}\n\n/**\n * Returns true if each member in a list of strings matches at least one value in a second\n * list of strings.\n */\nclass FnEachMemberIn extends FnConditionBase {\n  /**\n   * Creates an ``Fn::EachMemberIn`` function.\n   * @param stringsToCheck A list of strings, such as \"A\", \"B\", \"C\". AWS CloudFormation checks whether each member in the strings_to_check parameter is in the strings_to_match parameter.\n   * @param stringsToMatch A list of strings, such as \"A\", \"B\", \"C\". Each member in the strings_to_match parameter is compared against the members of the strings_to_check parameter.\n   */\n  constructor(stringsToCheck: string[], stringsToMatch: string[]) {\n    super('Fn::EachMemberIn', [stringsToCheck, stringsToMatch]);\n  }\n}\n\n/**\n * Returns all values for a specified parameter type.\n */\nclass FnRefAll extends FnBase {\n  /**\n   * Creates an ``Fn::RefAll`` function.\n   * @param parameterType An AWS-specific parameter type, such as AWS::EC2::SecurityGroup::Id or\n   *            AWS::EC2::VPC::Id. For more information, see Parameters in the AWS\n   *            CloudFormation User Guide.\n   */\n  constructor(parameterType: string) {\n    super('Fn::RefAll', parameterType);\n  }\n}\n\n/**\n * Returns an attribute value or list of values for a specific parameter and attribute.\n */\nclass FnValueOf extends FnBase {\n  /**\n   * Creates an ``Fn::ValueOf`` function.\n   * @param parameterOrLogicalId 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.\n   * @param attribute The name of an attribute from which you want to retrieve a value.\n   */\n  constructor(parameterOrLogicalId: string, attribute: string) {\n    super('Fn::ValueOf', [parameterOrLogicalId, attribute]);\n  }\n}\n\n/**\n * Returns a list of all attribute values for a given parameter type and attribute.\n */\nclass FnValueOfAll extends FnBase {\n  /**\n   * Creates an ``Fn::ValueOfAll`` function.\n   * @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.\n   * @param attribute The name of an attribute from which you want to retrieve a value. For more information about attributes, see Supported Attributes.\n   */\n  constructor(parameterType: string, attribute: string) {\n    super('Fn::ValueOfAll', [parameterType, attribute]);\n  }\n}\n\n/**\n * The intrinsic function ``Fn::Join`` appends a set of values into a single value, separated by\n * the specified delimiter. If a delimiter is the empty string, the set of values are concatenated\n * with no delimiter.\n */\nclass FnJoin implements IResolvable {\n  public readonly creationStack: string[];\n\n  private readonly delimiter: string;\n  private readonly listOfValues: any[];\n\n  /**\n   * Creates an ``Fn::Join`` function.\n   * @param delimiter The value you want to occur between fragments. The delimiter will occur between fragments only.\n   *          It will not terminate the final value.\n   * @param listOfValues The list of values you want combined.\n   */\n  constructor(delimiter: string, listOfValues: any[]) {\n    if (listOfValues.length === 0) {\n      throw new Error('FnJoin requires at least one value to be provided');\n    }\n\n    this.delimiter = delimiter;\n    this.listOfValues = listOfValues;\n    this.creationStack = captureStackTrace();\n  }\n\n  public resolve(context: IResolveContext): any {\n    if (Token.isUnresolved(this.listOfValues)) {\n      // This is a list token, don't try to do smart things with it.\n      return { 'Fn::Join': [this.delimiter, this.listOfValues] };\n    }\n    const resolved = this.resolveValues(context);\n    if (resolved.length === 1) {\n      return resolved[0];\n    }\n    return { 'Fn::Join': [this.delimiter, resolved] };\n  }\n\n  public toString() {\n    return Token.asString(this, { displayHint: 'Fn::Join' });\n  }\n\n  public toJSON() {\n    return '<Fn::Join>';\n  }\n\n  /**\n   * Optimization: if an Fn::Join is nested in another one and they share the same delimiter, then flatten it up. Also,\n   * if two concatenated elements are literal strings (not tokens), then pre-concatenate them with the delimiter, to\n   * generate shorter output.\n   */\n  private resolveValues(context: IResolveContext) {\n    const resolvedValues = this.listOfValues.map(x => Reference.isReference(x) ? x : context.resolve(x));\n    return minimalCloudFormationJoin(this.delimiter, resolvedValues);\n  }\n}\n\nfunction _inGroupsOf<T>(array: T[], maxGroup: number): T[][] {\n  const result = new Array<T[]>();\n  for (let i = 0; i < array.length; i += maxGroup) {\n    result.push(array.slice(i, i + maxGroup));\n  }\n  return result;\n}\n\nfunction range(n: number): number[] {\n  const ret = [];\n  for (let i = 0; i < n; i++) {\n    ret.push(i);\n  }\n  return ret;\n}"]}