cdk-cost-analyzer 0.1.35 → 0.1.37

package/dist/action/integrations/GitHubIntegration.d.ts

@@ -0,0 +1,43 @@
+import { GitHubIntegration as IGitHubIntegration, GitHubConfig, GitHubComment, CommentStrategy } from './types';
+export declare class GitHubIntegration implements IGitHubIntegration {
+    /**
+     * Create a GitHubIntegration instance from environment variables.
+     * Looks for GITHUB_TOKEN environment variable.
+     */
+    static fromEnvironment(): GitHubIntegration;
+    private config;
+    constructor(config: GitHubConfig);
+    /**
+     * Post a comment to a pull request using the specified strategy.
+     */
+    postPRComment(owner: string, repo: string, prNumber: number, comment: string, strategy?: CommentStrategy): Promise<void>;
+    /**
+     * Find an existing cost analyzer comment on a PR.
+     * Supports pagination for PRs with many comments.
+     */
+    findExistingComment(owner: string, repo: string, prNumber: number): Promise<GitHubComment | null>;
+    /**
+     * Update an existing comment.
+     */
+    updateComment(owner: string, repo: string, commentId: number, comment: string): Promise<void>;
+    /**
+     * Delete a comment.
+     */
+    deleteComment(owner: string, repo: string, commentId: number): Promise<void>;
+    /**
+     * Create a new comment on a PR.
+     */
+    private createComment;
+    /**
+     * Get headers for GitHub API requests.
+     */
+    private getHeaders;
+    /**
+     * Fetch with retry logic for rate limiting.
+     */
+    private fetchWithRetry;
+    /**
+     * Sanitize error messages to prevent token leakage.
+     */
+    private sanitizeError;
+}

package/dist/action/integrations/GitLabIntegration.d.ts

@@ -0,0 +1,7 @@
+import { GitLabIntegration as IGitLabIntegration, GitLabConfig } from './types';
+export declare class GitLabIntegration implements IGitLabIntegration {
+    static fromEnvironment(): GitLabIntegration;
+    private config;
+    constructor(config: GitLabConfig);
+    postMergeRequestComment(projectId: string, mergeRequestIid: string, comment: string): Promise<void>;
+}

package/dist/action/integrations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { GitLabIntegration } from './GitLabIntegration';
+export { GitHubIntegration } from './GitHubIntegration';

package/dist/action/integrations/types.d.ts

