type ConfigManager interface {
    // String values
    GetString(key string, defaultValue ...string) string
    
    // Numeric values
    GetInt(key string, defaultValue ...int) int
    GetInt64(key string, defaultValue ...int64) int64
    GetFloat64(key string, defaultValue ...float64) float64
    
    // Boolean values
    GetBool(key string, defaultValue ...bool) bool
    
    // Complex types
    Unmarshal(key string, dest interface{}) error
    
    // Configuration sources
    AddSource(source ConfigSource) error
    
    // Configuration management
    Set(key string, value interface{}) error
    SetDefault(key string, value interface{}) error
}

// String values
appName := config.GetString("app.name", "default-app")
version := config.GetString("app.version", "1.0.0")

// Numeric values
port := config.GetInt("server.port", 8080)
timeout := config.GetInt("server.timeout", 30)

// Boolean values
debug := config.GetBool("debug", false)
metricsEnabled := config.GetBool("metrics.enabled", true)

// Float values
rate := config.GetFloat64("rate.limit", 100.0)

// Unmarshal into struct
type DatabaseConfig struct {
    Host     string `yaml:"host"`
    Port     int    `yaml:"port"`
    Name     string `yaml:"name"`
    User     string `yaml:"user"`
    Password string `yaml:"password"`
}

var dbConfig DatabaseConfig
config.Unmarshal("database", &dbConfig)

// Validate configuration
func validateConfig(config ConfigManager) error {
    // Required fields
    if config.GetString("app.name") == "" {
        return errors.New("app.name is required")
    }
    
    if config.GetString("database.host") == "" {
        return errors.New("database.host is required")
    }
    
    // Value ranges
    port := config.GetInt("server.port")
    if port < 1 || port > 65535 {
        return errors.New("server.port must be between 1 and 65535")
    }
    
    return nil
}

config/
├── base.yaml          # Base configuration
├── development.yaml   # Development overrides
├── staging.yaml       # Staging overrides
├── production.yaml    # Production overrides
└── testing.yaml       # Testing overrides

# config/base.yaml
app:
  name: "my-app"
  version: "1.0.0"

server:
  address: ":8080"
  timeout: "30s"

database:
  host: "localhost"
  port: 5432
  name: "myapp"

logging:
  level: "info"
  format: "json"

# config/development.yaml
app:
  environment: "development"

database:
  host: "localhost"
  name: "myapp_dev"

logging:
  level: "debug"
  format: "console"

debug:
  enabled: true

# config/production.yaml
app:
  environment: "production"

database:
  host: "${DB_HOST}"
  name: "${DB_NAME}"
  user: "${DB_USER}"
  password: "${DB_PASSWORD}"

logging:
  level: "warn"
  format: "json"

metrics:
  enabled: true
  path: "/_/metrics"

func loadConfig(environment string) ConfigManager {
    config := forge.NewConfigManager()
    
    // Load base configuration
    config.AddSource(forge.NewFileSource("config/base.yaml"))
    
    // Load environment-specific configuration
    envConfig := fmt.Sprintf("config/%s.yaml", environment)
    config.AddSource(forge.NewFileSource(envConfig))
    
    // Load environment variables
    config.AddSource(forge.NewEnvSource())
    
    return config
}

// Watch for configuration changes
config.Watch(func(key string, value interface{}) {
    log.Printf("Configuration changed: %s = %v", key, value)
    
    // Handle specific configuration changes
    switch key {
    case "server.address":
        // Restart server with new address
        restartServer(value.(string))
    case "logging.level":
        // Update logging level
        updateLogLevel(value.(string))
    }
})

// Enable hot reload for file sources
config.AddSource(forge.NewFileSource("config.yaml", forge.WithHotReload(true)))

// Handle configuration reload
config.OnReload(func() {
    log.Println("Configuration reloaded")
    
    // Update application configuration
    updateApplicationConfig(config)
})

// Use environment variables for secrets
config.AddSource(forge.NewEnvSource())

// Use external secrets management
config.AddSource(forge.NewSecretsSource(forge.SecretsConfig{
    Provider: "aws-secrets-manager",
    Region:   "us-east-1",
    Secrets:  []string{"database-password", "api-key"},
}))

// Encrypt sensitive configuration values
config.AddSource(forge.NewEncryptedSource(forge.EncryptedConfig{
    Key:      "encryption-key",
    Provider: "file",
    Path:     "config/encrypted.yaml",
}))

func TestWithTestConfig(t *testing.T) {
    config := forge.NewConfigManager()
    
    // Set test configuration
    config.Set("app.name", "test-app")
    config.Set("server.port", 8080)
    config.Set("database.host", "localhost")
    
    // Test configuration access
    assert.Equal(t, "test-app", config.GetString("app.name"))
    assert.Equal(t, 8080, config.GetInt("server.port"))
    assert.Equal(t, "localhost", config.GetString("database.host"))
}

func TestConfigValidation(t *testing.T) {
    config := forge.NewConfigManager()
    
    // Test valid configuration
    config.Set("app.name", "test-app")
    config.Set("server.port", 8080)
    
    err := validateConfig(config)
    assert.NoError(t, err)
    
    // Test invalid configuration
    config.Set("app.name", "")
    config.Set("server.port", 0)
    
    err = validateConfig(config)
    assert.Error(t, err)
}