cloud-cost-cli 0.1.1 → 0.2.0

package/dist/src/analyzers/pricing-service.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingService = void 0;
+exports.getS3MonthlyCost = getS3MonthlyCost;
+exports.getELBMonthlyCost = getELBMonthlyCost;
+exports.getEIPMonthlyCost = getEIPMonthlyCost;
+const client_pricing_1 = require("@aws-sdk/client-pricing");
+// Cache for pricing data to avoid repeated API calls
+const pricingCache = new Map();
+class PricingService {
+    pricingClient;
+    region;
+    constructor(region = 'us-east-1') {
+        this.region = region;
+        // Pricing API is only available in us-east-1 and ap-south-1
+        this.pricingClient = new client_pricing_1.PricingClient({ region: 'us-east-1' });
+    }
+    /**
+     * Get EC2 instance on-demand pricing for the configured region
+     */
+    async getEC2Price(instanceType) {
+        const cacheKey = `ec2-${this.region}-${instanceType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'tenancy',
+                        Value: 'Shared',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'operatingSystem',
+                        Value: 'Linux',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'preInstalledSw',
+                        Value: 'NA',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'capacitystatus',
+                        Value: 'Used',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730; // 730 hours per month
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            // Fallback to estimate if API fails
+            return this.getFallbackEC2Price(instanceType);
+        }
+    }
+    /**
+     * Get EBS volume pricing per GB
+     */
+    async getEBSPrice(volumeType) {
+        const cacheKey = `ebs-${this.region}-${volumeType}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonEC2',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'productFamily',
+                        Value: 'Storage',
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'volumeApiName',
+                        Value: volumeType,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const pricePerGB = this.extractPriceFromResponse(response.PriceList);
+            pricingCache.set(cacheKey, pricePerGB);
+            return pricePerGB;
+        }
+        catch (error) {
+            return this.getFallbackEBSPrice(volumeType);
+        }
+    }
+    /**
+     * Get RDS instance pricing
+     */
+    async getRDSPrice(instanceClass, engine = 'mysql') {
+        const cacheKey = `rds-${this.region}-${instanceClass}-${engine}`;
+        if (pricingCache.has(cacheKey)) {
+            return pricingCache.get(cacheKey);
+        }
+        try {
+            const response = await this.pricingClient.send(new client_pricing_1.GetProductsCommand({
+                ServiceCode: 'AmazonRDS',
+                Filters: [
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'instanceType',
+                        Value: instanceClass,
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'location',
+                        Value: this.getLocationName(this.region),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'databaseEngine',
+                        Value: this.normalizeEngine(engine),
+                    },
+                    {
+                        Type: 'TERM_MATCH',
+                        Field: 'deploymentOption',
+                        Value: 'Single-AZ',
+                    },
+                ],
+                MaxResults: 1,
+            }));
+            const hourlyPrice = this.extractPriceFromResponse(response.PriceList);
+            const monthlyPrice = hourlyPrice * 730;
+            pricingCache.set(cacheKey, monthlyPrice);
+            return monthlyPrice;
+        }
+        catch (error) {
+            return this.getFallbackRDSPrice(instanceClass);
+        }
+    }
+    /**
+     * Extract price from AWS Pricing API response
+     */
+    extractPriceFromResponse(priceList) {
+        if (!priceList || priceList.length === 0) {
+            return 0;
+        }
+        try {
+            const product = JSON.parse(priceList[0]);
+            const terms = product.terms?.OnDemand;
+            if (!terms)
+                return 0;
+            const termKey = Object.keys(terms)[0];
+            const priceDimensions = terms[termKey]?.priceDimensions;
+            if (!priceDimensions)
+                return 0;
+            const dimensionKey = Object.keys(priceDimensions)[0];
+            const pricePerUnit = priceDimensions[dimensionKey]?.pricePerUnit?.USD;
+            return parseFloat(pricePerUnit || '0');
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    /**
+     * Convert AWS region code to location name used in Pricing API
+     */
+    getLocationName(region) {
+        const locationMap = {
+            'us-east-1': 'US East (N. Virginia)',
+            'us-east-2': 'US East (Ohio)',
+            'us-west-1': 'US West (N. California)',
+            'us-west-2': 'US West (Oregon)',
+            'eu-west-1': 'EU (Ireland)',
+            'eu-central-1': 'EU (Frankfurt)',
+            'ap-southeast-1': 'Asia Pacific (Singapore)',
+            'ap-southeast-2': 'Asia Pacific (Sydney)',
+            'ap-northeast-1': 'Asia Pacific (Tokyo)',
+            // Add more as needed
+        };
+        return locationMap[region] || 'US East (N. Virginia)';
+    }
+    /**
+     * Normalize RDS engine name for Pricing API
+     */
+    normalizeEngine(engine) {
+        const engineMap = {
+            'mysql': 'MySQL',
+            'postgres': 'PostgreSQL',
+            'mariadb': 'MariaDB',
+            'aurora': 'Aurora MySQL',
+            'aurora-mysql': 'Aurora MySQL',
+            'aurora-postgresql': 'Aurora PostgreSQL',
+        };
+        return engineMap[engine.toLowerCase()] || 'MySQL';
+    }
+    /**
+     * Fallback estimates when API calls fail (based on us-east-1)
+     */
+    getFallbackEC2Price(instanceType) {
+        const estimates = {
+            't3.micro': 7.59,
+            't3.small': 15.18,
+            't3.medium': 30.37,
+            't3.large': 60.74,
+            'm5.large': 70.08,
+            'm5.xlarge': 140.16,
+        };
+        return estimates[instanceType] || 50; // Generic estimate
+    }
+    getFallbackEBSPrice(volumeType) {
+        const estimates = {
+            'gp3': 0.08,
+            'gp2': 0.10,
+            'io1': 0.125,
+            'io2': 0.125,
+        };
+        return estimates[volumeType] || 0.08;
+    }
+    getFallbackRDSPrice(instanceClass) {
+        const estimates = {
+            'db.t3.micro': 11.01,
+            'db.t3.small': 22.63,
+            'db.t3.medium': 45.26,
+            'db.t3.large': 90.51,
+        };
+        return estimates[instanceClass] || 100;
+    }
+}
+exports.PricingService = PricingService;
+// Simple estimates for services where Pricing API is complex (S3, ELB, EIP)
+function getS3MonthlyCost(sizeGB, storageClass = 'standard') {
+    const pricing = {
+        'STANDARD': 0.023,
+        'INTELLIGENT_TIERING': 0.023,
+        'GLACIER': 0.004,
+        'DEEP_ARCHIVE': 0.00099,
+    };
+    const pricePerGB = pricing[storageClass] || 0.023;
+    return sizeGB * pricePerGB;
+}
+function getELBMonthlyCost(type = 'alb') {
+    // ELB pricing is relatively consistent across regions (~$16-18/month base)
+    return type === 'clb' ? 18.25 : 16.43;
+}
+function getEIPMonthlyCost() {
+    // ~$3.65/month when unattached (consistent across regions)
+    return 3.65;
+}

package/dist/src/commands/scan.d.ts

@@ -2,11 +2,14 @@ interface ScanCommandOptions {
     provider: string;
     region?: string;
     profile?: string;
+    subscriptionId?: string;
+    location?: string;
     top?: string;
     output?: string;
     days?: string;
     minSavings?: string;
     verbose?: boolean;
+    accurate?: boolean;
 }
 export declare function scanCommand(options: ScanCommandOptions): Promise<void>;
 export {};

package/dist/src/commands/scan.js

@@ -8,104 +8,191 @@ const rds_1 = require("../providers/aws/rds");
 const s3_1 = require("../providers/aws/s3");
 const elb_1 = require("../providers/aws/elb");
 const eip_1 = require("../providers/aws/eip");
+const client_2 = require("../providers/azure/client");
+const vms_1 = require("../providers/azure/vms");
+const disks_1 = require("../providers/azure/disks");
+const storage_1 = require("../providers/azure/storage");
+const sql_1 = require("../providers/azure/sql");
+const public_ips_1 = require("../providers/azure/public-ips");
 const table_1 = require("../reporters/table");
 const json_1 = require("../reporters/json");
 const logger_1 = require("../utils/logger");
 async function scanCommand(options) {
     try {
-        if (options.provider !== 'aws') {
-            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws`);
-            process.exit(1);
+        if (options.provider === 'aws') {
+            await scanAWS(options);
         }
-        const client = new client_1.AWSClient({
-            region: options.region,
-            profile: options.profile,
-        });
-        (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${client.region})...`);
-        // Run analyzers in parallel
-        (0, logger_1.info)('Analyzing EC2 instances...');
-        const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
-        (0, logger_1.info)('Analyzing EBS volumes...');
-        const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
-        (0, logger_1.info)('Analyzing RDS instances...');
-        const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
-        (0, logger_1.info)('Analyzing S3 buckets...');
-        const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
-        (0, logger_1.info)('Analyzing Load Balancers...');
-        const elbPromise = (0, elb_1.analyzeELBs)(client);
-        (0, logger_1.info)('Analyzing Elastic IPs...');
-        const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
-        // Wait for all analyzers to complete
-        const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
-            ec2Promise,
-            ebsPromise,
-            rdsPromise,
-            s3Promise,
-            elbPromise,
-            eipPromise,
-        ]);
-        (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
-        (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
-        (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
-        (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
-        (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
-        (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
-        // Combine opportunities
-        const allOpportunities = [
-            ...ec2Opportunities,
-            ...ebsOpportunities,
-            ...rdsOpportunities,
-            ...s3Opportunities,
-            ...elbOpportunities,
-            ...eipOpportunities,
-        ];
-        // Filter by minimum savings if specified
-        const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
-        const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
-        // Calculate totals
-        const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
-        const summary = {
-            totalResources: filteredOpportunities.length,
-            idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
-            oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
-            unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
-        };
-        const report = {
-            provider: 'aws',
-            accountId: 'N/A', // Will fetch from STS in future
-            region: client.region,
-            scanPeriod: {
-                start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
-                end: new Date(),
-            },
-            opportunities: filteredOpportunities,
-            totalPotentialSavings,
-            summary,
-        };
-        // Render output
-        const topN = parseInt(options.top || '5');
-        if (options.output === 'json') {
-            (0, json_1.renderJSON)(report);
+        else if (options.provider === 'azure') {
+            await scanAzure(options);
         }
         else {
-            (0, table_1.renderTable)(report, topN);
+            (0, logger_1.error)(`Provider "${options.provider}" not yet supported. Use --provider aws or --provider azure`);
+            process.exit(1);
         }
     }
     catch (err) {
-        if (err.name === 'CredentialsProviderError' || err.message?.includes('credentials')) {
-            (0, logger_1.error)('AWS credentials not found or invalid.');
-            console.log('\nTo configure AWS credentials:');
-            console.log('1. Run: aws configure');
-            console.log('2. Or set environment variables: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY');
-            console.log('3. Or use --profile flag with a configured profile');
-            console.log('\nSee: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html');
-        }
-        else {
-            (0, logger_1.error)(`Scan failed: ${err.message}`);
-            if (options.verbose) {
-                console.error(err);
-            }
+        (0, logger_1.error)(`Scan failed: ${err.message}`);
+        if (options.verbose) {
+            console.error(err);
         }
         process.exit(1);
     }
 }
+async function scanAWS(options) {
+    const client = new client_1.AWSClient({
+        region: options.region,
+        profile: options.profile,
+    });
+    (0, logger_1.info)(`Scanning AWS account (profile: ${options.profile || 'default'}, region: ${client.region})...`);
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+        (0, logger_1.info)('Real-time pricing will be available in a future release.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing EC2 instances...');
+    const ec2Promise = (0, ec2_1.analyzeEC2Instances)(client);
+    (0, logger_1.info)('Analyzing EBS volumes...');
+    const ebsPromise = (0, ebs_1.analyzeEBSVolumes)(client);
+    (0, logger_1.info)('Analyzing RDS instances...');
+    const rdsPromise = (0, rds_1.analyzeRDSInstances)(client);
+    (0, logger_1.info)('Analyzing S3 buckets...');
+    const s3Promise = (0, s3_1.analyzeS3Buckets)(client);
+    (0, logger_1.info)('Analyzing Load Balancers...');
+    const elbPromise = (0, elb_1.analyzeELBs)(client);
+    (0, logger_1.info)('Analyzing Elastic IPs...');
+    const eipPromise = (0, eip_1.analyzeElasticIPs)(client);
+    // Wait for all analyzers to complete
+    const [ec2Opportunities, ebsOpportunities, rdsOpportunities, s3Opportunities, elbOpportunities, eipOpportunities,] = await Promise.all([
+        ec2Promise,
+        ebsPromise,
+        rdsPromise,
+        s3Promise,
+        elbPromise,
+        eipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${ec2Opportunities.length} EC2 opportunities`);
+    (0, logger_1.success)(`Found ${ebsOpportunities.length} EBS opportunities`);
+    (0, logger_1.success)(`Found ${rdsOpportunities.length} RDS opportunities`);
+    (0, logger_1.success)(`Found ${s3Opportunities.length} S3 opportunities`);
+    (0, logger_1.success)(`Found ${elbOpportunities.length} ELB opportunities`);
+    (0, logger_1.success)(`Found ${eipOpportunities.length} EIP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...ec2Opportunities,
+        ...ebsOpportunities,
+        ...rdsOpportunities,
+        ...s3Opportunities,
+        ...elbOpportunities,
+        ...eipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'aws',
+        accountId: 'N/A', // Will fetch from STS in future
+        region: client.region,
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '30') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        (0, table_1.renderTable)(report, topN);
+    }
+}
+async function scanAzure(options) {
+    const client = new client_2.AzureClient({
+        subscriptionId: options.subscriptionId,
+        location: options.location,
+    });
+    (0, logger_1.info)(`Scanning Azure subscription (${client.subscriptionId})...`);
+    if (client.location) {
+        (0, logger_1.info)(`Filtering resources by location: ${client.location}`);
+    }
+    else {
+        (0, logger_1.info)('Scanning all locations (no filter specified)');
+    }
+    if (options.accurate) {
+        (0, logger_1.info)('Note: --accurate flag is not yet implemented. Using estimated pricing.');
+    }
+    // Run analyzers in parallel
+    (0, logger_1.info)('Analyzing Virtual Machines...');
+    const vmPromise = (0, vms_1.analyzeAzureVMs)(client);
+    (0, logger_1.info)('Analyzing Managed Disks...');
+    const diskPromise = (0, disks_1.analyzeAzureDisks)(client);
+    (0, logger_1.info)('Analyzing Storage Accounts...');
+    const storagePromise = (0, storage_1.analyzeAzureStorage)(client);
+    (0, logger_1.info)('Analyzing SQL Databases...');
+    const sqlPromise = (0, sql_1.analyzeAzureSQL)(client);
+    (0, logger_1.info)('Analyzing Public IP Addresses...');
+    const ipPromise = (0, public_ips_1.analyzeAzurePublicIPs)(client);
+    // Wait for all analyzers to complete
+    const [vmOpportunities, diskOpportunities, storageOpportunities, sqlOpportunities, ipOpportunities,] = await Promise.all([
+        vmPromise,
+        diskPromise,
+        storagePromise,
+        sqlPromise,
+        ipPromise,
+    ]);
+    (0, logger_1.success)(`Found ${vmOpportunities.length} VM opportunities`);
+    (0, logger_1.success)(`Found ${diskOpportunities.length} Disk opportunities`);
+    (0, logger_1.success)(`Found ${storageOpportunities.length} Storage opportunities`);
+    (0, logger_1.success)(`Found ${sqlOpportunities.length} SQL opportunities`);
+    (0, logger_1.success)(`Found ${ipOpportunities.length} Public IP opportunities`);
+    // Combine opportunities
+    const allOpportunities = [
+        ...vmOpportunities,
+        ...diskOpportunities,
+        ...storageOpportunities,
+        ...sqlOpportunities,
+        ...ipOpportunities,
+    ];
+    // Filter by minimum savings if specified
+    const minSavings = options.minSavings ? parseFloat(options.minSavings) : 0;
+    const filteredOpportunities = allOpportunities.filter((opp) => opp.estimatedSavings >= minSavings);
+    // Calculate totals
+    const totalPotentialSavings = filteredOpportunities.reduce((sum, opp) => sum + opp.estimatedSavings, 0);
+    const summary = {
+        totalResources: filteredOpportunities.length,
+        idleResources: filteredOpportunities.filter((o) => o.category === 'idle').length,
+        oversizedResources: filteredOpportunities.filter((o) => o.category === 'oversized').length,
+        unusedResources: filteredOpportunities.filter((o) => o.category === 'unused').length,
+    };
+    const report = {
+        provider: 'azure',
+        accountId: client.subscriptionId,
+        region: client.location || 'all',
+        scanPeriod: {
+            start: new Date(Date.now() - (parseInt(options.days || '7') * 24 * 60 * 60 * 1000)),
+            end: new Date(),
+        },
+        opportunities: filteredOpportunities,
+        totalPotentialSavings,
+        summary,
+    };
+    // Render output
+    const topN = parseInt(options.top || '5');
+    if (options.output === 'json') {
+        (0, json_1.renderJSON)(report);
+    }
+    else {
+        (0, table_1.renderTable)(report, topN);
+    }
+}

package/dist/src/providers/azure/client.d.ts

@@ -0,0 +1,20 @@
+import { ComputeManagementClient } from '@azure/arm-compute';
+import { StorageManagementClient } from '@azure/arm-storage';
+import { SqlManagementClient } from '@azure/arm-sql';
+import { NetworkManagementClient } from '@azure/arm-network';
+import { MonitorClient } from '@azure/arm-monitor';
+export interface AzureClientConfig {
+    subscriptionId?: string;
+    location?: string;
+}
+export declare class AzureClient {
+    private credential;
+    subscriptionId: string;
+    location: string;
+    constructor(config?: AzureClientConfig);
+    getComputeClient(): ComputeManagementClient;
+    getStorageClient(): StorageManagementClient;
+    getSqlClient(): SqlManagementClient;
+    getNetworkClient(): NetworkManagementClient;
+    getMonitorClient(): MonitorClient;
+}

package/dist/src/providers/azure/client.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureClient = void 0;
+const identity_1 = require("@azure/identity");
+const arm_compute_1 = require("@azure/arm-compute");
+const arm_storage_1 = require("@azure/arm-storage");
+const arm_sql_1 = require("@azure/arm-sql");
+const arm_network_1 = require("@azure/arm-network");
+const arm_monitor_1 = require("@azure/arm-monitor");
+class AzureClient {
+    credential;
+    subscriptionId;
+    location;
+    constructor(config = {}) {
+        // Use Azure SDK's default credential chain (env vars, CLI, managed identity)
+        this.credential = new identity_1.DefaultAzureCredential();
+        // Get subscription ID from env or config
+        this.subscriptionId = config.subscriptionId || process.env.AZURE_SUBSCRIPTION_ID || '';
+        if (!this.subscriptionId) {
+            throw new Error('Azure subscription ID not found. Set AZURE_SUBSCRIPTION_ID environment variable or use --subscription-id flag.');
+        }
+        // Default to East US if no location specified
+        this.location = config.location || '';
+    }
+    getComputeClient() {
+        return new arm_compute_1.ComputeManagementClient(this.credential, this.subscriptionId);
+    }
+    getStorageClient() {
+        return new arm_storage_1.StorageManagementClient(this.credential, this.subscriptionId);
+    }
+    getSqlClient() {
+        return new arm_sql_1.SqlManagementClient(this.credential, this.subscriptionId);
+    }
+    getNetworkClient() {
+        return new arm_network_1.NetworkManagementClient(this.credential, this.subscriptionId);
+    }
+    getMonitorClient() {
+        return new arm_monitor_1.MonitorClient(this.credential, this.subscriptionId);
+    }
+}
+exports.AzureClient = AzureClient;

package/dist/src/providers/azure/disks.d.ts

@@ -0,0 +1,4 @@
+import { AzureClient } from './client';
+import { SavingsOpportunity } from '../../types/opportunity';
+export declare const AZURE_DISK_PRICING: Record<string, number>;
+export declare function analyzeAzureDisks(client: AzureClient): Promise<SavingsOpportunity[]>;