@@ -0,0 +1,40 @@
+export interface GitLabIntegration {
+    postMergeRequestComment(projectId: string, mergeRequestIid: string, comment: string): Promise<void>;
+}
+export interface GitLabConfig {
+    token: string;
+    apiUrl: string;
+}
+export declare class GitLabAPIError extends Error {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * Comment strategy for GitHub PR comments
+ * - 'new': Always create a new comment
+ * - 'update': Find and update existing comment, or create new if not found
+ * - 'delete-and-new': Delete existing comment and create a new one
+ */
+export type CommentStrategy = 'new' | 'update' | 'delete-and-new';
+export interface GitHubIntegration {
+    postPRComment(owner: string, repo: string, prNumber: number, comment: string, strategy: CommentStrategy): Promise<void>;
+    findExistingComment(owner: string, repo: string, prNumber: number): Promise<GitHubComment | null>;
+    updateComment(owner: string, repo: string, commentId: number, comment: string): Promise<void>;
+    deleteComment(owner: string, repo: string, commentId: number): Promise<void>;
+}
+export interface GitHubConfig {
+    token: string;
+    apiUrl: string;
+}
+export interface GitHubComment {
+    id: number;
+    body: string;
+    user: {
+        login: string;
+        type: string;
+    };
+}
+export declare class GitHubAPIError extends Error {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}

package/dist/action/parser/TemplateParser.d.ts

@@ -0,0 +1,8 @@
+import { CloudFormationTemplate, TemplateParser as ITemplateParser } from './types';
+export declare class TemplateParseError extends Error {
+    templatePath?: string | undefined;
+    constructor(message: string, templatePath?: string | undefined);
+}
+export declare class TemplateParser implements ITemplateParser {
+    parse(content: string): CloudFormationTemplate;
+}

package/dist/action/parser/index.d.ts

@@ -0,0 +1,2 @@
+export { TemplateParser, TemplateParseError } from './TemplateParser';
+export * from './types';

package/dist/action/parser/types.d.ts

@@ -0,0 +1,30 @@
+export interface CloudFormationTemplate {
+    AWSTemplateFormatVersion?: string;
+    Description?: string;
+    Metadata?: Record<string, unknown>;
+    Parameters?: Record<string, Parameter>;
+    Resources: Record<string, Resource>;
+    Outputs?: Record<string, Output>;
+}
+export interface Resource {
+    Type: string;
+    Properties: Record<string, unknown>;
+    DependsOn?: string | string[];
+    Metadata?: Record<string, unknown>;
+}
+export interface Parameter {
+    Type: string;
+    Default?: unknown;
+    Description?: string;
+    AllowedValues?: unknown[];
+}
+export interface Output {
+    Value: unknown;
+    Description?: string;
+    Export?: {
+        Name: string;
+    };
+}
+export interface TemplateParser {
+    parse(content: string): CloudFormationTemplate;
+}

package/dist/action/pipeline/PipelineOrchestrator.d.ts

@@ -0,0 +1,23 @@
+import { PipelineOptions, PipelineResult } from './types';
+export declare class PipelineOrchestrator {
+    private configManager;
+    private synthesisOrchestrator;
+    private thresholdEnforcer;
+    constructor();
+    /**
+     * Run complete pipeline analysis
+     */
+    runPipelineAnalysis(options: PipelineOptions): Promise<PipelineResult>;
+    /**
+     * Synthesize both base and target branches
+     */
+    private synthesizeBothBranches;
+    /**
+     * Analyze costs between two templates
+     */
+    private analyzeCosts;
+    /**
+     * Build configuration summary
+     */
+    private buildConfigSummary;
+}

package/dist/action/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PipelineOrchestrator';
+export * from './types';

package/dist/action/pipeline/types.d.ts

@@ -0,0 +1,41 @@
+import { CostAnalysisResult } from '../api/types';
+import { ThresholdEvaluation } from '../threshold/types';
+export interface PipelineOptions {
+    baseTemplate?: string;
+    targetTemplate?: string;
+    baseBranch?: string;
+    targetBranch?: string;
+    cdkAppPath?: string;
+    outputPath?: string;
+    configPath?: string;
+    region?: string;
+    synthesize?: boolean;
+    environment?: string;
+}
+export interface PipelineResult {
+    costAnalysis: CostAnalysisResult;
+    thresholdStatus: ThresholdEvaluation;
+    synthesisInfo?: SynthesisInfo;
+    configUsed: ConfigSummary;
+}
+export interface SynthesisInfo {
+    baseStackCount: number;
+    targetStackCount: number;
+    baseSynthesisTime: number;
+    targetSynthesisTime: number;
+}
+export interface ConfigSummary {
+    configPath?: string;
+    thresholds?: {
+        warning?: number;
+        error?: number;
+        environment?: string;
+    };
+    usageAssumptions?: Record<string, unknown>;
+    excludedResourceTypes?: string[];
+    synthesisEnabled: boolean;
+}
+export declare class PipelineError extends Error {
+    stage: string;
+    constructor(message: string, stage: string);
+}

package/dist/action/pricing/CacheManager.d.ts

@@ -0,0 +1,75 @@
+import { PriceQueryParams } from './types';
+export interface CachedPriceEntry {
+    price: number;
+    timestamp: number;
+}
+export interface CacheMetadata {
+    entries: Record<string, CachedPriceEntry>;
+}
+/**
+ * Manages persistent caching of pricing data to reduce AWS API calls
+ * and improve performance across pipeline runs.
+ */
+export declare class CacheManager {
+    private cacheDir;
+    private cacheDurationMs;
+    private metadata;
+    private metadataPath;
+    /**
+     * Creates a new CacheManager instance
+     * @param cacheDir Directory to store cache files (default: .cdk-cost-analyzer-cache)
+     * @param cacheDurationHours Duration in hours before cache entries expire (default: 24)
+     */
+    constructor(cacheDir?: string, cacheDurationHours?: number);
+    /**
+     * Retrieves a cached price if it exists and is still fresh
+     * @param params Price query parameters
+     * @returns Cached price or null if not found or expired
+     */
+    getCachedPrice(params: PriceQueryParams): number | null;
+    /**
+     * Stores a price in the cache with current timestamp
+     * @param params Price query parameters
+     * @param price Price value to cache
+     */
+    setCachedPrice(params: PriceQueryParams, price: number): void;
+    /**
+     * Checks if a cached price exists and is still fresh
+     * @param params Price query parameters
+     * @returns true if fresh cache entry exists
+     */
+    hasFreshCache(params: PriceQueryParams): boolean;
+    /**
+     * Clears all cached entries
+     */
+    clearCache(): void;
+    /**
+     * Gets cache statistics
+     * @returns Object with cache statistics
+     */
+    getCacheStats(): {
+        totalEntries: number;
+        freshEntries: number;
+        staleEntries: number;
+    };
+    /**
+     * Removes stale cache entries
+     */
+    pruneStaleEntries(): void;
+    /**
+     * Generates a cache key from price query parameters
+     */
+    private getCacheKey;
+    /**
+     * Ensures the cache directory exists
+     */
+    private ensureCacheDirectory;
+    /**
+     * Loads cache metadata from disk
+     */
+    private loadMetadata;
+    /**
+     * Saves cache metadata to disk
+     */
+    private saveMetadata;
+}

package/dist/action/pricing/PricingClient.d.ts

@@ -0,0 +1,17 @@
+import { PricingClient as AWSPricingClient } from '@aws-sdk/client-pricing';
+import { CacheManager } from './CacheManager';
+import { PricingClient as IPricingClient, PriceQueryParams } from './types';
+export declare class PricingClient implements IPricingClient {
+    private cache;
+    private client;
+    private cacheManager?;
+    constructor(region?: string, cacheManager?: CacheManager, awsClient?: AWSPricingClient);
+    /**
+     * Clean up resources and connections
+     */
+    destroy(): void;
+    getPrice(params: PriceQueryParams): Promise<number | null>;
+    private fetchPriceWithRetry;
+    private fetchPrice;
+    private getCacheKey;
+}

package/dist/action/pricing/PricingService.d.ts

@@ -0,0 +1,16 @@
+import { PricingClient } from './PricingClient';
+import { PricingService as IPricingService, MonthlyCost, CostDelta } from './types';
+import { UsageAssumptionsConfig, CacheConfig } from '../config/types';
+import { ResourceWithId, ResourceDiff } from '../diff/types';
+export declare class PricingService implements IPricingService {
+    private calculators;
+    private pricingClient;
+    private excludedResourceTypes;
+    constructor(region?: string, usageAssumptions?: UsageAssumptionsConfig, excludedResourceTypes?: string[], cacheConfig?: CacheConfig, pricingClient?: PricingClient);
+    getResourceCost(resource: ResourceWithId, region: string, templateResources?: ResourceWithId[]): Promise<MonthlyCost>;
+    getCostDelta(diff: ResourceDiff, region: string): Promise<CostDelta>;
+    /**
+     * Clean up resources and connections
+     */
+    destroy(): void;
+}

package/dist/action/pricing/RegionMapper.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Normalize AWS region code to Pricing API region name
+ * Logs the normalization step when debug mode is enabled
+ */
+export declare function normalizeRegion(region: string): string;
+/**
+ * Get the AWS region prefix for pricing usagetype values.
+ * AWS uses region prefixes in usagetype values (e.g., USE1-ApiGatewayRequest).
+ * Reference: https://docs.aws.amazon.com/global-infrastructure/latest/regions/aws-region-billing-codes.html
+ *
+ * @param region - AWS region code (e.g., 'us-east-1', 'eu-west-1')
+ * @returns The usagetype prefix for the region, or empty string for unknown regions
+ */
+export declare function getRegionPrefix(region: string): string;

package/dist/action/pricing/calculators/ALBCalculator.d.ts

@@ -0,0 +1,15 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class ALBCalculator implements ResourceCostCalculator {
+    private customNewConnectionsPerSecond?;
+    private customActiveConnectionsPerMinute?;
+    private customProcessedBytesGB?;
+    private readonly DEFAULT_NEW_CONNECTIONS_PER_SECOND;
+    private readonly DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;
+    private readonly DEFAULT_PROCESSED_BYTES_GB;
+    private readonly HOURS_PER_MONTH;
+    constructor(customNewConnectionsPerSecond?: number | undefined, customActiveConnectionsPerMinute?: number | undefined, customProcessedBytesGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    canCalculate(resource: ResourceWithId): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/APIGatewayCalculator.d.ts

@@ -0,0 +1,9 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class APIGatewayCalculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateRestApiCost;
+    private calculateHttpApiCost;
+    private calculateWebSocketCost;
+}

package/dist/action/pricing/calculators/AutoScalingGroupCalculator.d.ts

@@ -0,0 +1,9 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class AutoScalingGroupCalculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient, templateResources?: ResourceWithId[]): Promise<MonthlyCost>;
+    private resolveInstanceType;
+    private resolveInstanceTypeFromLaunchTemplate;
+    private resolveReference;
+}

