Partition Resolution

/**
 * An AWS rule-set function for mapping a region string to a partition.
 */
public final class AwsPartition extends LibraryFunction {
    /** Function identifier used in endpoint rules */
    public static final String ID = "aws.partition";
    
    /** Result field identifiers */
    public static final Identifier NAME = Identifier.of("name");
    public static final Identifier DNS_SUFFIX = Identifier.of("dnsSuffix");
    public static final Identifier DUAL_STACK_DNS_SUFFIX = Identifier.of("dualStackDnsSuffix");
    public static final Identifier SUPPORTS_FIPS = Identifier.of("supportsFIPS");
    public static final Identifier SUPPORTS_DUAL_STACK = Identifier.of("supportsDualStack");
    public static final Identifier IMPLICIT_GLOBAL_REGION = Identifier.of("implicitGlobalRegion");
    public static final Identifier INFERRED = Identifier.of("inferred");
    
    /**
     * Gets the function definition for use in the rules engine
     * @return Function definition instance
     */
    public static Definition getDefinition();
    
    /**
     * Creates a partition function from the given region expression
     * @param region Expression that evaluates to an AWS region string
     * @return AwsPartition function instance
     */
    public static AwsPartition ofExpressions(ToExpression region);
}

/**
 * Represents an AWS partition with its regions and endpoint configuration
 */
public final class Partition {
    /**
     * Gets the partition name (e.g., "aws", "aws-us-gov", "aws-cn")
     * @return Partition name
     */
    public String name();
    
    /**
     * Gets the DNS suffix for this partition
     * @return DNS suffix string
     */
    public String dnsSuffix();
    
    /**
     * Gets the dual-stack DNS suffix for this partition
     * @return Dual-stack DNS suffix string
     */
    public String dualStackDnsSuffix();
    
    /**
     * Checks if this partition supports FIPS endpoints
     * @return true if FIPS is supported
     */
    public boolean supportsFips();
    
    /**
     * Checks if this partition supports dual-stack endpoints
     * @return true if dual-stack is supported
     */
    public boolean supportsDualStack();
    
    /**
     * Gets the implicit global region for this partition
     * @return Global region name or null
     */
    public String implicitGlobalRegion();
    
    /**
     * Gets the regions contained in this partition
     * @return Set of region names
     */
    public Set<String> regions();
}

/**
 * Manages the collection of AWS partitions and provides lookup functionality
 */
public final class Partitions {
    /**
     * Gets all available partitions
     * @return List of all partitions
     */
    public static List<Partition> getPartitions();
    
    /**
     * Looks up partition by region name
     * @param region AWS region name
     * @return Partition containing the region, or null if not found
     */
    public static Partition getPartitionForRegion(String region);
    
    /**
     * Adds a partition to the collection (primarily for testing)
     * @param partition Partition to add
     */
    public static void addPartition(Partition partition);
    
    /**
     * Clears all partitions (primarily for testing)
     */
    public static void clearPartitions();
}

/**
 * Represents the output structure returned by the aws.partition function
 */
public final class PartitionOutputs {
    /**
     * Creates partition outputs from a partition and region
     * @param partition Source partition
     * @param region Region name
     * @return PartitionOutputs instance
     */
    public static PartitionOutputs of(Partition partition, String region);
    
    /**
     * Gets the partition name
     * @return Partition name
     */
    public String name();
    
    /**
     * Gets the DNS suffix
     * @return DNS suffix
     */
    public String dnsSuffix();
    
    /**
     * Gets the dual-stack DNS suffix
     * @return Dual-stack DNS suffix
     */
    public String dualStackDnsSuffix();
    
    /**
     * Checks FIPS support
     * @return true if FIPS is supported
     */
    public boolean supportsFips();
    
    /**
     * Checks dual-stack support
     * @return true if dual-stack is supported
     */
    public boolean supportsDualStack();
    
    /**
     * Gets the implicit global region
     * @return Global region name
     */
    public String implicitGlobalRegion();
    
    /**
     * Indicates if the region was inferred from partition data
     * @return true if inferred
     */
    public boolean inferred();
}

/**
 * Provides region override mechanisms for special cases
 */
public final class RegionOverride {
    /**
     * Creates a region override configuration
     * @param originalRegion Original region name
     * @param overrideRegion Override region name
     * @return RegionOverride instance
     */
    public static RegionOverride of(String originalRegion, String overrideRegion);
    
    /**
     * Gets the original region
     * @return Original region name
     */
    public String originalRegion();
    
    /**
     * Gets the override region
     * @return Override region name
     */
    public String overrideRegion();
}

import software.amazon.smithy.rulesengine.aws.language.functions.AwsPartition;
import software.amazon.smithy.rulesengine.aws.language.functions.partition.*;

// Using the partition function in rules (conceptual)
AwsPartition partitionFunction = AwsPartition.ofExpressions(
    Expression.of("us-east-1")
);

// Direct partition lookup
Partition partition = Partitions.getPartitionForRegion("us-east-1");
if (partition != null) {
    System.out.println("Partition: " + partition.name());         // "aws"
    System.out.println("DNS Suffix: " + partition.dnsSuffix());   // "amazonaws.com"
    System.out.println("Supports FIPS: " + partition.supportsFips()); // true
}

// Working with partition outputs
PartitionOutputs outputs = PartitionOutputs.of(partition, "us-east-1");
String dnsSuffix = outputs.dnsSuffix();
boolean supportsDualStack = outputs.supportsDualStack();

// Get all partitions
List<Partition> allPartitions = Partitions.getPartitions();
// Typically includes:
// - aws (commercial partition)
// - aws-us-gov (GovCloud partition)
// - aws-cn (China partition)

# Endpoint rule example (conceptual)
aws.partition(Region) -> {
  name: "aws",
  dnsSuffix: "amazonaws.com",
  dualStackDnsSuffix: "amazonaws.com", 
  supportsFIPS: true,
  supportsDualStack: true,
  implicitGlobalRegion: "us-east-1",
  inferred: false
}