Global Data Sources

/**
 * Get information about the AWS caller identity
 * @param args - Optional arguments (none currently supported)
 * @returns Promise resolving to caller identity details
 */
function getCallerIdentity(args?: GetCallerIdentityArgs): Promise<GetCallerIdentityResult>;
function getCallerIdentityOutput(args?: GetCallerIdentityOutputArgs): pulumi.Output<GetCallerIdentityResult>;

interface GetCallerIdentityArgs {
    // No arguments currently supported
}

interface GetCallerIdentityResult {
    /** AWS account ID (12-digit number) */
    readonly accountId: string;
    /** ARN of the calling identity (user, role, or federated user) */
    readonly arn: string;
    /** Internal AWS ID string */
    readonly id: string;
    /** Unique identifier of the calling identity */
    readonly userId: string;
}

import * as aws from "@pulumi/aws";

// Get current identity
const identity = await aws.getCallerIdentity();
console.log(`Account ID: ${identity.accountId}`);
console.log(`User ARN: ${identity.arn}`);

// Use in resource configuration
const bucket = new aws.s3.Bucket("account-bucket", {
    bucket: `my-bucket-${identity.accountId}`
});

/**
 * Get information about the current AWS region
 * @param args - Optional region selection arguments
 * @returns Promise resolving to region details
 */
function getRegion(args?: GetRegionArgs): Promise<GetRegionResult>;
function getRegionOutput(args?: GetRegionOutputArgs): pulumi.Output<GetRegionResult>; 

interface GetRegionArgs {
    /** Specific region name to query (defaults to current region) */
    name?: string;
}

interface GetRegionResult {
    /** Region description */
    readonly description: string;
    /** Region endpoint URL */
    readonly endpoint: string; 
    /** Internal AWS region ID */
    readonly id: string;
    /** Region name (e.g., "us-west-2") */
    readonly name: string;
}

/**
 * Get list of all available AWS regions
 * @param args - Optional filtering arguments
 * @returns Promise resolving to list of regions
 */
function getRegions(args?: GetRegionsArgs): Promise<GetRegionsResult>;
function getRegionsOutput(args?: GetRegionsOutputArgs): pulumi.Output<GetRegionsResult>;

interface GetRegionsArgs {
    /** Include all regions regardless of opt-in status */
    allRegions?: boolean;
    /** Filter regions by name patterns */
    filters?: GetRegionsFilter[];
}

interface GetRegionsFilter {
    /** Filter name (e.g., "region-name", "opt-in-status") */
    name: string;
    /** Filter values */
    values: string[];
}

interface GetRegionsResult {
    /** List of region names */
    readonly names: string[];
}

/**
 * Get information about a specific availability zone
 * @param args - AZ selection arguments  
 * @returns Promise resolving to AZ details
 */
function getAvailabilityZone(args: GetAvailabilityZoneArgs): Promise<GetAvailabilityZoneResult>;
function getAvailabilityZoneOutput(args: GetAvailabilityZoneOutputArgs): pulumi.Output<GetAvailabilityZoneResult>;

interface GetAvailabilityZoneArgs {
    /** Filter conditions for AZ selection */
    filters?: GetAvailabilityZoneFilter[];
    /** Specific AZ name to query */
    name?: string;
    /** Specific AZ ID to query */
    zoneId?: string;
}

interface GetAvailabilityZoneFilter {
    /** Filter name (e.g., "zone-name", "state") */
    name: string;
    /** Filter values */
    values: string[];
}

interface GetAvailabilityZoneResult {
    /** Group name for the AZ */
    readonly groupName: string;
    /** Internal AWS AZ ID */
    readonly id: string;
    /** AZ name (e.g., "us-west-2a") */
    readonly name: string;
    /** Network border group */
    readonly networkBorderGroup: string;
    /** AWS region name */
    readonly region: string;
    /** AZ state (available, impaired, unavailable) */
    readonly state: string;
    /** Unique AZ identifier */
    readonly zoneId: string;
}

/**
 * Get list of availability zones in the current region
 * @param args - Optional filtering arguments
 * @returns Promise resolving to list of AZs
 */
function getAvailabilityZones(args?: GetAvailabilityZonesArgs): Promise<GetAvailabilityZonesResult>;
function getAvailabilityZonesOutput(args?: GetAvailabilityZonesOutputArgs): pulumi.Output<GetAvailabilityZonesResult>;

interface GetAvailabilityZonesArgs {
    /** Include all AZs regardless of state */
    allAvailabilityZones?: boolean;
    /** Exclude specific AZ names */
    excludeNames?: string[];
    /** Exclude specific AZ IDs */
    excludeZoneIds?: string[];
    /** Filter conditions */
    filters?: GetAvailabilityZonesFilter[];
    /** Include only specific AZ names */
    names?: string[];
    /** Include only AZs in this state */
    state?: string;
    /** Include only specific AZ IDs */
    zoneIds?: string[];
}