package/dist/action/pricing/calculators/CloudFrontCalculator.d.ts

@@ -0,0 +1,49 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Calculator for AWS CloudFront distribution costs.
+ *
+ * Estimates monthly costs based on data transfer and request volumes.
+ * CloudFront pricing includes:
+ * - Data transfer out to internet (per GB)
+ * - HTTP/HTTPS requests (per 10,000 requests)
+ *
+ * @see https://aws.amazon.com/cloudfront/pricing/
+ */
+export declare class CloudFrontCalculator implements ResourceCostCalculator {
+    private readonly dataTransferGB?;
+    private readonly requests?;
+    private readonly DEFAULT_DATA_TRANSFER_GB;
+    private readonly DEFAULT_REQUESTS;
+    /**
+     * Creates a CloudFront cost calculator.
+     *
+     * @param dataTransferGB - Optional custom data transfer volume in GB per month
+     * @param requests - Optional custom request count per month
+     */
+    constructor(dataTransferGB?: number | undefined, requests?: number | undefined);
+    /**
+     * Checks if this calculator supports the given resource type.
+     *
+     * @param resourceType - CloudFormation resource type
+     * @returns true if resource type is AWS::CloudFront::Distribution
+     */
+    supports(resourceType: string): boolean;
+    /**
+     * Calculates monthly cost for a CloudFront distribution.
+     *
+     * Cost components:
+     * - Data transfer out to internet (based on volume in GB)
+     * - HTTP/HTTPS requests (per 10,000 requests)
+     *
+     * Default assumptions:
+     * - 100 GB data transfer per month
+     * - 1,000,000 requests per month
+     *
+     * @param _resource - CloudFormation resource (properties not used for CloudFront)
+     * @param region - AWS region for pricing (CloudFront is global but pricing varies by region)
+     * @param pricingClient - Client for querying AWS Pricing API
+     * @returns Monthly cost estimate with assumptions and confidence level
+     */
+    calculateCost(_resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/DynamoDBCalculator.d.ts

@@ -0,0 +1,12 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+import { CostAnalyzerConfig } from '../../config/types';
+export declare class DynamoDBCalculator implements ResourceCostCalculator {
+    private config?;
+    constructor(config?: CostAnalyzerConfig);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private getUsageAssumptions;
+    private calculateOnDemandCost;
+    private calculateProvisionedCost;
+}

package/dist/action/pricing/calculators/EC2Calculator.d.ts

@@ -0,0 +1,6 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class EC2Calculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/ECSCalculator.d.ts

@@ -0,0 +1,8 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class ECSCalculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private calculateFargateCost;
+    private calculateEC2Cost;
+}

package/dist/action/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/action/pricing/calculators/ElastiCacheCalculator.d.ts

@@ -0,0 +1,7 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class ElastiCacheCalculator implements ResourceCostCalculator {
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private normalizeEngine;
+}

package/dist/action/pricing/calculators/LambdaCalculator.d.ts

@@ -0,0 +1,14 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class LambdaCalculator implements ResourceCostCalculator {
+    private readonly customInvocationsPerMonth?;
+    private readonly customAverageDurationMs?;
+    private readonly DEFAULT_INVOCATIONS;
+    private readonly DEFAULT_DURATION_MS;
+    private readonly DEFAULT_MEMORY_MB;
+    private readonly FALLBACK_REQUEST_PRICE;
+    private readonly FALLBACK_COMPUTE_PRICE;
+    constructor(customInvocationsPerMonth?: number | undefined, customAverageDurationMs?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/LaunchTemplateCalculator.d.ts

@@ -0,0 +1,35 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Configuration extracted from a LaunchTemplate's LaunchTemplateData.
+ * This interface can be used by other calculators (e.g., AutoScalingGroupCalculator)
+ * to reference instance configuration.
+ */
+export interface LaunchTemplateConfig {
+    instanceType: string | null;
+    imageId: string | null;
+    ebsVolumes: EbsVolumeConfig[];
+}
+export interface EbsVolumeConfig {
+    deviceName: string;
+    volumeType: string;
+    volumeSizeGB: number;
+    iops?: number;
+    throughput?: number;
+    deleteOnTermination: boolean;
+}
+export declare class LaunchTemplateCalculator implements ResourceCostCalculator {
+    private static readonly DEFAULT_VOLUME_SIZE_GB;
+    private static readonly DEFAULT_VOLUME_TYPE;
+    private static readonly MONTHLY_HOURS;
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    /**
+     * Extract configuration from a LaunchTemplate resource.
+     * This method is public to allow other calculators to use it.
+     */
+    extractConfig(resource: ResourceWithId): LaunchTemplateConfig;
+    private extractEbsVolumes;
+    private calculateInstanceCost;
+    private calculateStorageCost;
+}

package/dist/action/pricing/calculators/NLBCalculator.d.ts

@@ -0,0 +1,15 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class NLBCalculator implements ResourceCostCalculator {
+    private customNewConnectionsPerSecond?;
+    private customActiveConnectionsPerMinute?;
+    private customProcessedBytesGB?;
+    private readonly DEFAULT_NEW_CONNECTIONS_PER_SECOND;
+    private readonly DEFAULT_ACTIVE_CONNECTIONS_PER_MINUTE;
+    private readonly DEFAULT_PROCESSED_BYTES_GB;
+    private readonly HOURS_PER_MONTH;
+    constructor(customNewConnectionsPerSecond?: number | undefined, customActiveConnectionsPerMinute?: number | undefined, customProcessedBytesGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    canCalculate(resource: ResourceWithId): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/NatGatewayCalculator.d.ts

@@ -0,0 +1,10 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class NatGatewayCalculator implements ResourceCostCalculator {
+    private customDataProcessedGB?;
+    private readonly DEFAULT_DATA_PROCESSED_GB;
+    private readonly HOURS_PER_MONTH;
+    constructor(customDataProcessedGB?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(_resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/RDSCalculator.d.ts

@@ -0,0 +1,8 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class RDSCalculator implements ResourceCostCalculator {
+    private readonly DEFAULT_STORAGE_GB;
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private normalizeEngine;
+}

package/dist/action/pricing/calculators/S3Calculator.d.ts

@@ -0,0 +1,7 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+export declare class S3Calculator implements ResourceCostCalculator {
+    private readonly DEFAULT_STORAGE_GB;
+    supports(resourceType: string): boolean;
+    calculateCost(_resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+}

package/dist/action/pricing/calculators/SNSCalculator.d.ts

@@ -0,0 +1,54 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCostCalculator, MonthlyCost, PricingClient } from '../types';
+/**
+ * Cost breakdown for SNS pricing components
+ */
+export interface SNSCostBreakdown {
+    publishCost: number;
+    httpDeliveryCost: number;
+    emailDeliveryCost: number;
+    smsDeliveryCost: number;
+    mobilePushDeliveryCost: number;
+    totalCost: number;
+}
+/**
+ * Calculator for AWS::SNS::Topic resources.
+ *
+ * SNS Pricing Model (as of 2024):
+ * - Publishes: $0.50 per million requests (first 1M free)
+ * - HTTP/S deliveries: $0.60 per million
+ * - Email deliveries: $2.00 per 100,000
+ * - SMS: Varies by country (using US rate as default)
+ * - Mobile push: $0.50 per million
+ *
+ * @see https://aws.amazon.com/sns/pricing/
+ */
+export declare class SNSCalculator implements ResourceCostCalculator {
+    private readonly customMonthlyPublishes?;
+    private readonly customHttpDeliveries?;
+    private readonly customEmailDeliveries?;
+    private readonly customSmsDeliveries?;
+    private readonly customMobilePushDeliveries?;
+    private readonly DEFAULT_MONTHLY_PUBLISHES;
+    private readonly DEFAULT_HTTP_DELIVERIES;
+    private readonly DEFAULT_EMAIL_DELIVERIES;
+    private readonly DEFAULT_SMS_DELIVERIES;
+    private readonly DEFAULT_MOBILE_PUSH_DELIVERIES;
+    private readonly FALLBACK_PUBLISH_PRICE_PER_MILLION;
+    private readonly FALLBACK_HTTP_DELIVERY_PRICE_PER_MILLION;
+    private readonly FALLBACK_EMAIL_DELIVERY_PRICE_PER_100K;
+    private readonly FALLBACK_SMS_PRICE_PER_MESSAGE;
+    private readonly FALLBACK_MOBILE_PUSH_PRICE_PER_MILLION;
+    private readonly FREE_TIER_PUBLISHES;
+    constructor(customMonthlyPublishes?: number | undefined, customHttpDeliveries?: number | undefined, customEmailDeliveries?: number | undefined, customSmsDeliveries?: number | undefined, customMobilePushDeliveries?: number | undefined);
+    supports(resourceType: string): boolean;
+    calculateCost(resource: ResourceWithId, region: string, pricingClient: PricingClient): Promise<MonthlyCost>;
+    private getPublishPrice;
+    private getHttpDeliveryPrice;
+    private getEmailDeliveryPrice;
+    private getSmsPrice;
+    private getMobilePushPrice;
+    private calculateCostBreakdown;
+    private buildAssumptions;
+    private hasCustomAssumptions;
+}