@pulumi/aws 7.52.0 → 7.52.1

package/iot/roleAlias.js.map

@@ -1 +1 @@
-{"version":3,"file":"roleAlias.js","sourceRoot":"","sources":["../../iot/roleAlias.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjF,uDAAyC;AACzC,wDAA0C;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAa,SAAU,SAAQ,MAAM,CAAC,cAAc;IAChD;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAsB,EAAE,IAAmC;QACpH,OAAO,IAAI,SAAS,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,gBAAgB;IACT,MAAM,CAAU,YAAY,GAAG,6BAA6B,CAAC;IAEpE;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,SAAS,CAAC,YAAY,CAAC;IAC1D,CAAC;IAuCD,YAAY,IAAY,EAAE,WAA4C,EAAE,IAAmC;QACvG,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAAyC,CAAC;YACxD,cAAc,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC;YACvC,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC;YACnC,cAAc,CAAC,oBAAoB,CAAC,GAAG,KAAK,EAAE,kBAAkB,CAAC;YACjE,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC;YACzC,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;YAC3C,cAAc,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC;YACrC,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;SAC9C;aAAM;YACH,MAAM,IAAI,GAAG,WAAwC,CAAC;YACtD,IAAI,IAAI,EAAE,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBACxC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;aACxD;YACD,IAAI,IAAI,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1C,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;aAC1D;YACD,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC;YACtC,cAAc,CAAC,oBAAoB,CAAC,GAAG,IAAI,EAAE,kBAAkB,CAAC;YAChE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC;YACxC,cAAc,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC;YAC1C,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,IAAI,CAAC;YACpC,cAAc,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YAC1C,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;SACjD;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,KAAK,CAAC,SAAS,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;;AA/FL,8BAgGC"}
+{"version":3,"file":"roleAlias.js","sourceRoot":"","sources":["../../iot/roleAlias.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjF,uDAAyC;AACzC,wDAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAa,SAAU,SAAQ,MAAM,CAAC,cAAc;IAChD;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,EAA2B,EAAE,KAAsB,EAAE,IAAmC;QACpH,OAAO,IAAI,SAAS,CAAC,IAAI,EAAO,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IAChE,CAAC;IAED,gBAAgB;IACT,MAAM,CAAU,YAAY,GAAG,6BAA6B,CAAC;IAEpE;;;OAGG;IACI,MAAM,CAAC,UAAU,CAAC,GAAQ;QAC7B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;YACnC,OAAO,KAAK,CAAC;SAChB;QACD,OAAO,GAAG,CAAC,cAAc,CAAC,KAAK,SAAS,CAAC,YAAY,CAAC;IAC1D,CAAC;IAuCD,YAAY,IAAY,EAAE,WAA4C,EAAE,IAAmC;QACvG,IAAI,cAAc,GAAkB,EAAE,CAAC;QACvC,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAClB,IAAI,IAAI,CAAC,EAAE,EAAE;YACT,MAAM,KAAK,GAAG,WAAyC,CAAC;YACxD,cAAc,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC;YACvC,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC;YACnC,cAAc,CAAC,oBAAoB,CAAC,GAAG,KAAK,EAAE,kBAAkB,CAAC;YACjE,cAAc,CAAC,QAAQ,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC;YACzC,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;YAC3C,cAAc,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,IAAI,CAAC;YACrC,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC;SAC9C;aAAM;YACH,MAAM,IAAI,GAAG,WAAwC,CAAC;YACtD,IAAI,IAAI,EAAE,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBACxC,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;aACxD;YACD,IAAI,IAAI,EAAE,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1C,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;aAC1D;YACD,cAAc,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC;YACtC,cAAc,CAAC,oBAAoB,CAAC,GAAG,IAAI,EAAE,kBAAkB,CAAC;YAChE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC;YACxC,cAAc,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC;YAC1C,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,IAAI,CAAC;YACpC,cAAc,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;YAC1C,cAAc,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC;SACjD;QACD,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;QACnE,KAAK,CAAC,SAAS,CAAC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;;AA/FL,8BAgGC"}

package/lambda/getFunction.d.ts

@@ -74,7 +74,7 @@ import * as outputs from "../types/output";
  *     name: "new-function",
  *     role: reference.then(reference => reference.role),
  *     handler: reference.then(reference => reference.handler),
- *     runtime: aws.lambda.Runtime[reference.then(reference => reference.runtime)],
+ *     runtime: reference.then(reference => reference.runtime),
  *     memorySize: reference.then(reference => reference.memorySize),
  *     timeout: reference.then(reference => reference.timeout),
  *     architectures: reference.then(reference => reference.architectures),
@@ -114,9 +114,9 @@ import * as outputs from "../types/output";
  *     functionName: "my-durable-function",
  * });
  * export const durableSettings = {
- *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs).length.apply(length => length > 0),
- *     executionTimeout: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
- *     retentionPeriod: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
+ *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs.length).then(length => length > 0),
+ *     executionTimeout: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
+ *     retentionPeriod: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
  * };
  * ```
  */
@@ -380,7 +380,7 @@ export interface GetFunctionResult {
  *     name: "new-function",
  *     role: reference.then(reference => reference.role),
  *     handler: reference.then(reference => reference.handler),
- *     runtime: aws.lambda.Runtime[reference.then(reference => reference.runtime)],
+ *     runtime: reference.then(reference => reference.runtime),
  *     memorySize: reference.then(reference => reference.memorySize),
  *     timeout: reference.then(reference => reference.timeout),
  *     architectures: reference.then(reference => reference.architectures),
@@ -420,9 +420,9 @@ export interface GetFunctionResult {
  *     functionName: "my-durable-function",
  * });
  * export const durableSettings = {
- *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs).length.apply(length => length > 0),
- *     executionTimeout: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
- *     retentionPeriod: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
+ *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs.length).then(length => length > 0),
+ *     executionTimeout: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
+ *     retentionPeriod: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
  * };
  * ```
  */

