cdk-cost-analyzer 0.1.31 → 0.1.33

package/.cdk-cost-analyzer-cache/metadata.json

@@ -2,35 +2,35 @@
   "entries": {
     "AmazonS3:US East (N. Virginia):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770971189885
+      "timestamp": 1770977254582
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-ReadUnits|productFamily:Amazon DynamoDB PayPerRequest Throughput": {
       "price": 0.023,
-      "timestamp": 1770971189892
+      "timestamp": 1770977254588
     },
     "AmazonDynamoDB:US East (N. Virginia):group:DDB-WriteUnits|productFamily:Amazon DynamoDB PayPerRequest Throughput": {
       "price": 0.023,
-      "timestamp": 1770971189892
+      "timestamp": 1770977254588
     },
     "AmazonEC2:US East (N. Virginia):capacitystatus:Used|instanceType:t3.micro|operatingSystem:Linux|preInstalledSw:NA|tenancy:Shared": {
       "price": 0.023,
-      "timestamp": 1770971189901
+      "timestamp": 1770977254597
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Requests": {
       "price": 0.023,
-      "timestamp": 1770971189906
+      "timestamp": 1770977254605
     },
     "AWSLambda:US East (N. Virginia):group:AWS-Lambda-Duration": {
       "price": 0.023,
-      "timestamp": 1770971189906
+      "timestamp": 1770977254605
     },
     "AmazonS3:EU (Frankfurt):storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770971197326
+      "timestamp": 1770977262339
     },
     "AmazonS3:invalid-region-123:storageClass:General Purpose|volumeType:Standard": {
       "price": 0.023,
-      "timestamp": 1770971197371
+      "timestamp": 1770977262394
     }
   }
 }

package/dist/config/types.d.ts

@@ -62,6 +62,18 @@ export interface UsageAssumptionsConfig {
     vpcEndpoint?: {
         dataProcessedGB?: number;
     };
+    /**
+     * EFS (Elastic File System) usage assumptions for cost estimation.
+     * These values are used to estimate monthly costs for EFS file systems.
+     *
+     * @see https://aws.amazon.com/efs/pricing/
+     */
+    efs?: {
+        /** Total storage size in GB (default: 100) */
+        storageSizeGb?: number;
+        /** Percentage of storage in Infrequent Access class (default: 0, range: 0-100) */
+        infrequentAccessPercentage?: number;
+    };
     /**
      * SNS (Simple Notification Service) usage assumptions.
      * These values are used to estimate monthly costs for SNS topics.
@@ -80,6 +92,16 @@ export interface UsageAssumptionsConfig {
         /** Number of mobile push deliveries per month (default: 0) */
         mobilePushDeliveries?: number;
     };
+    /**
+     * SQS usage assumptions for cost estimation.
+     * Applies to both Standard and FIFO queues.
+     *
+     * @see https://aws.amazon.com/sqs/pricing/
+     */
+    sqs?: {
+        /** Number of requests per month (default: 1,000,000) */
+        monthlyRequests?: number;
+    };
     /**
      * Step Functions usage assumptions for cost estimation.
      *
@@ -96,6 +118,15 @@ export interface UsageAssumptionsConfig {
         /** Average execution duration in milliseconds (default: 1000, for Express workflows) */
         averageDurationMs?: number;
     };
+    /**
+     * Secrets Manager usage assumptions for cost estimation.
+     *
+     * @see https://aws.amazon.com/secrets-manager/pricing/
+     */
+    secretsManager?: {
+        /** Number of API calls per month (default: 10,000) */
+        monthlyApiCalls?: number;
+    };
 }
 export interface SynthesisConfig {
     appPath?: string;

package/dist/config/types.js

@@ -12,4 +12,4 @@ class ConfigurationError extends Error {
     }
 }
 exports.ConfigurationError = ConfigurationError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQTRKQSxNQUFhLGtCQUFtQixTQUFRLEtBQUs7SUFHbEM7SUFDQTtJQUhULFlBQ0UsT0FBZSxFQUNSLFVBQWtCLEVBQ2xCLGdCQUEwQjtRQUVqQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFIUixlQUFVLEdBQVYsVUFBVSxDQUFRO1FBQ2xCLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBVTtRQUdqQyxJQUFJLENBQUMsSUFBSSxHQUFHLG9CQUFvQixDQUFDO0lBQ25DLENBQUM7Q0FDRjtBQVRELGdEQVNDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBDb3N0QW5hbHl6ZXJDb25maWcge1xuICB0aHJlc2hvbGRzPzogVGhyZXNob2xkQ29uZmlnO1xuICB1c2FnZUFzc3VtcHRpb25zPzogVXNhZ2VBc3N1bXB0aW9uc0NvbmZpZztcbiAgc3ludGhlc2lzPzogU3ludGhlc2lzQ29uZmlnO1xuICBleGNsdXNpb25zPzogRXhjbHVzaW9uc0NvbmZpZztcbiAgY2FjaGU/OiBDYWNoZUNvbmZpZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBUaHJlc2hvbGRDb25maWcge1xuICBkZWZhdWx0PzogVGhyZXNob2xkTGV2ZWxzO1xuICBlbnZpcm9ubWVudHM/OiBSZWNvcmQ8c3RyaW5nLCBUaHJlc2hvbGRMZXZlbHM+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRocmVzaG9sZExldmVscyB7XG4gIHdhcm5pbmc/OiBudW1iZXI7XG4gIGVycm9yPzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVzYWdlQXNzdW1wdGlvbnNDb25maWcge1xuICBzMz86IHtcbiAgICBzdG9yYWdlR0I/OiBudW1iZXI7XG4gICAgZ2V0UmVxdWVzdHM/OiBudW1iZXI7XG4gICAgcHV0UmVxdWVzdHM/OiBudW1iZXI7XG4gIH07XG4gIGxhbWJkYT86IHtcbiAgICBpbnZvY2F0aW9uc1Blck1vbnRoPzogbnVtYmVyO1xuICAgIGF2ZXJhZ2VEdXJhdGlvbk1zPzogbnVtYmVyO1xuICB9O1xuICAvKipcbiAgICogRHluYW1vREIgdXNhZ2UgYXNzdW1wdGlvbnMgZm9yIG9uLWRlbWFuZCAocGF5LXBlci1yZXF1ZXN0KSBiaWxsaW5nIG1vZGUuXG4gICAqIFRoZXNlIHZhbHVlcyBhcmUgdXNlZCB0byBlc3RpbWF0ZSBtb250aGx5IGNvc3RzIGZvciBEeW5hbW9EQiB0YWJsZXNcbiAgICogY29uZmlndXJlZCB3aXRoIEJpbGxpbmdNb2RlOiBQQVlfUEVSX1JFUVVFU1QuXG4gICAqXG4gICAqIEZvciBwcm92aXNpb25lZCBiaWxsaW5nIG1vZGUsIGNvc3RzIGFyZSBjYWxjdWxhdGVkIGJhc2VkIG9uIHRoZVxuICAgKiBSZWFkQ2FwYWNpdHlVbml0cyBhbmQgV3JpdGVDYXBhY2l0eVVuaXRzIHNwZWNpZmllZCBpbiB0aGUgdGVtcGxhdGUuXG4gICAqXG4gICAqIEBzZWUgaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9keW5hbW9kYi9wcmljaW5nL1xuICAgKi9cbiAgZHluYW1vZGI/OiB7XG4gICAgLyoqIE51bWJlciBvZiByZWFkIHJlcXVlc3RzIHBlciBtb250aCAoZGVmYXVsdDogMTAsMDAwLDAwMCkgKi9cbiAgICByZWFkUmVxdWVzdHNQZXJNb250aD86IG51bWJlcjtcbiAgICAvKiogTnVtYmVyIG9mIHdyaXRlIHJlcXVlc3RzIHBlciBtb250aCAoZGVmYXVsdDogMSwwMDAsMDAwKSAqL1xuICAgIHdyaXRlUmVxdWVzdHNQZXJNb250aD86IG51bWJlcjtcbiAgfTtcbiAgbmF0R2F0ZXdheT86IHtcbiAgICBkYXRhUHJvY2Vzc2VkR0I/OiBudW1iZXI7XG4gIH07XG4gIGFsYj86IHtcbiAgICBuZXdDb25uZWN0aW9uc1BlclNlY29uZD86IG51bWJlcjtcbiAgICBhY3RpdmVDb25uZWN0aW9uc1Blck1pbnV0ZT86IG51bWJlcjtcbiAgICBwcm9jZXNzZWRCeXRlc0dCPzogbnVtYmVyO1xuICB9O1xuICBubGI/OiB7XG4gICAgbmV3Q29ubmVjdGlvbnNQZXJTZWNvbmQ/OiBudW1iZXI7XG4gICAgYWN0aXZlQ29ubmVjdGlvbnNQZXJNaW51dGU/OiBudW1iZXI7XG4gICAgcHJvY2Vzc2VkQnl0ZXNHQj86IG51bWJlcjtcbiAgfTtcbiAgY2xvdWRmcm9udD86IHtcbiAgICBkYXRhVHJhbnNmZXJHQj86IG51bWJlcjtcbiAgICByZXF1ZXN0cz86IG51bWJlcjtcbiAgfTtcbiAgYXBpR2F0ZXdheT86IHtcbiAgICByZXF1ZXN0c1Blck1vbnRoPzogbnVtYmVyO1xuICB9O1xuICB2cGNFbmRwb2ludD86IHtcbiAgICBkYXRhUHJvY2Vzc2VkR0I/OiBudW1iZXI7XG4gIH07XG4gIC8qKlxuICAgKiBFRlMgKEVsYXN0aWMgRmlsZSBTeXN0ZW0pIHVzYWdlIGFzc3VtcHRpb25zIGZvciBjb3N0IGVzdGltYXRpb24uXG4gICAqIFRoZXNlIHZhbHVlcyBhcmUgdXNlZCB0byBlc3RpbWF0ZSBtb250aGx5IGNvc3RzIGZvciBFRlMgZmlsZSBzeXN0ZW1zLlxuICAgKlxuICAgKiBAc2VlIGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vZWZzL3ByaWNpbmcvXG4gICAqL1xuICBlZnM/OiB7XG4gICAgLyoqIFRvdGFsIHN0b3JhZ2Ugc2l6ZSBpbiBHQiAoZGVmYXVsdDogMTAwKSAqL1xuICAgIHN0b3JhZ2VTaXplR2I/OiBudW1iZXI7XG4gICAgLyoqIFBlcmNlbnRhZ2Ugb2Ygc3RvcmFnZSBpbiBJbmZyZXF1ZW50IEFjY2VzcyBjbGFzcyAoZGVmYXVsdDogMCwgcmFuZ2U6IDAtMTAwKSAqL1xuICAgIGluZnJlcXVlbnRBY2Nlc3NQZXJjZW50YWdlPzogbnVtYmVyO1xuICB9O1xuICAvKipcbiAgICogU05TIChTaW1wbGUgTm90aWZpY2F0aW9uIFNlcnZpY2UpIHVzYWdlIGFzc3VtcHRpb25zLlxuICAgKiBUaGVzZSB2YWx1ZXMgYXJlIHVzZWQgdG8gZXN0aW1hdGUgbW9udGhseSBjb3N0cyBmb3IgU05TIHRvcGljcy5cbiAgICpcbiAgICogQHNlZSBodHRwczovL2F3cy5hbWF6b24uY29tL3Nucy9wcmljaW5nL1xuICAgKi9cbiAgc25zPzoge1xuICAgIC8qKiBOdW1iZXIgb2YgcHVibGlzaCByZXF1ZXN0cyBwZXIgbW9udGggKGRlZmF1bHQ6IDEsMDAwLDAwMCkgKi9cbiAgICBtb250aGx5UHVibGlzaGVzPzogbnVtYmVyO1xuICAgIC8qKiBOdW1iZXIgb2YgSFRUUC9TIGRlbGl2ZXJpZXMgcGVyIG1vbnRoIChkZWZhdWx0OiAxLDAwMCwwMDApICovXG4gICAgaHR0cERlbGl2ZXJpZXM/OiBudW1iZXI7XG4gICAgLyoqIE51bWJlciBvZiBlbWFpbCBkZWxpdmVyaWVzIHBlciBtb250aCAoZGVmYXVsdDogMCkgKi9cbiAgICBlbWFpbERlbGl2ZXJpZXM/OiBudW1iZXI7XG4gICAgLyoqIE51bWJlciBvZiBTTVMgZGVsaXZlcmllcyBwZXIgbW9udGggKGRlZmF1bHQ6IDApICovXG4gICAgc21zRGVsaXZlcmllcz86IG51bWJlcjtcbiAgICAvKiogTnVtYmVyIG9mIG1vYmlsZSBwdXNoIGRlbGl2ZXJpZXMgcGVyIG1vbnRoIChkZWZhdWx0OiAwKSAqL1xuICAgIG1vYmlsZVB1c2hEZWxpdmVyaWVzPzogbnVtYmVyO1xuICB9O1xuICAvKipcbiAgICogU1FTIHVzYWdlIGFzc3VtcHRpb25zIGZvciBjb3N0IGVzdGltYXRpb24uXG4gICAqIEFwcGxpZXMgdG8gYm90aCBTdGFuZGFyZCBhbmQgRklGTyBxdWV1ZXMuXG4gICAqXG4gICAqIEBzZWUgaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9zcXMvcHJpY2luZy9cbiAgICovXG4gIHNxcz86IHtcbiAgICAvKiogTnVtYmVyIG9mIHJlcXVlc3RzIHBlciBtb250aCAoZGVmYXVsdDogMSwwMDAsMDAwKSAqL1xuICAgIG1vbnRobHlSZXF1ZXN0cz86IG51bWJlcjtcbiAgfTtcbiAgLyoqXG4gICAqIFN0ZXAgRnVuY3Rpb25zIHVzYWdlIGFzc3VtcHRpb25zIGZvciBjb3N0IGVzdGltYXRpb24uXG4gICAqXG4gICAqIFN0YW5kYXJkIHdvcmtmbG93cyBhcmUgY2hhcmdlZCBwZXIgc3RhdGUgdHJhbnNpdGlvbi5cbiAgICogRXhwcmVzcyB3b3JrZmxvd3MgYXJlIGNoYXJnZWQgcGVyIHJlcXVlc3QgYW5kIHBlciBHQi1zZWNvbmQgb2YgZHVyYXRpb24uXG4gICAqXG4gICAqIEBzZWUgaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9zdGVwLWZ1bmN0aW9ucy9wcmljaW5nL1xuICAgKi9cbiAgc3RlcEZ1bmN0aW9ucz86IHtcbiAgICAvKiogTnVtYmVyIG9mIHdvcmtmbG93IGV4ZWN1dGlvbnMgcGVyIG1vbnRoIChkZWZhdWx0OiAxMCwwMDApICovXG4gICAgbW9udGhseUV4ZWN1dGlvbnM/OiBudW1iZXI7XG4gICAgLyoqIE51bWJlciBvZiBzdGF0ZSB0cmFuc2l0aW9ucyBwZXIgZXhlY3V0aW9uIChkZWZhdWx0OiAxMCwgZm9yIFN0YW5kYXJkIHdvcmtmbG93cykgKi9cbiAgICBzdGF0ZVRyYW5zaXRpb25zUGVyRXhlY3V0aW9uPzogbnVtYmVyO1xuICAgIC8qKiBBdmVyYWdlIGV4ZWN1dGlvbiBkdXJhdGlvbiBpbiBtaWxsaXNlY29uZHMgKGRlZmF1bHQ6IDEwMDAsIGZvciBFeHByZXNzIHdvcmtmbG93cykgKi9cbiAgICBhdmVyYWdlRHVyYXRpb25Ncz86IG51bWJlcjtcbiAgfTtcbiAgLyoqXG4gICAqIFNlY3JldHMgTWFuYWdlciB1c2FnZSBhc3N1bXB0aW9ucyBmb3IgY29zdCBlc3RpbWF0aW9uLlxuICAgKlxuICAgKiBAc2VlIGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vc2VjcmV0cy1tYW5hZ2VyL3ByaWNpbmcvXG4gICAqL1xuICBzZWNyZXRzTWFuYWdlcj86IHtcbiAgICAvKiogTnVtYmVyIG9mIEFQSSBjYWxscyBwZXIgbW9udGggKGRlZmF1bHQ6IDEwLDAwMCkgKi9cbiAgICBtb250aGx5QXBpQ2FsbHM/OiBudW1iZXI7XG4gIH07XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3ludGhlc2lzQ29uZmlnIHtcbiAgYXBwUGF0aD86IHN0cmluZztcbiAgb3V0cHV0UGF0aD86IHN0cmluZztcbiAgY3VzdG9tQ29tbWFuZD86IHN0cmluZztcbiAgY29udGV4dD86IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRXhjbHVzaW9uc0NvbmZpZyB7XG4gIHJlc291cmNlVHlwZXM/OiBzdHJpbmdbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDYWNoZUNvbmZpZyB7XG4gIGVuYWJsZWQ/OiBib29sZWFuO1xuICBkdXJhdGlvbkhvdXJzPzogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFZhbGlkYXRpb25SZXN1bHQge1xuICB2YWxpZDogYm9vbGVhbjtcbiAgZXJyb3JzOiBzdHJpbmdbXTtcbiAgd2FybmluZ3M6IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgY2xhc3MgQ29uZmlndXJhdGlvbkVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihcbiAgICBtZXNzYWdlOiBzdHJpbmcsXG4gICAgcHVibGljIGNvbmZpZ1BhdGg6IHN0cmluZyxcbiAgICBwdWJsaWMgdmFsaWRhdGlvbkVycm9yczogc3RyaW5nW10sXG4gICkge1xuICAgIHN1cGVyKG1lc3NhZ2UpO1xuICAgIHRoaXMubmFtZSA9ICdDb25maWd1cmF0aW9uRXJyb3InO1xuICB9XG59XG4iXX0=