interface GetAvailabilityZonesResult {
    /** Group names for the AZs */
    readonly groupNames: string[];
    /** Internal AWS IDs */
    readonly id: string;
    /** AZ names */
    readonly names: string[];
    /** Unique AZ identifiers */
    readonly zoneIds: string[];
}

// Get all AZs in current region
const azs = await aws.getAvailabilityZones({ state: "available" });

// Create subnets across multiple AZs
const subnets = azs.names.map((az, index) => 
    new aws.ec2.Subnet(`subnet-${index}`, {
        vpcId: vpc.id,
        availabilityZone: az,
        cidrBlock: `10.0.${index}.0/24`
    })
);

// Get specific AZ information
const az = await aws.getAvailabilityZone({ name: "us-west-2a" });
console.log(`AZ ID: ${az.zoneId}`);

/**
 * Get AWS partition information
 * @param args - Optional partition arguments
 * @returns Promise resolving to partition details
 */
function getPartition(args?: GetPartitionArgs): Promise<GetPartitionResult>;
function getPartitionOutput(args?: GetPartitionOutputArgs): pulumi.Output<GetPartitionResult>;

interface GetPartitionArgs {
    // No arguments currently supported
}

interface GetPartitionResult {
    /** DNS suffix for URLs in this partition */
    readonly dnsSuffix: string;
    /** Internal partition ID */
    readonly id: string;
    /** Partition name (aws, aws-cn, aws-us-gov) */
    readonly partition: string;
    /** Reverse DNS prefix */
    readonly reverseDnsPrefix: string;
}

/**
 * Get service principal for AWS services  
 * @param args - Service specification arguments
 * @returns Promise resolving to service principal
 */
function getServicePrincipal(args: GetServicePrincipalArgs): Promise<GetServicePrincipalResult>;
function getServicePrincipalOutput(args: GetServicePrincipalOutputArgs): pulumi.Output<GetServicePrincipalResult>;

interface GetServicePrincipalArgs {
    /** AWS region (defaults to current region) */
    region?: string;
    /** AWS service name (e.g., "lambda", "ec2", "s3") */
    serviceName: string;
}

interface GetServicePrincipalResult {
    /** Internal ID */
    readonly id: string;
    /** Service principal (e.g., "lambda.amazonaws.com") */
    readonly name: string;
    /** Service suffix */
    readonly suffix: string;
}

/**
 * Get AWS IP address ranges
 * @param args - IP range filtering arguments
 * @returns Promise resolving to IP ranges
 */
function getIpRanges(args?: GetIpRangesArgs): Promise<GetIpRangesResult>;
function getIpRangesOutput(args?: GetIpRangesOutputArgs): pulumi.Output<GetIpRangesResult>;

interface GetIpRangesArgs {
    /** Filter by AWS regions */
    regions?: string[];
    /** Filter by AWS services */
    services?: string[];
    /** Include IPv6 ranges */
    ipv6?: boolean;
}

interface GetIpRangesResult {
    /** Publication date/time */
    readonly createDate: string;
    /** Internal ID */
    readonly id: string;
    /** IPv4 CIDR blocks */
    readonly cidrBlocks: string[];
    /** IPv6 CIDR blocks */
    readonly ipv6CidrBlocks: string[];
    /** Synchronization token */
    readonly syncToken: string;
}

/**
 * Parse and validate AWS ARNs
 * @param args - ARN parsing arguments
 * @returns Promise resolving to parsed ARN components
 */
function getArn(args: GetArnArgs): Promise<GetArnResult>;
function getArnOutput(args: GetArnOutputArgs): pulumi.Output<GetArnResult>;

interface GetArnArgs {
    /** ARN string to parse */
    arn: string;
}

interface GetArnResult {
    /** AWS account ID from ARN */
    readonly account: string;
    /** Internal ID */
    readonly id: string;
    /** AWS partition */
    readonly partition: string;
    /** AWS region */
    readonly region: string;
    /** Resource portion of ARN */
    readonly resource: string;
    /** AWS service */
    readonly service: string;
}

// Parse an ARN
const parsed = await aws.getArn({ 
    arn: "arn:aws:s3:::my-bucket/file.txt" 
});
console.log(`Service: ${parsed.service}`);
console.log(`Resource: ${parsed.resource}`);

// Get AWS service principal
const lambdaPrincipal = await aws.getServicePrincipal({
    serviceName: "lambda"
});

// Use in IAM trust policy
const role = new aws.iam.Role("lambda-role", {
    assumeRolePolicy: JSON.stringify({
        Version: "2012-10-17",
        Statement: [{
            Action: "sts:AssumeRole",
            Effect: "Allow", 
            Principal: {
                Service: lambdaPrincipal.name
            }
        }]
    })
});