package/lambda/getFunction.js

@@ -102,7 +102,7 @@ const utilities = __importStar(require("../utilities"));
  *     name: "new-function",
  *     role: reference.then(reference => reference.role),
  *     handler: reference.then(reference => reference.handler),
- *     runtime: aws.lambda.Runtime[reference.then(reference => reference.runtime)],
+ *     runtime: reference.then(reference => reference.runtime),
  *     memorySize: reference.then(reference => reference.memorySize),
  *     timeout: reference.then(reference => reference.timeout),
  *     architectures: reference.then(reference => reference.architectures),
@@ -142,9 +142,9 @@ const utilities = __importStar(require("../utilities"));
  *     functionName: "my-durable-function",
  * });
  * export const durableSettings = {
- *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs).length.apply(length => length > 0),
- *     executionTimeout: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
- *     retentionPeriod: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
+ *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs.length).then(length => length > 0),
+ *     executionTimeout: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
+ *     retentionPeriod: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
  * };
  * ```
  */
@@ -232,7 +232,7 @@ exports.getFunction = getFunction;
  *     name: "new-function",
  *     role: reference.then(reference => reference.role),
  *     handler: reference.then(reference => reference.handler),
- *     runtime: aws.lambda.Runtime[reference.then(reference => reference.runtime)],
+ *     runtime: reference.then(reference => reference.runtime),
  *     memorySize: reference.then(reference => reference.memorySize),
  *     timeout: reference.then(reference => reference.timeout),
  *     architectures: reference.then(reference => reference.architectures),
@@ -272,9 +272,9 @@ exports.getFunction = getFunction;
  *     functionName: "my-durable-function",
  * });
  * export const durableSettings = {
- *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs).length.apply(length => length > 0),
- *     executionTimeout: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
- *     retentionPeriod: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
+ *     hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs.length).then(length => length > 0),
+ *     executionTimeout: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
+ *     retentionPeriod: Promise.all([durableFunction.then(durableFunction => durableFunction.durableConfigs.length), durableFunction]).then(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
  * };
  * ```
  */

package/lambda/getFunctionUrl.d.ts

@@ -51,7 +51,7 @@ import * as outputs from "../types/output";
  * const example = aws.lambda.getFunctionUrl({
  *     functionName: "api_function",
  * });