package/dist/pricing/PricingService.js

@@ -9,6 +9,7 @@ const CloudFrontCalculator_1 = require("./calculators/CloudFrontCalculator");
 const DynamoDBCalculator_1 = require("./calculators/DynamoDBCalculator");
 const EC2Calculator_1 = require("./calculators/EC2Calculator");
 const ECSCalculator_1 = require("./calculators/ECSCalculator");
+const EFSCalculator_1 = require("./calculators/EFSCalculator");
 const ElastiCacheCalculator_1 = require("./calculators/ElastiCacheCalculator");
 const LambdaCalculator_1 = require("./calculators/LambdaCalculator");
 const LaunchTemplateCalculator_1 = require("./calculators/LaunchTemplateCalculator");
@@ -16,7 +17,9 @@ const NatGatewayCalculator_1 = require("./calculators/NatGatewayCalculator");
 const NLBCalculator_1 = require("./calculators/NLBCalculator");
 const RDSCalculator_1 = require("./calculators/RDSCalculator");
 const S3Calculator_1 = require("./calculators/S3Calculator");
+const SecretsManagerCalculator_1 = require("./calculators/SecretsManagerCalculator");
 const SNSCalculator_1 = require("./calculators/SNSCalculator");
+const SQSCalculator_1 = require("./calculators/SQSCalculator");
 const StepFunctionsCalculator_1 = require("./calculators/StepFunctionsCalculator");
 const VPCEndpointCalculator_1 = require("./calculators/VPCEndpointCalculator");
 const PricingClient_1 = require("./PricingClient");
