AWS SDK Region Config Resolver

import { 
  resolveRegionConfig,
  getAwsRegionExtensionConfiguration,
  resolveAwsRegionExtensionConfiguration,
  RegionInputConfig,
  RegionResolvedConfig,
  RegionExtensionRuntimeConfigType,
  REGION_ENV_NAME,
  REGION_INI_NAME,
  NODE_REGION_CONFIG_OPTIONS,
  NODE_REGION_CONFIG_FILE_OPTIONS,
  isFipsRegion,
  getRealRegion
} from "@aws-sdk/region-config-resolver";
import { Provider } from "@smithy/types";
import { LoadedConfigSelectors, LocalConfigOptions } from "@smithy/node-config-provider";
import { AwsRegionExtensionConfiguration } from "@aws-sdk/types";

const { 
  resolveRegionConfig,
  getAwsRegionExtensionConfiguration,
  resolveAwsRegionExtensionConfiguration,
  REGION_ENV_NAME,
  REGION_INI_NAME,
  NODE_REGION_CONFIG_OPTIONS,
  isFipsRegion,
  getRealRegion
} = require("@aws-sdk/region-config-resolver");

import { resolveRegionConfig } from "@aws-sdk/region-config-resolver";

// Basic region configuration
const config = resolveRegionConfig({
  region: "us-east-1",
  useFipsEndpoint: false
});

// Access resolved region
const region = await config.region();
console.log(region); // "us-east-1"

// Check if FIPS endpoint should be used
const useFips = await config.useFipsEndpoint();
console.log(useFips); // false

// FIPS regions are automatically detected and normalized
const fipsConfig = resolveRegionConfig({
  region: "fips-us-west-2"
});
const normalizedRegion = await fipsConfig.region();
console.log(normalizedRegion); // "us-west-2" - FIPS prefix removed

// FIPS setting is automatically enabled for FIPS regions
const fipsEndpointFlag = await fipsConfig.useFipsEndpoint();
console.log(fipsEndpointFlag); // true - automatically enabled

// Provider-based region configuration
const providerConfig = resolveRegionConfig({
  region: async () => process.env.AWS_REGION || "us-east-1",
  useFipsEndpoint: () => Promise.resolve(process.env.AWS_USE_FIPS === "true")
});

/**
 * Resolves region configuration with FIPS endpoint handling
 * @param input - Configuration input with region and FIPS settings
 * @returns Resolved configuration with provider functions
 */
function resolveRegionConfig<T>(
  input: T & RegionInputConfig
): T & RegionResolvedConfig;

interface RegionInputConfig {
  /** The AWS region to which this client will send requests */
  region?: string | Provider<string>;
  /** Enables FIPS compatible endpoints */
  useFipsEndpoint?: boolean | Provider<boolean>;
}

interface RegionResolvedConfig {
  /** Resolved value for input config region */
  region: Provider<string>;
  /** Resolved value for input useFipsEndpoint */
  useFipsEndpoint: Provider<boolean>;
}

import { resolveRegionConfig } from "@aws-sdk/region-config-resolver";

// With string region
const config1 = resolveRegionConfig({
  region: "us-east-1",
  useFipsEndpoint: true
});

// With provider region
const config2 = resolveRegionConfig({
  region: async () => process.env.AWS_REGION || "us-west-2",
  useFipsEndpoint: false
});

// Access resolved values
const resolvedRegion = await config1.region();
const shouldUseFips = await config1.useFipsEndpoint();

/**
 * Creates AWS region extension configuration object
 * @param runtimeConfig - Runtime configuration with region
 * @returns Extension configuration with region methods
 */
function getAwsRegionExtensionConfiguration(
  runtimeConfig: RegionExtensionRuntimeConfigType
): {
  setRegion(region: Provider<string>): void;
  region(): Provider<string>;
};

/**
 * Resolves AWS region extension configuration
 * @param awsRegionExtensionConfiguration - Extension configuration to resolve
 * @returns Runtime configuration type
 */
function resolveAwsRegionExtensionConfiguration(
  awsRegionExtensionConfiguration: AwsRegionExtensionConfiguration
): RegionExtensionRuntimeConfigType;

type RegionExtensionRuntimeConfigType = Partial<{
  region: string | Provider<string>;
}>;

/** Environment variable name for AWS region */
const REGION_ENV_NAME: "AWS_REGION";

/** INI file key name for region configuration */
const REGION_INI_NAME: "region";

/** Configuration selectors for Node.js region config loading */
const NODE_REGION_CONFIG_OPTIONS: LoadedConfigSelectors<string>;

/** Local configuration file options */
const NODE_REGION_CONFIG_FILE_OPTIONS: LocalConfigOptions;

import { 
  REGION_ENV_NAME, 
  REGION_INI_NAME, 
  NODE_REGION_CONFIG_OPTIONS 
} from "@aws-sdk/region-config-resolver";

// Access environment variable name
const envVar = process.env[REGION_ENV_NAME]; // process.env.AWS_REGION

// Use in configuration loading
const region = NODE_REGION_CONFIG_OPTIONS.environmentVariableSelector(process.env);

/**
 * @internal
 * Determines if a region string represents a FIPS region
 * @param region - Region string to check
 * @returns True if region starts with "fips-" or ends with "-fips"
 */
function isFipsRegion(region: string): boolean;

/**
 * @internal
 * Converts FIPS region names to their real region equivalents
 * @param region - Region string (FIPS or regular)
 * @returns Real region name without FIPS prefixes/suffixes
 */
function getRealRegion(region: string): string;

// Internal utilities - not typically used directly
import { isFipsRegion, getRealRegion } from "@aws-sdk/region-config-resolver";

// Check if a region is FIPS
console.log(isFipsRegion("fips-us-east-1")); // true
console.log(isFipsRegion("us-east-1")); // false
console.log(isFipsRegion("us-west-2-fips")); // true

// Get real region from FIPS region
console.log(getRealRegion("fips-us-east-1")); // "us-east-1"
console.log(getRealRegion("us-west-2-fips")); // "us-west-2"
console.log(getRealRegion("fips-aws-global")); // "us-east-1"
console.log(getRealRegion("aws-fips")); // "us-east-1"
console.log(getRealRegion("us-east-1")); // "us-east-1" (unchanged)

interface Provider<T> {
  (): Promise<T>;
}

interface LoadedConfigSelectors<T> {
  environmentVariableSelector: (env: Record<string, string | undefined>) => T | undefined;
  configFileSelector: (profile: Record<string, string | undefined>) => T | undefined;
  default: () => T;
}

interface LocalConfigOptions {
  preferredFile: "credentials";
}

interface AwsRegionExtensionConfiguration {
  setRegion(region: Provider<string>): void;
  region(): Provider<string>;
}

// Error handling example
try {
  const config = resolveRegionConfig({
    // Missing region property
    useFipsEndpoint: false
  });
} catch (error) {
  console.error(error.message); // "Region is missing"
}