- * const corsConfig = pulumi.all([example.then(example => example.cors).length, example]).apply(([length, example]) => length > 0 ? example.cors?.[0] : null);
+ * const corsConfig = Promise.all([example.then(example => example.cors.length), example]).then(([length, example]) => length > 0 ? example.cors?.[0] : null);
  * const allowedOrigins = corsConfig != null ? corsConfig?.allowOrigins : [];
  * export const corsAllowedOrigins = allowedOrigins;
  * ```
@@ -171,7 +171,7 @@ export interface GetFunctionUrlResult {
  * const example = aws.lambda.getFunctionUrl({
  *     functionName: "api_function",
  * });
- * const corsConfig = pulumi.all([example.then(example => example.cors).length, example]).apply(([length, example]) => length > 0 ? example.cors?.[0] : null);
+ * const corsConfig = Promise.all([example.then(example => example.cors.length), example]).then(([length, example]) => length > 0 ? example.cors?.[0] : null);
  * const allowedOrigins = corsConfig != null ? corsConfig?.allowOrigins : [];
  * export const corsAllowedOrigins = allowedOrigins;
  * ```

package/lambda/getFunctionUrl.js

@@ -79,7 +79,7 @@ const utilities = __importStar(require("../utilities"));
  * const example = aws.lambda.getFunctionUrl({
  *     functionName: "api_function",
  * });
- * const corsConfig = pulumi.all([example.then(example => example.cors).length, example]).apply(([length, example]) => length > 0 ? example.cors?.[0] : null);
+ * const corsConfig = Promise.all([example.then(example => example.cors.length), example]).then(([length, example]) => length > 0 ? example.cors?.[0] : null);
  * const allowedOrigins = corsConfig != null ? corsConfig?.allowOrigins : [];
  * export const corsAllowedOrigins = allowedOrigins;
  * ```
@@ -144,7 +144,7 @@ exports.getFunctionUrl = getFunctionUrl;
  * const example = aws.lambda.getFunctionUrl({
  *     functionName: "api_function",
  * });
- * const corsConfig = pulumi.all([example.then(example => example.cors).length, example]).apply(([length, example]) => length > 0 ? example.cors?.[0] : null);
+ * const corsConfig = Promise.all([example.then(example => example.cors.length), example]).then(([length, example]) => length > 0 ? example.cors?.[0] : null);
  * const allowedOrigins = corsConfig != null ? corsConfig?.allowOrigins : [];
  * export const corsAllowedOrigins = allowedOrigins;
  * ```

package/lambda/getFunctions.d.ts

@@ -11,7 +11,7 @@ import * as pulumi from "@pulumi/pulumi";
  * import * as aws from "@pulumi/aws";
  *
  * const all = aws.lambda.getFunctions({});
- * export const functionCount = all.then(all => all.functionNames).length;
+ * export const functionCount = all.then(all => all.functionNames.length);
  * export const allFunctionNames = all.then(all => all.functionNames);
  * ```
  *
@@ -21,32 +21,34 @@ import * as pulumi from "@pulumi/pulumi";
  * import * as pulumi from "@pulumi/pulumi";
  * import * as aws from "@pulumi/aws";
  *
- * // Get all Lambda functions
- * const all = aws.lambda.getFunctions({});
- * // Create CloudWatch alarms for all functions
- * const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
- * all.then(all => all.functionNames).length.apply(rangeBody => {
- *     for (let range = 0; range < rangeBody; range++) {
- *         lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
- *             name: all.then(all => `${all.functionNames[range]}-errors`),
- *             comparisonOperator: "GreaterThanThreshold",
- *             evaluationPeriods: 2,
- *             metricName: "Errors",
- *             namespace: "AWS/Lambda",
- *             period: 300,
- *             statistic: "Sum",
- *             threshold: 5,
- *             alarmDescription: "This metric monitors lambda errors",
- *             dimensions: {
- *                 FunctionName: all.then(all => all.functionNames[range]),
- *             },
- *             tags: {
- *                 Environment: "monitoring",
- *                 Purpose: "lambda-error-tracking",
- *             },
- *         }));
- *     }
- * });
+ * export = async () => {
+ *     // Get all Lambda functions
+ *     const all = await aws.lambda.getFunctions({});
+ *     // Create CloudWatch alarms for all functions
+ *     const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
+ * all.functionNames.length.apply(rangeBody => {
+ *         for (let range = 0; range < rangeBody; range++) {
+ *             lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
+ *                 name: `${all.functionNames[range]}-errors`,
+ *                 comparisonOperator: "GreaterThanThreshold",
+ *                 evaluationPeriods: 2,
+ *                 metricName: "Errors",
+ *                 namespace: "AWS/Lambda",
+ *                 period: 300,
+ *                 statistic: "Sum",
+ *                 threshold: 5,
+ *                 alarmDescription: "This metric monitors lambda errors",
+ *                 dimensions: {
+ *                     FunctionName: all.functionNames[range],
+ *                 },
+ *                 tags: {
+ *                     Environment: "monitoring",
+ *                     Purpose: "lambda-error-tracking",
+ *                 },
+ *             }));
+ *         }
+ *     });
+ * }
  * ```
  *
  * ### Filter Functions by Name Pattern