@@ -57,8 +60,11 @@ class PricingService {
             new ElastiCacheCalculator_1.ElastiCacheCalculator(),
             new AutoScalingGroupCalculator_1.AutoScalingGroupCalculator(),
             new LaunchTemplateCalculator_1.LaunchTemplateCalculator(),
+            new EFSCalculator_1.EFSCalculator(usageAssumptions?.efs?.storageSizeGb, usageAssumptions?.efs?.infrequentAccessPercentage),
             new SNSCalculator_1.SNSCalculator(usageAssumptions?.sns?.monthlyPublishes, usageAssumptions?.sns?.httpDeliveries, usageAssumptions?.sns?.emailDeliveries, usageAssumptions?.sns?.smsDeliveries, usageAssumptions?.sns?.mobilePushDeliveries),
+            new SQSCalculator_1.SQSCalculator(config),
             new StepFunctionsCalculator_1.StepFunctionsCalculator(usageAssumptions?.stepFunctions?.monthlyExecutions, usageAssumptions?.stepFunctions?.stateTransitionsPerExecution, usageAssumptions?.stepFunctions?.averageDurationMs),
+            new SecretsManagerCalculator_1.SecretsManagerCalculator(usageAssumptions?.secretsManager?.monthlyApiCalls),
         ];
     }
     async getResourceCost(resource, region, templateResources) {
@@ -172,4 +178,4 @@ class PricingService {
     }
 }
 exports.PricingService = PricingService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PricingService.js","sourceRoot":"","sources":["../../src/pricing/PricingService.ts"],"names":[],"mappings":"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","sourcesContent":["import { CacheManager } from './CacheManager';\nimport { ALBCalculator } from './calculators/ALBCalculator';\nimport { APIGatewayCalculator } from './calculators/APIGatewayCalculator';\nimport { AutoScalingGroupCalculator } from './calculators/AutoScalingGroupCalculator';\nimport { CloudFrontCalculator } from './calculators/CloudFrontCalculator';\nimport { DynamoDBCalculator } from './calculators/DynamoDBCalculator';\nimport { EC2Calculator } from './calculators/EC2Calculator';\nimport { ECSCalculator } from './calculators/ECSCalculator';\nimport { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';\nimport { LambdaCalculator } from './calculators/LambdaCalculator';\nimport { LaunchTemplateCalculator } from './calculators/LaunchTemplateCalculator';\nimport { NatGatewayCalculator } from './calculators/NatGatewayCalculator';\nimport { NLBCalculator } from './calculators/NLBCalculator';\nimport { RDSCalculator } from './calculators/RDSCalculator';\nimport { S3Calculator } from './calculators/S3Calculator';\nimport { SNSCalculator } from './calculators/SNSCalculator';\nimport { StepFunctionsCalculator } from './calculators/StepFunctionsCalculator';\nimport { VPCEndpointCalculator } from './calculators/VPCEndpointCalculator';\nimport { PricingClient } from './PricingClient';\nimport {\n  PricingService as IPricingService,\n  MonthlyCost,\n  CostDelta,\n  ResourceCostCalculator,\n} from './types';\nimport { UsageAssumptionsConfig, CacheConfig, CostAnalyzerConfig } from '../config/types';\nimport { ResourceWithId, ResourceDiff } from '../diff/types';\n\nexport class PricingService implements IPricingService {\n  private calculators: ResourceCostCalculator[];\n  private pricingClient: PricingClient;\n  private excludedResourceTypes: Set<string>;\n\n  constructor(\n    region: string = 'us-east-1',\n    usageAssumptions?: UsageAssumptionsConfig,\n    excludedResourceTypes?: string[],\n    cacheConfig?: CacheConfig,\n    pricingClient?: PricingClient,\n  ) {\n    // Use provided pricing client or create a new one\n    if (pricingClient) {\n      this.pricingClient = pricingClient;\n    } else {\n      // Initialize cache manager if caching is enabled\n      let cacheManager: CacheManager | undefined;\n      if (cacheConfig?.enabled !== false) {\n        const cacheDuration = cacheConfig?.durationHours ?? 24;\n        cacheManager = new CacheManager('.cdk-cost-analyzer-cache', cacheDuration);\n      }\n\n      this.pricingClient = new PricingClient(region, cacheManager);\n    }\n    this.excludedResourceTypes = new Set(excludedResourceTypes || []);\n    \n    // Build config object for calculators that need it\n    const config: CostAnalyzerConfig | undefined = usageAssumptions ? { usageAssumptions } : undefined;\n    \n    this.calculators = [\n      new EC2Calculator(),\n      new S3Calculator(),\n      new LambdaCalculator(\n        usageAssumptions?.lambda?.invocationsPerMonth,\n        usageAssumptions?.lambda?.averageDurationMs,\n      ),\n      new RDSCalculator(),\n      new DynamoDBCalculator(config),\n      new ECSCalculator(),\n      new APIGatewayCalculator(),\n      new NatGatewayCalculator(usageAssumptions?.natGateway?.dataProcessedGB),\n      new ALBCalculator(\n        usageAssumptions?.alb?.newConnectionsPerSecond,\n        usageAssumptions?.alb?.activeConnectionsPerMinute,\n        usageAssumptions?.alb?.processedBytesGB,\n      ),\n      new NLBCalculator(\n        usageAssumptions?.nlb?.newConnectionsPerSecond,\n        usageAssumptions?.nlb?.activeConnectionsPerMinute,\n        usageAssumptions?.nlb?.processedBytesGB,\n      ),\n      new VPCEndpointCalculator(usageAssumptions?.vpcEndpoint?.dataProcessedGB),\n      new CloudFrontCalculator(\n        usageAssumptions?.cloudfront?.dataTransferGB,\n        usageAssumptions?.cloudfront?.requests,\n      ),\n      new ElastiCacheCalculator(),\n      new AutoScalingGroupCalculator(),\n      new LaunchTemplateCalculator(),\n      new SNSCalculator(\n        usageAssumptions?.sns?.monthlyPublishes,\n        usageAssumptions?.sns?.httpDeliveries,\n        usageAssumptions?.sns?.emailDeliveries,\n        usageAssumptions?.sns?.smsDeliveries,\n        usageAssumptions?.sns?.mobilePushDeliveries,\n      ),\n      new StepFunctionsCalculator(\n        usageAssumptions?.stepFunctions?.monthlyExecutions,\n        usageAssumptions?.stepFunctions?.stateTransitionsPerExecution,\n        usageAssumptions?.stepFunctions?.averageDurationMs,\n      ),\n    ];\n  }\n\n  async getResourceCost(resource: ResourceWithId, region: string, templateResources?: ResourceWithId[]): Promise<MonthlyCost> {\n    // Check if resource type is excluded\n    if (this.excludedResourceTypes.has(resource.type)) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: [`Resource type ${resource.type} is excluded from cost analysis`],\n      };\n    }\n\n    // Find calculator using canCalculate if available, otherwise fall back to supports\n    const calculator = this.calculators.find(calc => {\n      if (calc.canCalculate) {\n        return calc.canCalculate(resource);\n      }\n      return calc.supports(resource.type);\n    });\n\n    if (!calculator) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Resource type ${resource.type} is not supported`],\n      };\n    }\n\n    try {\n      return await calculator.calculateCost(resource, region, this.pricingClient, templateResources);\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to calculate cost: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  async getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta> {\n    // Filter out excluded resources before processing\n    const filteredAdded = diff.added.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredRemoved = diff.removed.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredModified = diff.modified.filter(r => !this.excludedResourceTypes.has(r.type));\n\n    // Build template resource context from all resources in the diff\n    const allResources: ResourceWithId[] = [\n      ...diff.added,\n      ...diff.removed,\n      ...diff.modified.map(r => ({\n        logicalId: r.logicalId,\n        type: r.type,\n        properties: r.newProperties,\n      })),\n    ];\n\n    const addedCosts = await Promise.all(\n      filteredAdded.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const removedCosts = await Promise.all(\n      filteredRemoved.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const modifiedCosts = await Promise.all(\n      filteredModified.map(async (resource) => {\n        const oldResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.oldProperties,\n        };\n        const newResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.newProperties,\n        };\n\n        const oldMonthlyCost = await this.getResourceCost(oldResource, region, allResources);\n        const newMonthlyCost = await this.getResourceCost(newResource, region, allResources);\n        const costDelta = newMonthlyCost.amount - oldMonthlyCost.amount;\n\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost: newMonthlyCost,\n          oldMonthlyCost,\n          newMonthlyCost,\n          costDelta,\n        };\n      }),\n    );\n\n    const totalAddedCost = addedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalRemovedCost = removedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalModifiedDelta = modifiedCosts.reduce((sum, r) => sum + r.costDelta, 0);\n\n    const totalDelta = totalAddedCost - totalRemovedCost + totalModifiedDelta;\n\n    return {\n      totalDelta,\n      currency: 'USD',\n      addedCosts,\n      removedCosts,\n      modifiedCosts,\n    };\n  }\n\n  /**\n   * Clean up resources and connections\n   */\n  destroy(): void {\n    this.pricingClient.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PricingService.js","sourceRoot":"","sources":["../../src/pricing/PricingService.ts"],"names":[],"mappings":"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","sourcesContent":["import { CacheManager } from './CacheManager';\nimport { ALBCalculator } from './calculators/ALBCalculator';\nimport { APIGatewayCalculator } from './calculators/APIGatewayCalculator';\nimport { AutoScalingGroupCalculator } from './calculators/AutoScalingGroupCalculator';\nimport { CloudFrontCalculator } from './calculators/CloudFrontCalculator';\nimport { DynamoDBCalculator } from './calculators/DynamoDBCalculator';\nimport { EC2Calculator } from './calculators/EC2Calculator';\nimport { ECSCalculator } from './calculators/ECSCalculator';\nimport { EFSCalculator } from './calculators/EFSCalculator';\nimport { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';\nimport { LambdaCalculator } from './calculators/LambdaCalculator';\nimport { LaunchTemplateCalculator } from './calculators/LaunchTemplateCalculator';\nimport { NatGatewayCalculator } from './calculators/NatGatewayCalculator';\nimport { NLBCalculator } from './calculators/NLBCalculator';\nimport { RDSCalculator } from './calculators/RDSCalculator';\nimport { S3Calculator } from './calculators/S3Calculator';\nimport { SecretsManagerCalculator } from './calculators/SecretsManagerCalculator';\nimport { SNSCalculator } from './calculators/SNSCalculator';\nimport { SQSCalculator } from './calculators/SQSCalculator';\nimport { StepFunctionsCalculator } from './calculators/StepFunctionsCalculator';\nimport { VPCEndpointCalculator } from './calculators/VPCEndpointCalculator';\nimport { PricingClient } from './PricingClient';\nimport {\n  PricingService as IPricingService,\n  MonthlyCost,\n  CostDelta,\n  ResourceCostCalculator,\n} from './types';\nimport { UsageAssumptionsConfig, CacheConfig, CostAnalyzerConfig } from '../config/types';\nimport { ResourceWithId, ResourceDiff } from '../diff/types';\n\nexport class PricingService implements IPricingService {\n  private calculators: ResourceCostCalculator[];\n  private pricingClient: PricingClient;\n  private excludedResourceTypes: Set<string>;\n\n  constructor(\n    region: string = 'us-east-1',\n    usageAssumptions?: UsageAssumptionsConfig,\n    excludedResourceTypes?: string[],\n    cacheConfig?: CacheConfig,\n    pricingClient?: PricingClient,\n  ) {\n    // Use provided pricing client or create a new one\n    if (pricingClient) {\n      this.pricingClient = pricingClient;\n    } else {\n      // Initialize cache manager if caching is enabled\n      let cacheManager: CacheManager | undefined;\n      if (cacheConfig?.enabled !== false) {\n        const cacheDuration = cacheConfig?.durationHours ?? 24;\n        cacheManager = new CacheManager('.cdk-cost-analyzer-cache', cacheDuration);\n      }\n\n      this.pricingClient = new PricingClient(region, cacheManager);\n    }\n    this.excludedResourceTypes = new Set(excludedResourceTypes || []);\n    \n    // Build config object for calculators that need it\n    const config: CostAnalyzerConfig | undefined = usageAssumptions ? { usageAssumptions } : undefined;\n    \n    this.calculators = [\n      new EC2Calculator(),\n      new S3Calculator(),\n      new LambdaCalculator(\n        usageAssumptions?.lambda?.invocationsPerMonth,\n        usageAssumptions?.lambda?.averageDurationMs,\n      ),\n      new RDSCalculator(),\n      new DynamoDBCalculator(config),\n      new ECSCalculator(),\n      new APIGatewayCalculator(),\n      new NatGatewayCalculator(usageAssumptions?.natGateway?.dataProcessedGB),\n      new ALBCalculator(\n        usageAssumptions?.alb?.newConnectionsPerSecond,\n        usageAssumptions?.alb?.activeConnectionsPerMinute,\n        usageAssumptions?.alb?.processedBytesGB,\n      ),\n      new NLBCalculator(\n        usageAssumptions?.nlb?.newConnectionsPerSecond,\n        usageAssumptions?.nlb?.activeConnectionsPerMinute,\n        usageAssumptions?.nlb?.processedBytesGB,\n      ),\n      new VPCEndpointCalculator(usageAssumptions?.vpcEndpoint?.dataProcessedGB),\n      new CloudFrontCalculator(\n        usageAssumptions?.cloudfront?.dataTransferGB,\n        usageAssumptions?.cloudfront?.requests,\n      ),\n      new ElastiCacheCalculator(),\n      new AutoScalingGroupCalculator(),\n      new LaunchTemplateCalculator(),\n      new EFSCalculator(\n        usageAssumptions?.efs?.storageSizeGb,\n        usageAssumptions?.efs?.infrequentAccessPercentage,\n      ),\n      new SNSCalculator(\n        usageAssumptions?.sns?.monthlyPublishes,\n        usageAssumptions?.sns?.httpDeliveries,\n        usageAssumptions?.sns?.emailDeliveries,\n        usageAssumptions?.sns?.smsDeliveries,\n        usageAssumptions?.sns?.mobilePushDeliveries,\n      ),\n      new SQSCalculator(config),\n      new StepFunctionsCalculator(\n        usageAssumptions?.stepFunctions?.monthlyExecutions,\n        usageAssumptions?.stepFunctions?.stateTransitionsPerExecution,\n        usageAssumptions?.stepFunctions?.averageDurationMs,\n      ),\n      new SecretsManagerCalculator(\n        usageAssumptions?.secretsManager?.monthlyApiCalls,\n      ),\n    ];\n  }\n\n  async getResourceCost(resource: ResourceWithId, region: string, templateResources?: ResourceWithId[]): Promise<MonthlyCost> {\n    // Check if resource type is excluded\n    if (this.excludedResourceTypes.has(resource.type)) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'high',\n        assumptions: [`Resource type ${resource.type} is excluded from cost analysis`],\n      };\n    }\n\n    // Find calculator using canCalculate if available, otherwise fall back to supports\n    const calculator = this.calculators.find(calc => {\n      if (calc.canCalculate) {\n        return calc.canCalculate(resource);\n      }\n      return calc.supports(resource.type);\n    });\n\n    if (!calculator) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Resource type ${resource.type} is not supported`],\n      };\n    }\n\n    try {\n      return await calculator.calculateCost(resource, region, this.pricingClient, templateResources);\n    } catch (error) {\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to calculate cost: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n\n  async getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta> {\n    // Filter out excluded resources before processing\n    const filteredAdded = diff.added.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredRemoved = diff.removed.filter(r => !this.excludedResourceTypes.has(r.type));\n    const filteredModified = diff.modified.filter(r => !this.excludedResourceTypes.has(r.type));\n\n    // Build template resource context from all resources in the diff\n    const allResources: ResourceWithId[] = [\n      ...diff.added,\n      ...diff.removed,\n      ...diff.modified.map(r => ({\n        logicalId: r.logicalId,\n        type: r.type,\n        properties: r.newProperties,\n      })),\n    ];\n\n    const addedCosts = await Promise.all(\n      filteredAdded.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const removedCosts = await Promise.all(\n      filteredRemoved.map(async (resource) => {\n        const monthlyCost = await this.getResourceCost(resource, region, allResources);\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost,\n        };\n      }),\n    );\n\n    const modifiedCosts = await Promise.all(\n      filteredModified.map(async (resource) => {\n        const oldResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.oldProperties,\n        };\n        const newResource: ResourceWithId = {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          properties: resource.newProperties,\n        };\n\n        const oldMonthlyCost = await this.getResourceCost(oldResource, region, allResources);\n        const newMonthlyCost = await this.getResourceCost(newResource, region, allResources);\n        const costDelta = newMonthlyCost.amount - oldMonthlyCost.amount;\n\n        return {\n          logicalId: resource.logicalId,\n          type: resource.type,\n          monthlyCost: newMonthlyCost,\n          oldMonthlyCost,\n          newMonthlyCost,\n          costDelta,\n        };\n      }),\n    );\n\n    const totalAddedCost = addedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalRemovedCost = removedCosts.reduce((sum, r) => sum + r.monthlyCost.amount, 0);\n    const totalModifiedDelta = modifiedCosts.reduce((sum, r) => sum + r.costDelta, 0);\n\n    const totalDelta = totalAddedCost - totalRemovedCost + totalModifiedDelta;\n\n    return {\n      totalDelta,\n      currency: 'USD',\n      addedCosts,\n      removedCosts,\n      modifiedCosts,\n    };\n  }\n\n  /**\n   * Clean up resources and connections\n   */\n  destroy(): void {\n    this.pricingClient.destroy();\n  }\n}\n"]}

package/dist/pricing/calculators/EFSCalculator.d.ts

@@ -0,0 +1,19 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export interface EFSUsageAssumptions {
+    storageSizeGb?: number;
+    infrequentAccessPercentage?: number;
+}
+export declare class EFSCalculator implements ResourceCostCalculator {
+    private readonly customStorageSizeGb?;
+    private readonly customInfrequentAccessPercentage?;
+    private readonly DEFAULT_STORAGE_SIZE_GB;
+    private readonly DEFAULT_IA_PERCENTAGE;
+    private readonly FALLBACK_STANDARD_PRICE;
+    private readonly FALLBACK_IA_STORAGE_PRICE;
+    private readonly FALLBACK_IA_REQUEST_PRICE;
+    private readonly FALLBACK_PROVISIONED_THROUGHPUT_PRICE;
+    constructor(customStorageSizeGb?: number | undefined, customInfrequentAccessPercentage?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/pricing/calculators/EFSCalculator.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EFSCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+const Logger_1 = require("../../utils/Logger");
+class EFSCalculator {
+    customStorageSizeGb;
+    customInfrequentAccessPercentage;
+    DEFAULT_STORAGE_SIZE_GB = 100;
+    DEFAULT_IA_PERCENTAGE = 0;
+    // Fallback pricing rates (AWS EFS us-east-1 pricing as of 2024)
+    FALLBACK_STANDARD_PRICE = 0.30; // Per GB-month
+    FALLBACK_IA_STORAGE_PRICE = 0.016; // Per GB-month
+    FALLBACK_IA_REQUEST_PRICE = 0.01; // Per GB transferred
+    FALLBACK_PROVISIONED_THROUGHPUT_PRICE = 6.00; // Per MB/s-month
+    constructor(customStorageSizeGb, customInfrequentAccessPercentage) {
+        this.customStorageSizeGb = customStorageSizeGb;
+        this.customInfrequentAccessPercentage = customInfrequentAccessPercentage;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::EFS::FileSystem';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        try {
+            // Guard against undefined properties
+            if (!resource.properties) {
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: ['Resource properties are undefined'],
+                };
+            }
+            const regionPrefix = (0, RegionMapper_1.getRegionPrefix)(region);
+            const storageSizeGb = this.customStorageSizeGb ?? this.DEFAULT_STORAGE_SIZE_GB;
+            const iaPercentage = this.customInfrequentAccessPercentage ?? this.DEFAULT_IA_PERCENTAGE;
+            Logger_1.Logger.debug('EFS pricing calculation started', {
+                region,
+                regionPrefix,
+                normalizedRegion: (0, RegionMapper_1.normalizeRegion)(region),
+                storageSizeGb,
+                iaPercentage,
+            });
+            // Check for lifecycle policies to determine if IA storage is used
+            const lifecyclePolicies = resource.properties?.LifecyclePolicies;
+            const hasIATransition = lifecyclePolicies?.some(policy => policy.TransitionToIA !== undefined) ?? false;
+            // Check for provisioned throughput
+            const throughputMode = resource.properties?.ThroughputMode;
+            const provisionedThroughputInMibps = resource.properties?.ProvisionedThroughputInMibps;
+            const isProvisionedThroughput = throughputMode === 'provisioned' && provisionedThroughputInMibps !== undefined;
+            // Calculate storage distribution
+            const effectiveIAPercentage = hasIATransition ? iaPercentage : 0;
+            const standardStorageGb = storageSizeGb * (1 - effectiveIAPercentage / 100);
+            const iaStorageGb = storageSizeGb * (effectiveIAPercentage / 100);
+            // Get Standard storage pricing
+            const standardStoragePrice = await pricingClient.getPrice({
+                serviceCode: 'AmazonEFS',
+                region: (0, RegionMapper_1.normalizeRegion)(region),
+                filters: [
+                    { field: 'productFamily', value: 'Storage' },
+                    { field: 'usagetype', value: `${regionPrefix}-TimedStorage-ByteHrs` },
+                ],
+            });
+            Logger_1.Logger.debug('EFS Standard storage price retrieved', {
+                standardStoragePrice,
+                usageType: `${regionPrefix}-TimedStorage-ByteHrs`,
+            });
+            // Get Infrequent Access storage pricing
+            let iaStoragePrice = null;
+            let iaRequestPrice = null;
+            if (hasIATransition && iaPercentage > 0) {
+                iaStoragePrice = await pricingClient.getPrice({
+                    serviceCode: 'AmazonEFS',
+                    region: (0, RegionMapper_1.normalizeRegion)(region),
+                    filters: [
+                        { field: 'productFamily', value: 'Storage' },
+                        { field: 'usagetype', value: `${regionPrefix}-IATimedStorage-ByteHrs` },
+                    ],
+                });
+                iaRequestPrice = await pricingClient.getPrice({
+                    serviceCode: 'AmazonEFS',
+                    region: (0, RegionMapper_1.normalizeRegion)(region),
+                    filters: [
+                        { field: 'productFamily', value: 'Storage' },
+                        { field: 'usagetype', value: `${regionPrefix}-IARequests-Bytes` },
+                    ],
+                });
+                Logger_1.Logger.debug('EFS IA storage prices retrieved', {
+                    iaStoragePrice,
+                    iaRequestPrice,
+                });
+            }
+            // Get Provisioned Throughput pricing
+            let provisionedThroughputPrice = null;
+            if (isProvisionedThroughput) {
+                provisionedThroughputPrice = await pricingClient.getPrice({
+                    serviceCode: 'AmazonEFS',
+                    region: (0, RegionMapper_1.normalizeRegion)(region),
+                    filters: [
+                        { field: 'productFamily', value: 'Provisioned Throughput' },
+                        { field: 'usagetype', value: `${regionPrefix}-ProvisionedTP-MiBpsHrs` },
+                    ],
+                });
+                Logger_1.Logger.debug('EFS Provisioned Throughput price retrieved', {
+                    provisionedThroughputPrice,
+                    usageType: `${regionPrefix}-ProvisionedTP-MiBpsHrs`,
+                });
+            }
+            const assumptions = [];
+            let totalCost = 0;
+            let confidence = 'medium';
+            // Calculate standard storage cost
+            const effectiveStandardPrice = standardStoragePrice ?? this.FALLBACK_STANDARD_PRICE;
+            const standardStorageCost = standardStorageGb * effectiveStandardPrice;
+            if (standardStoragePrice === null) {
+                assumptions.push('Using fallback Standard storage pricing (API unavailable)');
+                confidence = 'low';
+            }
+            totalCost += standardStorageCost;
+            assumptions.push(`Standard storage: ${standardStorageGb.toFixed(2)} GB × $${effectiveStandardPrice.toFixed(4)}/GB = $${standardStorageCost.toFixed(2)}/month`);
+            // Calculate IA storage cost
+            if (hasIATransition && iaPercentage > 0) {
+                const effectiveIAStoragePrice = iaStoragePrice ?? this.FALLBACK_IA_STORAGE_PRICE;
+                const iaStorageCost = iaStorageGb * effectiveIAStoragePrice;
+                if (iaStoragePrice === null) {
+                    assumptions.push('Using fallback Infrequent Access storage pricing (API unavailable)');
+                    confidence = 'low';
+                }
+                totalCost += iaStorageCost;
+                assumptions.push(`Infrequent Access storage: ${iaStorageGb.toFixed(2)} GB × $${effectiveIAStoragePrice.toFixed(4)}/GB = $${iaStorageCost.toFixed(2)}/month`);
+                // Estimate IA request cost (assume 10% of IA data is accessed per month)
+                const estimatedIAAccessGb = iaStorageGb * 0.10;
+                const effectiveIARequestPrice = iaRequestPrice ?? this.FALLBACK_IA_REQUEST_PRICE;
+                const iaRequestCost = estimatedIAAccessGb * effectiveIARequestPrice;
+                if (iaRequestPrice === null && iaPercentage > 0) {
+                    assumptions.push('Using fallback Infrequent Access request pricing (API unavailable)');
+                    confidence = 'low';
+                }
+                totalCost += iaRequestCost;
+                assumptions.push(`IA requests (estimated 10% access): ${estimatedIAAccessGb.toFixed(2)} GB × $${effectiveIARequestPrice.toFixed(4)}/GB = $${iaRequestCost.toFixed(2)}/month`);
+            }
+            // Calculate provisioned throughput cost
+            if (isProvisionedThroughput && provisionedThroughputInMibps !== undefined) {
+                const effectiveProvisionedPrice = provisionedThroughputPrice ?? this.FALLBACK_PROVISIONED_THROUGHPUT_PRICE;
+                const provisionedCost = provisionedThroughputInMibps * effectiveProvisionedPrice;
+                if (provisionedThroughputPrice === null) {
+                    assumptions.push('Using fallback Provisioned Throughput pricing (API unavailable)');
+                    confidence = 'low';
+                }
+                totalCost += provisionedCost;
+                assumptions.push(`Provisioned Throughput: ${provisionedThroughputInMibps} MB/s × $${effectiveProvisionedPrice.toFixed(2)}/MB/s = $${provisionedCost.toFixed(2)}/month`);
+            }
+            // Add summary assumptions
+            assumptions.push(`Total storage: ${storageSizeGb} GB`);
+            if (this.customStorageSizeGb !== undefined) {
+                assumptions.push('Using custom storage size assumption from configuration');
+            }
+            if (hasIATransition) {
+                assumptions.push(`Lifecycle policy detected: ${effectiveIAPercentage}% in Infrequent Access`);
+                if (this.customInfrequentAccessPercentage !== undefined) {
+                    assumptions.push('Using custom IA percentage assumption from configuration');
+                }
+            }
+            if (throughputMode) {
+                assumptions.push(`Throughput mode: ${throughputMode}`);
+            }
+            assumptions.push(`Total: $${totalCost.toFixed(2)}/month`);
+            Logger_1.Logger.debug('EFS cost calculated', {
+                standardStorageCost,
+                totalCost,
+                confidence,
+            });
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence,
+                assumptions,
+            };
+        }
+        catch (error) {
+            Logger_1.Logger.debug('EFS pricing calculation failed', {
+                error: error instanceof Error ? error.message : String(error),
+                region,
+            });
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+}
+exports.EFSCalculator = EFSCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EFSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/EFSCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion, getRegionPrefix } from '../RegionMapper';\nimport { Logger } from '../../utils/Logger';\n\nexport interface EFSUsageAssumptions {\n  storageSizeGb?: number;\n  infrequentAccessPercentage?: number;\n}\n\nexport class EFSCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_STORAGE_SIZE_GB = 100;\n  private readonly DEFAULT_IA_PERCENTAGE = 0;\n  \n  // Fallback pricing rates (AWS EFS us-east-1 pricing as of 2024)\n  private readonly FALLBACK_STANDARD_PRICE = 0.30; // Per GB-month\n  private readonly FALLBACK_IA_STORAGE_PRICE = 0.016; // Per GB-month\n  private readonly FALLBACK_IA_REQUEST_PRICE = 0.01; // Per GB transferred\n  private readonly FALLBACK_PROVISIONED_THROUGHPUT_PRICE = 6.00; // Per MB/s-month\n\n  constructor(\n    private readonly customStorageSizeGb?: number,\n    private readonly customInfrequentAccessPercentage?: number,\n  ) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::EFS::FileSystem';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    try {\n      // Guard against undefined properties\n      if (!resource.properties) {\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: ['Resource properties are undefined'],\n        };\n      }\n\n      const regionPrefix = getRegionPrefix(region);\n      const storageSizeGb = this.customStorageSizeGb ?? this.DEFAULT_STORAGE_SIZE_GB;\n      const iaPercentage = this.customInfrequentAccessPercentage ?? this.DEFAULT_IA_PERCENTAGE;\n\n      Logger.debug('EFS pricing calculation started', {\n        region,\n        regionPrefix,\n        normalizedRegion: normalizeRegion(region),\n        storageSizeGb,\n        iaPercentage,\n      });\n\n      // Check for lifecycle policies to determine if IA storage is used\n      const lifecyclePolicies = resource.properties?.LifecyclePolicies as Array<{ TransitionToIA?: string }> | undefined;\n      const hasIATransition = lifecyclePolicies?.some(policy => policy.TransitionToIA !== undefined) ?? false;\n\n      // Check for provisioned throughput\n      const throughputMode = resource.properties?.ThroughputMode as string | undefined;\n      const provisionedThroughputInMibps = resource.properties?.ProvisionedThroughputInMibps as number | undefined;\n      const isProvisionedThroughput = throughputMode === 'provisioned' && provisionedThroughputInMibps !== undefined;\n\n      // Calculate storage distribution\n      const effectiveIAPercentage = hasIATransition ? iaPercentage : 0;\n      const standardStorageGb = storageSizeGb * (1 - effectiveIAPercentage / 100);\n      const iaStorageGb = storageSizeGb * (effectiveIAPercentage / 100);\n\n      // Get Standard storage pricing\n      const standardStoragePrice = await pricingClient.getPrice({\n        serviceCode: 'AmazonEFS',\n        region: normalizeRegion(region),\n        filters: [\n          { field: 'productFamily', value: 'Storage' },\n          { field: 'usagetype', value: `${regionPrefix}-TimedStorage-ByteHrs` },\n        ],\n      });\n\n      Logger.debug('EFS Standard storage price retrieved', {\n        standardStoragePrice,\n        usageType: `${regionPrefix}-TimedStorage-ByteHrs`,\n      });\n\n      // Get Infrequent Access storage pricing\n      let iaStoragePrice: number | null = null;\n      let iaRequestPrice: number | null = null;\n      if (hasIATransition && iaPercentage > 0) {\n        iaStoragePrice = await pricingClient.getPrice({\n          serviceCode: 'AmazonEFS',\n          region: normalizeRegion(region),\n          filters: [\n            { field: 'productFamily', value: 'Storage' },\n            { field: 'usagetype', value: `${regionPrefix}-IATimedStorage-ByteHrs` },\n          ],\n        });\n\n        iaRequestPrice = await pricingClient.getPrice({\n          serviceCode: 'AmazonEFS',\n          region: normalizeRegion(region),\n          filters: [\n            { field: 'productFamily', value: 'Storage' },\n            { field: 'usagetype', value: `${regionPrefix}-IARequests-Bytes` },\n          ],\n        });\n\n        Logger.debug('EFS IA storage prices retrieved', {\n          iaStoragePrice,\n          iaRequestPrice,\n        });\n      }\n\n      // Get Provisioned Throughput pricing\n      let provisionedThroughputPrice: number | null = null;\n      if (isProvisionedThroughput) {\n        provisionedThroughputPrice = await pricingClient.getPrice({\n          serviceCode: 'AmazonEFS',\n          region: normalizeRegion(region),\n          filters: [\n            { field: 'productFamily', value: 'Provisioned Throughput' },\n            { field: 'usagetype', value: `${regionPrefix}-ProvisionedTP-MiBpsHrs` },\n          ],\n        });\n\n        Logger.debug('EFS Provisioned Throughput price retrieved', {\n          provisionedThroughputPrice,\n          usageType: `${regionPrefix}-ProvisionedTP-MiBpsHrs`,\n        });\n      }\n\n      const assumptions: string[] = [];\n      let totalCost = 0;\n      let confidence: 'high' | 'medium' | 'low' | 'unknown' = 'medium';\n\n      // Calculate standard storage cost\n      const effectiveStandardPrice = standardStoragePrice ?? this.FALLBACK_STANDARD_PRICE;\n      const standardStorageCost = standardStorageGb * effectiveStandardPrice;\n      if (standardStoragePrice === null) {\n        assumptions.push('Using fallback Standard storage pricing (API unavailable)');\n        confidence = 'low';\n      }\n      totalCost += standardStorageCost;\n      assumptions.push(`Standard storage: ${standardStorageGb.toFixed(2)} GB × $${effectiveStandardPrice.toFixed(4)}/GB = $${standardStorageCost.toFixed(2)}/month`);\n\n      // Calculate IA storage cost\n      if (hasIATransition && iaPercentage > 0) {\n        const effectiveIAStoragePrice = iaStoragePrice ?? this.FALLBACK_IA_STORAGE_PRICE;\n        const iaStorageCost = iaStorageGb * effectiveIAStoragePrice;\n        if (iaStoragePrice === null) {\n          assumptions.push('Using fallback Infrequent Access storage pricing (API unavailable)');\n          confidence = 'low';\n        }\n        totalCost += iaStorageCost;\n        assumptions.push(`Infrequent Access storage: ${iaStorageGb.toFixed(2)} GB × $${effectiveIAStoragePrice.toFixed(4)}/GB = $${iaStorageCost.toFixed(2)}/month`);\n\n        // Estimate IA request cost (assume 10% of IA data is accessed per month)\n        const estimatedIAAccessGb = iaStorageGb * 0.10;\n        const effectiveIARequestPrice = iaRequestPrice ?? this.FALLBACK_IA_REQUEST_PRICE;\n        const iaRequestCost = estimatedIAAccessGb * effectiveIARequestPrice;\n        if (iaRequestPrice === null && iaPercentage > 0) {\n          assumptions.push('Using fallback Infrequent Access request pricing (API unavailable)');\n          confidence = 'low';\n        }\n        totalCost += iaRequestCost;\n        assumptions.push(`IA requests (estimated 10% access): ${estimatedIAAccessGb.toFixed(2)} GB × $${effectiveIARequestPrice.toFixed(4)}/GB = $${iaRequestCost.toFixed(2)}/month`);\n      }\n\n      // Calculate provisioned throughput cost\n      if (isProvisionedThroughput && provisionedThroughputInMibps !== undefined) {\n        const effectiveProvisionedPrice = provisionedThroughputPrice ?? this.FALLBACK_PROVISIONED_THROUGHPUT_PRICE;\n        const provisionedCost = provisionedThroughputInMibps * effectiveProvisionedPrice;\n        if (provisionedThroughputPrice === null) {\n          assumptions.push('Using fallback Provisioned Throughput pricing (API unavailable)');\n          confidence = 'low';\n        }\n        totalCost += provisionedCost;\n        assumptions.push(`Provisioned Throughput: ${provisionedThroughputInMibps} MB/s × $${effectiveProvisionedPrice.toFixed(2)}/MB/s = $${provisionedCost.toFixed(2)}/month`);\n      }\n\n      // Add summary assumptions\n      assumptions.push(`Total storage: ${storageSizeGb} GB`);\n      if (this.customStorageSizeGb !== undefined) {\n        assumptions.push('Using custom storage size assumption from configuration');\n      }\n      if (hasIATransition) {\n        assumptions.push(`Lifecycle policy detected: ${effectiveIAPercentage}% in Infrequent Access`);\n        if (this.customInfrequentAccessPercentage !== undefined) {\n          assumptions.push('Using custom IA percentage assumption from configuration');\n        }\n      }\n      if (throughputMode) {\n        assumptions.push(`Throughput mode: ${throughputMode}`);\n      }\n\n      assumptions.push(`Total: $${totalCost.toFixed(2)}/month`);\n\n      Logger.debug('EFS cost calculated', {\n        standardStorageCost,\n        totalCost,\n        confidence,\n      });\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence,\n        assumptions,\n      };\n    } catch (error) {\n      Logger.debug('EFS pricing calculation failed', {\n        error: error instanceof Error ? error.message : String(error),\n        region,\n      });\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n}\n"]}

package/dist/pricing/calculators/SQSCalculator.d.ts

@@ -0,0 +1,16 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+import { CostAnalyzerConfig } from '../../config/types';
+export declare class SQSCalculator implements ResourceCostCalculator {
+    private readonly DEFAULT_MONTHLY_REQUESTS;
+    private readonly FALLBACK_STANDARD_PRICE_PER_MILLION;
+    private readonly FALLBACK_FIFO_PRICE_PER_MILLION;
+    private config?;
+    constructor(config?: CostAnalyzerConfig);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private isFifoQueue;
+    private getMonthlyRequests;
+    private buildAssumptions;
+    private getPricePerMillion;
+}

package/dist/pricing/calculators/SQSCalculator.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQSCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+class SQSCalculator {
+    DEFAULT_MONTHLY_REQUESTS = 1_000_000;
+    // Fallback pricing rates (AWS SQS us-east-1 pricing as of 2024)
+    // Used when API pricing is unavailable but user provided usage assumptions
+    FALLBACK_STANDARD_PRICE_PER_MILLION = 0.40;
+    FALLBACK_FIFO_PRICE_PER_MILLION = 0.50;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::SQS::Queue';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const isFifo = this.isFifoQueue(resource);
+        const monthlyRequests = this.getMonthlyRequests();
+        try {
+            const pricePerMillion = await this.getPricePerMillion(region, isFifo, pricingClient);
+            const assumptions = this.buildAssumptions(monthlyRequests, isFifo);
+            if (pricePerMillion === null) {
+                const hasCustomAssumptions = this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined;
+                if (hasCustomAssumptions) {
+                    const fallbackPrice = isFifo
+                        ? this.FALLBACK_FIFO_PRICE_PER_MILLION
+                        : this.FALLBACK_STANDARD_PRICE_PER_MILLION;
+                    const monthlyCost = (monthlyRequests / 1_000_000) * fallbackPrice;
+                    return {
+                        amount: monthlyCost,
+                        currency: 'USD',
+                        confidence: 'low',
+                        assumptions: [
+                            'Using fallback pricing (API unavailable)',
+                            ...assumptions,
+                        ],
+                    };
+                }
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for SQS in region ${region}`,
+                        ...assumptions,
+                    ],
+                };
+            }
+            const monthlyCost = (monthlyRequests / 1_000_000) * pricePerMillion;
+            return {
+                amount: monthlyCost,
+                currency: 'USD',
+                confidence: 'medium',
+                assumptions,
+            };
+        }
+        catch (error) {
+            const assumptions = this.buildAssumptions(monthlyRequests, isFifo);
+            const hasCustomAssumptions = this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined;
+            if (hasCustomAssumptions) {
+                const fallbackPrice = isFifo
+                    ? this.FALLBACK_FIFO_PRICE_PER_MILLION
+                    : this.FALLBACK_STANDARD_PRICE_PER_MILLION;
+                const monthlyCost = (monthlyRequests / 1_000_000) * fallbackPrice;
+                return {
+                    amount: monthlyCost,
+                    currency: 'USD',
+                    confidence: 'low',
+                    assumptions: [
+                        'Using fallback pricing (API error)',
+                        ...assumptions,
+                    ],
+                };
+            }
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [
+                    `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,
+                    ...assumptions,
+                ],
+            };
+        }
+    }
+    isFifoQueue(resource) {
+        return resource.properties.FifoQueue === true ||
+            resource.properties.FifoQueue === 'true';
+    }
+    getMonthlyRequests() {
+        return this.config?.usageAssumptions?.sqs?.monthlyRequests ?? this.DEFAULT_MONTHLY_REQUESTS;
+    }
+    buildAssumptions(monthlyRequests, isFifo) {
+        const assumptions = [
+            `Assumes ${monthlyRequests.toLocaleString()} requests per month`,
+            isFifo ? 'FIFO queue' : 'Standard queue',
+            'Does not include data transfer costs',
+        ];
+        if (this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined) {
+            assumptions.push('Using custom monthly requests assumption from configuration');
+        }
+        return assumptions;
+    }
+    async getPricePerMillion(region, isFifo, pricingClient) {
+        const normalizedRegion = (0, RegionMapper_1.normalizeRegion)(region);
+        const regionPrefix = (0, RegionMapper_1.getRegionPrefix)(region);
+        // Standard queue usagetype: USE1-Requests (or just Requests for us-east-1)
+        // FIFO queue usagetype: USE1-Requests-FIFO (or just Requests-FIFO for us-east-1)
+        const baseUsageType = isFifo ? 'Requests-FIFO' : 'Requests';
+        const usageType = regionPrefix ? `${regionPrefix}-${baseUsageType}` : baseUsageType;
+        return pricingClient.getPrice({
+            serviceCode: 'AWSQueueService',
+            region: normalizedRegion,
+            filters: [
+                { field: 'productFamily', value: 'Queue' },
+                { field: 'usagetype', value: usageType },
+            ],
+        });
+    }
+}
+exports.SQSCalculator = SQSCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SQSCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/SQSCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion, getRegionPrefix } from '../RegionMapper';\nimport { CostAnalyzerConfig } from '../../config/types';\n\nexport class SQSCalculator implements ResourceCostCalculator {\n  private readonly DEFAULT_MONTHLY_REQUESTS = 1_000_000;\n\n  // Fallback pricing rates (AWS SQS us-east-1 pricing as of 2024)\n  // Used when API pricing is unavailable but user provided usage assumptions\n  private readonly FALLBACK_STANDARD_PRICE_PER_MILLION = 0.40;\n  private readonly FALLBACK_FIFO_PRICE_PER_MILLION = 0.50;\n\n  private config?: CostAnalyzerConfig;\n\n  constructor(config?: CostAnalyzerConfig) {\n    this.config = config;\n  }\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::SQS::Queue';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const isFifo = this.isFifoQueue(resource);\n    const monthlyRequests = this.getMonthlyRequests();\n\n    try {\n      const pricePerMillion = await this.getPricePerMillion(region, isFifo, pricingClient);\n\n      const assumptions = this.buildAssumptions(monthlyRequests, isFifo);\n\n      if (pricePerMillion === null) {\n        const hasCustomAssumptions = this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined;\n\n        if (hasCustomAssumptions) {\n          const fallbackPrice = isFifo\n            ? this.FALLBACK_FIFO_PRICE_PER_MILLION\n            : this.FALLBACK_STANDARD_PRICE_PER_MILLION;\n          const monthlyCost = (monthlyRequests / 1_000_000) * fallbackPrice;\n\n          return {\n            amount: monthlyCost,\n            currency: 'USD',\n            confidence: 'low',\n            assumptions: [\n              'Using fallback pricing (API unavailable)',\n              ...assumptions,\n            ],\n          };\n        }\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for SQS in region ${region}`,\n            ...assumptions,\n          ],\n        };\n      }\n\n      const monthlyCost = (monthlyRequests / 1_000_000) * pricePerMillion;\n\n      return {\n        amount: monthlyCost,\n        currency: 'USD',\n        confidence: 'medium',\n        assumptions,\n      };\n    } catch (error) {\n      const assumptions = this.buildAssumptions(monthlyRequests, isFifo);\n      const hasCustomAssumptions = this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined;\n\n      if (hasCustomAssumptions) {\n        const fallbackPrice = isFifo\n          ? this.FALLBACK_FIFO_PRICE_PER_MILLION\n          : this.FALLBACK_STANDARD_PRICE_PER_MILLION;\n        const monthlyCost = (monthlyRequests / 1_000_000) * fallbackPrice;\n\n        return {\n          amount: monthlyCost,\n          currency: 'USD',\n          confidence: 'low',\n          assumptions: [\n            'Using fallback pricing (API error)',\n            ...assumptions,\n          ],\n        };\n      }\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [\n          `Failed to fetch pricing: ${error instanceof Error ? error.message : String(error)}`,\n          ...assumptions,\n        ],\n      };\n    }\n  }\n\n  private isFifoQueue(resource: ResourceWithId): boolean {\n    return resource.properties.FifoQueue === true ||\n           resource.properties.FifoQueue === 'true';\n  }\n\n  private getMonthlyRequests(): number {\n    return this.config?.usageAssumptions?.sqs?.monthlyRequests ?? this.DEFAULT_MONTHLY_REQUESTS;\n  }\n\n  private buildAssumptions(monthlyRequests: number, isFifo: boolean): string[] {\n    const assumptions = [\n      `Assumes ${monthlyRequests.toLocaleString()} requests per month`,\n      isFifo ? 'FIFO queue' : 'Standard queue',\n      'Does not include data transfer costs',\n    ];\n\n    if (this.config?.usageAssumptions?.sqs?.monthlyRequests !== undefined) {\n      assumptions.push('Using custom monthly requests assumption from configuration');\n    }\n\n    return assumptions;\n  }\n\n  private async getPricePerMillion(\n    region: string,\n    isFifo: boolean,\n    pricingClient: PricingClient,\n  ): Promise<number | null> {\n    const normalizedRegion = normalizeRegion(region);\n    const regionPrefix = getRegionPrefix(region);\n\n    // Standard queue usagetype: USE1-Requests (or just Requests for us-east-1)\n    // FIFO queue usagetype: USE1-Requests-FIFO (or just Requests-FIFO for us-east-1)\n    const baseUsageType = isFifo ? 'Requests-FIFO' : 'Requests';\n    const usageType = regionPrefix ? `${regionPrefix}-${baseUsageType}` : baseUsageType;\n\n    return pricingClient.getPrice({\n      serviceCode: 'AWSQueueService',\n      region: normalizedRegion,\n      filters: [\n        { field: 'productFamily', value: 'Queue' },\n        { field: 'usagetype', value: usageType },\n      ],\n    });\n  }\n}\n"]}

package/dist/pricing/calculators/SecretsManagerCalculator.d.ts

@@ -0,0 +1,21 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Calculator for AWS::SecretsManager::Secret resources.
+ *
+ * AWS Secrets Manager Pricing Model (as of 2024):
+ * - Secret storage: $0.40 per secret per month
+ * - API calls: $0.05 per 10,000 API calls
+ * - No free tier
+ *
+ * @see https://aws.amazon.com/secrets-manager/pricing/
+ */
+export declare class SecretsManagerCalculator implements ResourceCostCalculator {
+    private readonly customMonthlyApiCalls?;
+    private readonly DEFAULT_MONTHLY_API_CALLS;
+    private readonly FALLBACK_SECRET_STORAGE_PRICE;
+    private readonly FALLBACK_API_CALL_PRICE_PER_10K;
+    constructor(customMonthlyApiCalls?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/pricing/calculators/SecretsManagerCalculator.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretsManagerCalculator = void 0;
+const RegionMapper_1 = require("../RegionMapper");
+const Logger_1 = require("../../utils/Logger");
+/**
+ * Calculator for AWS::SecretsManager::Secret resources.
+ *
+ * AWS Secrets Manager Pricing Model (as of 2024):
+ * - Secret storage: $0.40 per secret per month
+ * - API calls: $0.05 per 10,000 API calls
+ * - No free tier
+ *
+ * @see https://aws.amazon.com/secrets-manager/pricing/
+ */
+class SecretsManagerCalculator {
+    customMonthlyApiCalls;
+    // Default usage assumptions
+    DEFAULT_MONTHLY_API_CALLS = 10_000;
+    // Fallback pricing (AWS Secrets Manager pricing as of 2024)
+    FALLBACK_SECRET_STORAGE_PRICE = 0.40; // Per secret per month
+    FALLBACK_API_CALL_PRICE_PER_10K = 0.05;
+    constructor(customMonthlyApiCalls) {
+        this.customMonthlyApiCalls = customMonthlyApiCalls;
+    }
+    supports(resourceType) {
+        return resourceType === 'AWS::SecretsManager::Secret';
+    }
+    async calculateCost(resource, region, pricingClient) {
+        const monthlyApiCalls = this.customMonthlyApiCalls ?? this.DEFAULT_MONTHLY_API_CALLS;
+        Logger_1.Logger.debug('Secrets Manager pricing calculation started', {
+            region,
+            logicalId: resource.logicalId,
+            monthlyApiCalls,
+        });
+        try {
+            const normalizedRegion = (0, RegionMapper_1.normalizeRegion)(region);
+            // Query pricing for secret storage (per secret monthly cost)
+            const secretStoragePrice = await pricingClient.getPrice({
+                serviceCode: 'AWSSecretsManager',
+                region: normalizedRegion,
+                filters: [
+                    { field: 'productFamily', value: 'Secret' },
+                    { field: 'group', value: 'SecretStorage' },
+                ],
+            });
+            Logger_1.Logger.debug('Secrets Manager storage price retrieved', {
+                secretStoragePrice,
+                region: normalizedRegion,
+            });
+            // Query pricing for API calls
+            const apiCallPrice = await pricingClient.getPrice({
+                serviceCode: 'AWSSecretsManager',
+                region: normalizedRegion,
+                filters: [
+                    { field: 'productFamily', value: 'Secret' },
+                    { field: 'group', value: 'SecretRotation' },
+                ],
+            });
+            Logger_1.Logger.debug('Secrets Manager API call price retrieved', {
+                apiCallPrice,
+                region: normalizedRegion,
+            });
+            // If pricing data is completely unavailable
+            if (secretStoragePrice === null && apiCallPrice === null) {
+                Logger_1.Logger.debug('Secrets Manager pricing not available', {
+                    region,
+                    normalizedRegion,
+                });
+                return {
+                    amount: 0,
+                    currency: 'USD',
+                    confidence: 'unknown',
+                    assumptions: [
+                        `Pricing data not available for Secrets Manager in region ${region}`,
+                        `Would assume ${monthlyApiCalls.toLocaleString()} API calls per month`,
+                    ],
+                };
+            }
+            // Handle pricing unavailability with fallback
+            const storageCost = secretStoragePrice ?? this.FALLBACK_SECRET_STORAGE_PRICE;
+            const callCostPer10K = apiCallPrice ?? this.FALLBACK_API_CALL_PRICE_PER_10K;
+            const apiCallCost = (monthlyApiCalls / 10_000) * callCostPer10K;
+            const totalCost = storageCost + apiCallCost;
+            const confidence = (secretStoragePrice === null || apiCallPrice === null) ? 'low' : 'medium';
+            const usedFallback = (secretStoragePrice === null || apiCallPrice === null);
+            Logger_1.Logger.debug('Secrets Manager cost calculated', {
+                storageCost,
+                callCostPer10K,
+                apiCallCost,
+                totalCost,
+                confidence,
+                usedFallback,
+            });
+            const assumptions = [];
+            // Add fallback warning first if used
+            if (usedFallback) {
+                if (secretStoragePrice === null) {
+                    assumptions.push('Using fallback storage pricing (API unavailable)');
+                }
+                if (apiCallPrice === null) {
+                    assumptions.push('Using fallback API call pricing (API unavailable)');
+                }
+            }
+            // Add cost breakdown
+            assumptions.push(`Secret storage: $${storageCost.toFixed(2)}/month`);
+            assumptions.push(`API calls: ${monthlyApiCalls.toLocaleString()} calls × $${callCostPer10K.toFixed(4)}/10K = $${apiCallCost.toFixed(2)}/month`);
+            assumptions.push(`Total: $${totalCost.toFixed(2)}/month`);
+            // Add custom assumption note
+            if (this.customMonthlyApiCalls !== undefined) {
+                assumptions.push('Using custom API call volume from configuration');
+            }
+            // Add informational notes
+            assumptions.push('No free tier for Secrets Manager');
+            assumptions.push('Cross-region replication incurs additional costs (not calculated)');
+            return {
+                amount: totalCost,
+                currency: 'USD',
+                confidence,
+                assumptions,
+            };
+        }
+        catch (error) {
+            Logger_1.Logger.debug('Secrets Manager pricing calculation failed', {
+                error: error instanceof Error ? error.message : String(error),
+                region,
+            });
+            return {
+                amount: 0,
+                currency: 'USD',
+                confidence: 'unknown',
+                assumptions: [`Failed to calculate Secrets Manager cost: ${error instanceof Error ? error.message : String(error)}`],
+            };
+        }
+    }
+}
+exports.SecretsManagerCalculator = SecretsManagerCalculator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SecretsManagerCalculator.js","sourceRoot":"","sources":["../../../src/pricing/calculators/SecretsManagerCalculator.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';\nimport { normalizeRegion } from '../RegionMapper';\nimport { Logger } from '../../utils/Logger';\n\n/**\n * Calculator for AWS::SecretsManager::Secret resources.\n *\n * AWS Secrets Manager Pricing Model (as of 2024):\n * - Secret storage: $0.40 per secret per month\n * - API calls: $0.05 per 10,000 API calls\n * - No free tier\n *\n * @see https://aws.amazon.com/secrets-manager/pricing/\n */\nexport class SecretsManagerCalculator implements ResourceCostCalculator {\n  // Default usage assumptions\n  private readonly DEFAULT_MONTHLY_API_CALLS = 10_000;\n\n  // Fallback pricing (AWS Secrets Manager pricing as of 2024)\n  private readonly FALLBACK_SECRET_STORAGE_PRICE = 0.40; // Per secret per month\n  private readonly FALLBACK_API_CALL_PRICE_PER_10K = 0.05;\n\n  constructor(private readonly customMonthlyApiCalls?: number) {}\n\n  supports(resourceType: string): boolean {\n    return resourceType === 'AWS::SecretsManager::Secret';\n  }\n\n  async calculateCost(\n    resource: ResourceWithId,\n    region: string,\n    pricingClient: PricingClient,\n  ): Promise<MonthlyCost> {\n    const monthlyApiCalls = this.customMonthlyApiCalls ?? this.DEFAULT_MONTHLY_API_CALLS;\n\n    Logger.debug('Secrets Manager pricing calculation started', {\n      region,\n      logicalId: resource.logicalId,\n      monthlyApiCalls,\n    });\n\n    try {\n      const normalizedRegion = normalizeRegion(region);\n\n      // Query pricing for secret storage (per secret monthly cost)\n      const secretStoragePrice = await pricingClient.getPrice({\n        serviceCode: 'AWSSecretsManager',\n        region: normalizedRegion,\n        filters: [\n          { field: 'productFamily', value: 'Secret' },\n          { field: 'group', value: 'SecretStorage' },\n        ],\n      });\n\n      Logger.debug('Secrets Manager storage price retrieved', {\n        secretStoragePrice,\n        region: normalizedRegion,\n      });\n\n      // Query pricing for API calls\n      const apiCallPrice = await pricingClient.getPrice({\n        serviceCode: 'AWSSecretsManager',\n        region: normalizedRegion,\n        filters: [\n          { field: 'productFamily', value: 'Secret' },\n          { field: 'group', value: 'SecretRotation' },\n        ],\n      });\n\n      Logger.debug('Secrets Manager API call price retrieved', {\n        apiCallPrice,\n        region: normalizedRegion,\n      });\n\n      // If pricing data is completely unavailable\n      if (secretStoragePrice === null && apiCallPrice === null) {\n        Logger.debug('Secrets Manager pricing not available', {\n          region,\n          normalizedRegion,\n        });\n\n        return {\n          amount: 0,\n          currency: 'USD',\n          confidence: 'unknown',\n          assumptions: [\n            `Pricing data not available for Secrets Manager in region ${region}`,\n            `Would assume ${monthlyApiCalls.toLocaleString()} API calls per month`,\n          ],\n        };\n      }\n\n      // Handle pricing unavailability with fallback\n      const storageCost = secretStoragePrice ?? this.FALLBACK_SECRET_STORAGE_PRICE;\n      const callCostPer10K = apiCallPrice ?? this.FALLBACK_API_CALL_PRICE_PER_10K;\n\n      const apiCallCost = (monthlyApiCalls / 10_000) * callCostPer10K;\n      const totalCost = storageCost + apiCallCost;\n\n      const confidence = (secretStoragePrice === null || apiCallPrice === null) ? 'low' : 'medium';\n      const usedFallback = (secretStoragePrice === null || apiCallPrice === null);\n\n      Logger.debug('Secrets Manager cost calculated', {\n        storageCost,\n        callCostPer10K,\n        apiCallCost,\n        totalCost,\n        confidence,\n        usedFallback,\n      });\n\n      const assumptions: string[] = [];\n\n      // Add fallback warning first if used\n      if (usedFallback) {\n        if (secretStoragePrice === null) {\n          assumptions.push('Using fallback storage pricing (API unavailable)');\n        }\n        if (apiCallPrice === null) {\n          assumptions.push('Using fallback API call pricing (API unavailable)');\n        }\n      }\n\n      // Add cost breakdown\n      assumptions.push(`Secret storage: $${storageCost.toFixed(2)}/month`);\n      assumptions.push(\n        `API calls: ${monthlyApiCalls.toLocaleString()} calls × $${callCostPer10K.toFixed(4)}/10K = $${apiCallCost.toFixed(2)}/month`,\n      );\n      assumptions.push(`Total: $${totalCost.toFixed(2)}/month`);\n\n      // Add custom assumption note\n      if (this.customMonthlyApiCalls !== undefined) {\n        assumptions.push('Using custom API call volume from configuration');\n      }\n\n      // Add informational notes\n      assumptions.push('No free tier for Secrets Manager');\n      assumptions.push('Cross-region replication incurs additional costs (not calculated)');\n\n      return {\n        amount: totalCost,\n        currency: 'USD',\n        confidence,\n        assumptions,\n      };\n    } catch (error) {\n      Logger.debug('Secrets Manager pricing calculation failed', {\n        error: error instanceof Error ? error.message : String(error),\n        region,\n      });\n\n      return {\n        amount: 0,\n        currency: 'USD',\n        confidence: 'unknown',\n        assumptions: [`Failed to calculate Secrets Manager cost: ${error instanceof Error ? error.message : String(error)}`],\n      };\n    }\n  }\n}\n"]}

package/dist/pricing/index.d.ts

@@ -6,8 +6,11 @@ export { S3Calculator } from './calculators/S3Calculator';
 export { LambdaCalculator } from './calculators/LambdaCalculator';
 export { RDSCalculator } from './calculators/RDSCalculator';
 export { CloudFrontCalculator } from './calculators/CloudFrontCalculator';
+export { EFSCalculator, EFSUsageAssumptions } from './calculators/EFSCalculator';
 export { ElastiCacheCalculator } from './calculators/ElastiCacheCalculator';
+export { SecretsManagerCalculator } from './calculators/SecretsManagerCalculator';
 export { SNSCalculator, SNSCostBreakdown } from './calculators/SNSCalculator';
+export { SQSCalculator } from './calculators/SQSCalculator';
 export { LaunchTemplateCalculator, LaunchTemplateConfig, EbsVolumeConfig, } from './calculators/LaunchTemplateCalculator';
 export { StepFunctionsCalculator, StepFunctionsWorkflowType, } from './calculators/StepFunctionsCalculator';
 export * from './types';

package/dist/pricing/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StepFunctionsCalculator = exports.LaunchTemplateCalculator = exports.SNSCalculator = exports.ElastiCacheCalculator = exports.CloudFrontCalculator = exports.RDSCalculator = exports.LambdaCalculator = exports.S3Calculator = exports.EC2Calculator = exports.CacheManager = exports.PricingClient = exports.PricingService = void 0;
+exports.StepFunctionsCalculator = exports.LaunchTemplateCalculator = exports.SQSCalculator = exports.SNSCalculator = exports.SecretsManagerCalculator = exports.ElastiCacheCalculator = exports.EFSCalculator = exports.CloudFrontCalculator = exports.RDSCalculator = exports.LambdaCalculator = exports.S3Calculator = exports.EC2Calculator = exports.CacheManager = exports.PricingClient = exports.PricingService = void 0;
 var PricingService_1 = require("./PricingService");
 Object.defineProperty(exports, "PricingService", { enumerable: true, get: function () { return PricingService_1.PricingService; } });
 var PricingClient_1 = require("./PricingClient");
@@ -31,13 +31,19 @@ var RDSCalculator_1 = require("./calculators/RDSCalculator");
 Object.defineProperty(exports, "RDSCalculator", { enumerable: true, get: function () { return RDSCalculator_1.RDSCalculator; } });
 var CloudFrontCalculator_1 = require("./calculators/CloudFrontCalculator");
 Object.defineProperty(exports, "CloudFrontCalculator", { enumerable: true, get: function () { return CloudFrontCalculator_1.CloudFrontCalculator; } });
+var EFSCalculator_1 = require("./calculators/EFSCalculator");
+Object.defineProperty(exports, "EFSCalculator", { enumerable: true, get: function () { return EFSCalculator_1.EFSCalculator; } });
 var ElastiCacheCalculator_1 = require("./calculators/ElastiCacheCalculator");
 Object.defineProperty(exports, "ElastiCacheCalculator", { enumerable: true, get: function () { return ElastiCacheCalculator_1.ElastiCacheCalculator; } });
+var SecretsManagerCalculator_1 = require("./calculators/SecretsManagerCalculator");
+Object.defineProperty(exports, "SecretsManagerCalculator", { enumerable: true, get: function () { return SecretsManagerCalculator_1.SecretsManagerCalculator; } });
 var SNSCalculator_1 = require("./calculators/SNSCalculator");
 Object.defineProperty(exports, "SNSCalculator", { enumerable: true, get: function () { return SNSCalculator_1.SNSCalculator; } });
+var SQSCalculator_1 = require("./calculators/SQSCalculator");
+Object.defineProperty(exports, "SQSCalculator", { enumerable: true, get: function () { return SQSCalculator_1.SQSCalculator; } });
 var LaunchTemplateCalculator_1 = require("./calculators/LaunchTemplateCalculator");
 Object.defineProperty(exports, "LaunchTemplateCalculator", { enumerable: true, get: function () { return LaunchTemplateCalculator_1.LaunchTemplateCalculator; } });
 var StepFunctionsCalculator_1 = require("./calculators/StepFunctionsCalculator");
 Object.defineProperty(exports, "StepFunctionsCalculator", { enumerable: true, get: function () { return StepFunctionsCalculator_1.StepFunctionsCalculator; } });
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/releasetag.txt

@@ -1 +1 @@
-v0.1.31
+v0.1.33

package/docs/CALCULATORS.md

@@ -9,6 +9,7 @@ This document provides detailed information about all supported AWS resource typ
 - [Storage Resources](#storage-resources)
 - [Database Resources](#database-resources)
 - [Networking Resources](#networking-resources)
+- [Messaging Resources](#messaging-resources)
 - [Content Delivery Resources](#content-delivery-resources)
 - [Serverless Resources](#serverless-resources)
 - [Container Resources](#container-resources)
@@ -130,6 +131,99 @@ Total: $2.31/month
 - Cross-region replication costs not included
 - Lifecycle policies not considered
 
+### AWS::EFS::FileSystem
+
+**Description:** Amazon Elastic File System for scalable, shared file storage
+
+**Cost Components:**
+- Standard Storage: GB-month for frequently accessed data
+- Infrequent Access (IA) Storage: GB-month for infrequently accessed data
+- IA Requests: Data transferred to/from IA storage
+- Provisioned Throughput: MB/s-month (if configured)
+
+**Default Assumptions:**
+- 100 GB total storage
+- 0% in Infrequent Access storage class
+- Bursting throughput mode (no provisioned throughput cost)
+- 10% of IA data accessed per month (for IA request cost estimation)
+
+**Configuration:**
+```yaml
+usageAssumptions:
+  efs:
+    storageSizeGb: 100
+    infrequentAccessPercentage: 0
+```
+
+**Pricing Model:**
+| Component | Price (us-east-1) |
+|-----------|-------------------|
+| Standard Storage | $0.30/GB-month |
+| Infrequent Access Storage | $0.016/GB-month |
+| IA Requests | $0.01/GB transferred |
+| Provisioned Throughput | $6.00/MB/s-month |
+
+**Example (Standard Storage Only):**
+```
+Storage: 100 GB × $0.30/GB = $30.00/month
+```
+
+**Example (With Infrequent Access - 50%):**
+```
+Standard storage: 50 GB × $0.30/GB = $15.00
+IA storage: 50 GB × $0.016/GB = $0.80
+IA requests: 5 GB × $0.01/GB = $0.05
+Total: $15.85/month
+```
+
+**Example (With Provisioned Throughput):**
+```
+Storage: 100 GB × $0.30/GB = $30.00
+Provisioned: 10 MB/s × $6.00/MB/s = $60.00
+Total: $90.00/month
+```
+
+**Storage Class Detection:**
+
+The calculator automatically detects Infrequent Access usage from CloudFormation template:
+
+```yaml
+# CloudFormation template with lifecycle policy
+Resources:
+  MyFileSystem:
+    Type: AWS::EFS::FileSystem
+    Properties:
+      LifecyclePolicies:
+        - TransitionToIA: AFTER_30_DAYS
+```
+
+When `TransitionToIA` is detected, the calculator applies the configured `infrequentAccessPercentage` to estimate IA storage costs. Without a lifecycle policy, all storage is calculated at Standard rates.
+
+**Throughput Mode Detection:**
+
+The calculator detects provisioned throughput from CloudFormation template:
+
+```yaml
+# CloudFormation template with provisioned throughput
+Resources:
+  MyFileSystem:
+    Type: AWS::EFS::FileSystem
+    Properties:
+      ThroughputMode: provisioned
+      ProvisionedThroughputInMibps: 10
+```
+
+When `ThroughputMode: provisioned` is detected with a `ProvisionedThroughputInMibps` value, the provisioned throughput cost is added to the total.
+
+**Notes:**
+- EFS One Zone storage class not currently supported (uses Standard pricing)
+- Archive storage class not calculated
+- Data transfer costs not included
+- Mount target costs not included (no charge)
+- Backup costs not included
+- Actual storage used may vary from assumptions
+- IA request cost assumes 10% of IA data is accessed monthly
+
 ## Database Resources
 
 ### AWS::RDS::DBInstance
@@ -386,6 +480,54 @@ Monthly Cost: $0.00 (no charge)
 - Each endpoint per AZ incurs separate charges
 - Data transfer within same region not charged
 
+## Messaging Resources
+
+### AWS::SQS::Queue
+
+**Description:** Amazon Simple Queue Service for message queuing
+
+**Cost Components:**
+- Request pricing: Per million requests
+
+**Queue Types:**
+- **Standard Queue**: $0.40 per million requests (first 1 million free)
+- **FIFO Queue**: $0.50 per million requests (first 1 million free)
+
+**Default Assumptions:**
+- 1 million requests per month
+- Standard queue (unless FifoQueue property is true)
+
+**Configuration:**
+```yaml
+usageAssumptions:
+  sqs:
+    monthlyRequests: 1000000
+```
+
+**Example (Standard Queue):**
+```
+Requests: 1M × $0.40/1M = $0.40
+Total: $0.40/month
+```
+
+**Example (FIFO Queue):**
+```
+Requests: 1M × $0.50/1M = $0.50
+Total: $0.50/month
+```
+
+**Detection:**
+- Queue type is detected from the `FifoQueue` CloudFormation property
+- If `FifoQueue: true` is set, FIFO pricing is applied
+- Otherwise, standard queue pricing is used
+
+**Notes:**
+- First 1 million requests free per month (not factored into estimates)
+- FIFO queues provide exactly-once processing
+- Data transfer costs not included
+- Long polling and batch operations count as single requests
+- Dead-letter queue costs calculated separately
+
 ## Content Delivery Resources
 
 ### AWS::CloudFront::Distribution
@@ -712,6 +854,54 @@ Total: $0.02/month
 - First 4,000 state transitions per month are free tier eligible (Standard)
 - Activity polling and callbacks may incur additional charges
 
+## Security Resources
+
+### AWS::SecretsManager::Secret
+
+**Description:** AWS Secrets Manager for credential and secret storage
+
+**Cost Components:**
+- Secret storage: $0.40 per secret per month
+- API calls: $0.05 per 10,000 API calls
+
+**Default Assumptions:**
+- 10,000 API calls per month (GetSecretValue, DescribeSecret, etc.)
+
+**Configuration:**
+```yaml
+usageAssumptions:
+  secretsManager:
+    monthlyApiCalls: 10000
+```
+
+**Example:**
+```
+Secret storage: 1 secret × $0.40 = $0.40/month
+API calls: 10,000 calls × $0.05/10K = $0.05/month
+Total: $0.45/month
+```
+
+**Example with higher API volume:**
+```yaml
+usageAssumptions:
+  secretsManager:
+    monthlyApiCalls: 50000
+```
+
+```
+Secret storage: 1 secret × $0.40 = $0.40/month
+API calls: 50,000 calls × $0.05/10K = $0.25/month
+Total: $0.65/month
+```
+
+**Notes:**
+- No free tier for Secrets Manager
+- Automatic rotation is included in the base secret cost
+- Cross-region replication incurs additional storage costs (not calculated)
+- API call pricing includes GetSecretValue, DescribeSecret, ListSecrets, and other operations
+- Deletion protection can prevent accidental secret deletion
+- Secrets can be rotated automatically using Lambda functions (Lambda costs separate)
+
 ## Container Resources
 
 ### AWS::ECS::Service
@@ -774,6 +964,10 @@ usageAssumptions:
     getRequests: 100000
     putRequests: 10000
   
+  efs:
+    storageSizeGb: 500
+    infrequentAccessPercentage: 30  # 30% in Infrequent Access
+  
   # Database
   rds:
     hoursPerMonth: 730
@@ -802,6 +996,10 @@ usageAssumptions:
   vpcEndpoint:
     dataProcessedGB: 200
   
+  # Messaging
+  sqs:
+    monthlyRequests: 5000000
+  
   # Content Delivery
   cloudFront:
     dataTransferGB: 1000
@@ -838,6 +1036,10 @@ usageAssumptions:
     stateTransitionsPerExecution: 15   # State transitions per execution (Standard)
     averageDurationMs: 2000            # Average duration in ms (Express)
 
+  # Security
+  secretsManager:
+    monthlyApiCalls: 50000  # API calls per month
+
   # Containers
   ecs:
     fargate:
@@ -864,11 +1066,18 @@ const result = await analyzeCosts({
       invocationsPerMonth: 5000000,
       averageDurationMs: 500,
     },
+    efs: {
+      storageSizeGb: 200,
+      infrequentAccessPercentage: 25,
+    },
     stepFunctions: {
       monthlyExecutions: 50000,
       stateTransitionsPerExecution: 15,
       averageDurationMs: 2000,
     },
+    secretsManager: {
+      monthlyApiCalls: 50000,
+    },
   },
 });
 ```

package/package.json

@@ -83,7 +83,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.31",
+  "version": "0.1.33",
   "bugs": {
     "url": "https://github.com/buildinginthecloud/cdk-cost-analyzer/issues"
   },