@@ -100,16 +102,16 @@ import * as pulumi from "@pulumi/pulumi";
  * export = async () => {
  *     const all = await aws.lambda.getFunctions({});
  *     // Get detailed information for each function
- *     const details = .map(__index => (await aws.lambda.getFunction({
+ *     const details = Array.from({length: all.functionNames.length}, (_, i) => i).apply(range => range.map(__index => (await aws.lambda.getFunction({
  *         functionName: all.functionNames[__index],
- *     })));
+ *     }))));
  *     const functionInventory = .map(([i, name]) => ({
  *         name: name,
  *         arn: all.functionArns[i],
- *         runtime: details.apply(details => details[i].runtime),
- *         memorySize: details.apply(details => details[i].memorySize),
- *         timeout: details.apply(details => details[i].timeout),
- *         handler: details.apply(details => details[i].handler),
+ *         runtime: details[i].runtime,
+ *         memorySize: details[i].memorySize,
+ *         timeout: details[i].timeout,
+ *         handler: details[i].handler,
  *     }));
  *     return {
  *         functionInventory: functionInventory,
@@ -157,7 +159,7 @@ export interface GetFunctionsResult {
  * import * as aws from "@pulumi/aws";
  *
  * const all = aws.lambda.getFunctions({});
- * export const functionCount = all.then(all => all.functionNames).length;
+ * export const functionCount = all.then(all => all.functionNames.length);
  * export const allFunctionNames = all.then(all => all.functionNames);
  * ```
  *
@@ -167,32 +169,34 @@ export interface GetFunctionsResult {
  * import * as pulumi from "@pulumi/pulumi";
  * import * as aws from "@pulumi/aws";
  *
- * // Get all Lambda functions
- * const all = aws.lambda.getFunctions({});
- * // Create CloudWatch alarms for all functions
- * const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
- * all.then(all => all.functionNames).length.apply(rangeBody => {
- *     for (let range = 0; range < rangeBody; range++) {
- *         lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
- *             name: all.then(all => `${all.functionNames[range]}-errors`),
- *             comparisonOperator: "GreaterThanThreshold",
- *             evaluationPeriods: 2,
- *             metricName: "Errors",
- *             namespace: "AWS/Lambda",
- *             period: 300,
- *             statistic: "Sum",
- *             threshold: 5,
- *             alarmDescription: "This metric monitors lambda errors",
- *             dimensions: {
- *                 FunctionName: all.then(all => all.functionNames[range]),
- *             },
- *             tags: {
- *                 Environment: "monitoring",
- *                 Purpose: "lambda-error-tracking",
- *             },
- *         }));
- *     }
- * });
+ * export = async () => {
+ *     // Get all Lambda functions
+ *     const all = await aws.lambda.getFunctions({});
+ *     // Create CloudWatch alarms for all functions
+ *     const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
+ * all.functionNames.length.apply(rangeBody => {
+ *         for (let range = 0; range < rangeBody; range++) {
+ *             lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
+ *                 name: `${all.functionNames[range]}-errors`,
+ *                 comparisonOperator: "GreaterThanThreshold",
+ *                 evaluationPeriods: 2,
+ *                 metricName: "Errors",
+ *                 namespace: "AWS/Lambda",
+ *                 period: 300,
+ *                 statistic: "Sum",
+ *                 threshold: 5,
+ *                 alarmDescription: "This metric monitors lambda errors",
+ *                 dimensions: {
+ *                     FunctionName: all.functionNames[range],
+ *                 },
+ *                 tags: {
+ *                     Environment: "monitoring",
+ *                     Purpose: "lambda-error-tracking",
+ *                 },
+ *             }));
+ *         }
+ *     });
+ * }
  * ```
  *
  * ### Filter Functions by Name Pattern
@@ -246,16 +250,16 @@ export interface GetFunctionsResult {
  * export = async () => {
  *     const all = await aws.lambda.getFunctions({});
  *     // Get detailed information for each function
- *     const details = .map(__index => (await aws.lambda.getFunction({
+ *     const details = Array.from({length: all.functionNames.length}, (_, i) => i).apply(range => range.map(__index => (await aws.lambda.getFunction({
  *         functionName: all.functionNames[__index],
- *     })));
+ *     }))));
  *     const functionInventory = .map(([i, name]) => ({
  *         name: name,
  *         arn: all.functionArns[i],
- *         runtime: details.apply(details => details[i].runtime),
- *         memorySize: details.apply(details => details[i].memorySize),
- *         timeout: details.apply(details => details[i].timeout),
- *         handler: details.apply(details => details[i].handler),
+ *         runtime: details[i].runtime,
+ *         memorySize: details[i].memorySize,
+ *         timeout: details[i].timeout,
+ *         handler: details[i].handler,
  *     }));
  *     return {
  *         functionInventory: functionInventory,

package/lambda/getFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFunctions.d.ts","sourceRoot":"","sources":["../../lambda/getFunctions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAM9G;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,sBAAsB,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAMtI;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAC7C"}
+{"version":3,"file":"getFunctions.d.ts","sourceRoot":"","sources":["../../lambda/getFunctions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuHG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAM9G;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC;IACjC;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuHG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,sBAAsB,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAMtI;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CAC7C"}

package/lambda/getFunctions.js

@@ -40,7 +40,7 @@ const utilities = __importStar(require("../utilities"));
  * import * as aws from "@pulumi/aws";
  *
  * const all = aws.lambda.getFunctions({});
- * export const functionCount = all.then(all => all.functionNames).length;
+ * export const functionCount = all.then(all => all.functionNames.length);
  * export const allFunctionNames = all.then(all => all.functionNames);
  * ```
  *
@@ -50,32 +50,34 @@ const utilities = __importStar(require("../utilities"));
  * import * as pulumi from "@pulumi/pulumi";
  * import * as aws from "@pulumi/aws";
  *
- * // Get all Lambda functions
- * const all = aws.lambda.getFunctions({});
- * // Create CloudWatch alarms for all functions
- * const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
- * all.then(all => all.functionNames).length.apply(rangeBody => {
- *     for (let range = 0; range < rangeBody; range++) {
- *         lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
- *             name: all.then(all => `${all.functionNames[range]}-errors`),
- *             comparisonOperator: "GreaterThanThreshold",
- *             evaluationPeriods: 2,
- *             metricName: "Errors",
- *             namespace: "AWS/Lambda",
- *             period: 300,
- *             statistic: "Sum",
- *             threshold: 5,
- *             alarmDescription: "This metric monitors lambda errors",
- *             dimensions: {
- *                 FunctionName: all.then(all => all.functionNames[range]),
- *             },
- *             tags: {
- *                 Environment: "monitoring",
- *                 Purpose: "lambda-error-tracking",
- *             },
- *         }));
- *     }
- * });
+ * export = async () => {
+ *     // Get all Lambda functions
+ *     const all = await aws.lambda.getFunctions({});
+ *     // Create CloudWatch alarms for all functions
+ *     const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
+ * all.functionNames.length.apply(rangeBody => {
+ *         for (let range = 0; range < rangeBody; range++) {
+ *             lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
+ *                 name: `${all.functionNames[range]}-errors`,
+ *                 comparisonOperator: "GreaterThanThreshold",
+ *                 evaluationPeriods: 2,
+ *                 metricName: "Errors",
+ *                 namespace: "AWS/Lambda",
+ *                 period: 300,
+ *                 statistic: "Sum",
+ *                 threshold: 5,
+ *                 alarmDescription: "This metric monitors lambda errors",
+ *                 dimensions: {
+ *                     FunctionName: all.functionNames[range],
+ *                 },
+ *                 tags: {
+ *                     Environment: "monitoring",
+ *                     Purpose: "lambda-error-tracking",
+ *                 },
+ *             }));
+ *         }
+ *     });
+ * }
  * ```
  *
  * ### Filter Functions by Name Pattern
@@ -129,16 +131,16 @@ const utilities = __importStar(require("../utilities"));
  * export = async () => {
  *     const all = await aws.lambda.getFunctions({});
  *     // Get detailed information for each function
- *     const details = .map(__index => (await aws.lambda.getFunction({
+ *     const details = Array.from({length: all.functionNames.length}, (_, i) => i).apply(range => range.map(__index => (await aws.lambda.getFunction({
  *         functionName: all.functionNames[__index],
- *     })));
+ *     }))));
  *     const functionInventory = .map(([i, name]) => ({
  *         name: name,
  *         arn: all.functionArns[i],
- *         runtime: details.apply(details => details[i].runtime),
- *         memorySize: details.apply(details => details[i].memorySize),
- *         timeout: details.apply(details => details[i].timeout),
- *         handler: details.apply(details => details[i].handler),
+ *         runtime: details[i].runtime,
+ *         memorySize: details[i].memorySize,
+ *         timeout: details[i].timeout,
+ *         handler: details[i].handler,
  *     }));
  *     return {
  *         functionInventory: functionInventory,
@@ -166,7 +168,7 @@ exports.getFunctions = getFunctions;
  * import * as aws from "@pulumi/aws";
  *
  * const all = aws.lambda.getFunctions({});
- * export const functionCount = all.then(all => all.functionNames).length;
+ * export const functionCount = all.then(all => all.functionNames.length);
  * export const allFunctionNames = all.then(all => all.functionNames);
  * ```
  *
@@ -176,32 +178,34 @@ exports.getFunctions = getFunctions;
  * import * as pulumi from "@pulumi/pulumi";
  * import * as aws from "@pulumi/aws";
  *
- * // Get all Lambda functions
- * const all = aws.lambda.getFunctions({});
- * // Create CloudWatch alarms for all functions
- * const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
- * all.then(all => all.functionNames).length.apply(rangeBody => {
- *     for (let range = 0; range < rangeBody; range++) {
- *         lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
- *             name: all.then(all => `${all.functionNames[range]}-errors`),
- *             comparisonOperator: "GreaterThanThreshold",
- *             evaluationPeriods: 2,
- *             metricName: "Errors",
- *             namespace: "AWS/Lambda",
- *             period: 300,
- *             statistic: "Sum",
- *             threshold: 5,
- *             alarmDescription: "This metric monitors lambda errors",
- *             dimensions: {
- *                 FunctionName: all.then(all => all.functionNames[range]),
- *             },
- *             tags: {
- *                 Environment: "monitoring",
- *                 Purpose: "lambda-error-tracking",
- *             },
- *         }));
- *     }
- * });
+ * export = async () => {
+ *     // Get all Lambda functions
+ *     const all = await aws.lambda.getFunctions({});
+ *     // Create CloudWatch alarms for all functions
+ *     const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
+ * all.functionNames.length.apply(rangeBody => {
+ *         for (let range = 0; range < rangeBody; range++) {
+ *             lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
+ *                 name: `${all.functionNames[range]}-errors`,
+ *                 comparisonOperator: "GreaterThanThreshold",
+ *                 evaluationPeriods: 2,
+ *                 metricName: "Errors",
+ *                 namespace: "AWS/Lambda",
+ *                 period: 300,
+ *                 statistic: "Sum",
+ *                 threshold: 5,
+ *                 alarmDescription: "This metric monitors lambda errors",
+ *                 dimensions: {
+ *                     FunctionName: all.functionNames[range],
+ *                 },
+ *                 tags: {
+ *                     Environment: "monitoring",
+ *                     Purpose: "lambda-error-tracking",
+ *                 },
+ *             }));
+ *         }
+ *     });
+ * }
  * ```
  *
  * ### Filter Functions by Name Pattern
@@ -255,16 +259,16 @@ exports.getFunctions = getFunctions;
  * export = async () => {
  *     const all = await aws.lambda.getFunctions({});
  *     // Get detailed information for each function
- *     const details = .map(__index => (await aws.lambda.getFunction({
+ *     const details = Array.from({length: all.functionNames.length}, (_, i) => i).apply(range => range.map(__index => (await aws.lambda.getFunction({
  *         functionName: all.functionNames[__index],
- *     })));
+ *     }))));
  *     const functionInventory = .map(([i, name]) => ({
  *         name: name,
  *         arn: all.functionArns[i],
- *         runtime: details.apply(details => details[i].runtime),
- *         memorySize: details.apply(details => details[i].memorySize),
- *         timeout: details.apply(details => details[i].timeout),
- *         handler: details.apply(details => details[i].handler),
+ *         runtime: details[i].runtime,
+ *         memorySize: details[i].memorySize,
+ *         timeout: details[i].timeout,
+ *         handler: details[i].handler,
  *     }));
  *     return {
  *         functionInventory: functionInventory,

package/lambda/getFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"getFunctions.js","sourceRoot":"","sources":["../../lambda/getFunctions.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjF,uDAAyC;AACzC,wDAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AACH,SAAgB,YAAY,CAAC,IAAuB,EAAE,IAA2B;IAC7E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,sCAAsC,EAAE;QACjE,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,oCAMC;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AACH,SAAgB,kBAAkB,CAAC,IAA6B,EAAE,IAAiC;IAC/F,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,sCAAsC,EAAE;QACvE,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gDAMC"}
+{"version":3,"file":"getFunctions.js","sourceRoot":"","sources":["../../lambda/getFunctions.ts"],"names":[],"mappings":";AAAA,sEAAsE;AACtE,iFAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjF,uDAAyC;AACzC,wDAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuHG;AACH,SAAgB,YAAY,CAAC,IAAuB,EAAE,IAA2B;IAC7E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,sCAAsC,EAAE;QACjE,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,oCAMC;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuHG;AACH,SAAgB,kBAAkB,CAAC,IAA6B,EAAE,IAAiC;IAC/F,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,sCAAsC,EAAE;QACvE,QAAQ,EAAE,IAAI,CAAC,MAAM;KACxB,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAND,gDAMC"}

package/lambda/getInvocation.d.ts

@@ -51,11 +51,11 @@ import * as pulumi from "@pulumi/pulumi";
  * })).then(invoke => invoke.result);
  * // Use dynamic configuration
  * const example = new aws.elasticache.Cluster("example", {
- *     clusterId: config?.cache?.clusterId,
- *     engine: config?.cache?.engine,
- *     nodeType: config?.cache?.nodeType,
+ *     clusterId: String(config?.cache?.clusterId),
+ *     engine: String(config?.cache?.engine),
+ *     nodeType: String(config?.cache?.nodeType),
  *     numCacheNodes: Number(config?.cache?.nodes),
- *     parameterGroupName: config?.cache?.parameterGroup,
+ *     parameterGroupName: String(config?.cache?.parameterGroup),
  *     tags: config?.tags,
  * });
  * ```
@@ -158,11 +158,11 @@ export interface GetInvocationResult {
  * })).then(invoke => invoke.result);
  * // Use dynamic configuration
  * const example = new aws.elasticache.Cluster("example", {
- *     clusterId: config?.cache?.clusterId,
- *     engine: config?.cache?.engine,
- *     nodeType: config?.cache?.nodeType,
+ *     clusterId: String(config?.cache?.clusterId),
+ *     engine: String(config?.cache?.engine),
+ *     nodeType: String(config?.cache?.nodeType),
  *     numCacheNodes: Number(config?.cache?.nodes),
- *     parameterGroupName: config?.cache?.parameterGroup,
+ *     parameterGroupName: String(config?.cache?.parameterGroup),
  *     tags: config?.tags,
  * });
  * ```

package/lambda/getInvocation.js

@@ -80,11 +80,11 @@ const utilities = __importStar(require("../utilities"));
  * })).then(invoke => invoke.result);
  * // Use dynamic configuration
  * const example = new aws.elasticache.Cluster("example", {
- *     clusterId: config?.cache?.clusterId,
- *     engine: config?.cache?.engine,
- *     nodeType: config?.cache?.nodeType,
+ *     clusterId: String(config?.cache?.clusterId),
+ *     engine: String(config?.cache?.engine),
+ *     nodeType: String(config?.cache?.nodeType),
  *     numCacheNodes: Number(config?.cache?.nodes),
- *     parameterGroupName: config?.cache?.parameterGroup,
+ *     parameterGroupName: String(config?.cache?.parameterGroup),
  *     tags: config?.tags,
  * });
  * ```
@@ -152,11 +152,11 @@ exports.getInvocation = getInvocation;
  * })).then(invoke => invoke.result);
  * // Use dynamic configuration
  * const example = new aws.elasticache.Cluster("example", {
- *     clusterId: config?.cache?.clusterId,
- *     engine: config?.cache?.engine,
- *     nodeType: config?.cache?.nodeType,
+ *     clusterId: String(config?.cache?.clusterId),
+ *     engine: String(config?.cache?.engine),
+ *     nodeType: String(config?.cache?.nodeType),
  *     numCacheNodes: Number(config?.cache?.nodes),
- *     parameterGroupName: config?.cache?.parameterGroup,
+ *     parameterGroupName: String(config?.cache?.parameterGroup),
  *     tags: config?.tags,
  * });
  * ```