OpenFeature Providers

const context = {
  // The JS providers do not map targetingKey — GrowthBook buckets on `id`.
  targetingKey: "user-123",
  id: "user-123",
  country: "US",
  plan: "premium",
  email: "user@example.com",
};

from openfeature.evaluation_context import EvaluationContext

context = EvaluationContext(
    targeting_key="user-123",
    attributes={
        "country": "US",
        "plan": "premium",
        "email": "user@example.com",
    }
)

evalCtx := openfeature.NewEvaluationContext("user-123", map[string]interface{}{
    // The Go provider does not map targetingKey — GrowthBook buckets on `id`.
    "id":      "user-123",
    "country": "US",
    "plan":    "premium",
    "email":   "user@example.com",
})

var context = new EvaluationContext(
    targetingKey: "user-123",
    new Dictionary<string, Value>
    {
        { "country", new Value("US") },
        { "plan",    new Value("premium") },
        { "email",   new Value("user@example.com") },
    }
);

import dev.openfeature.sdk.EvaluationContext;
import dev.openfeature.sdk.MutableContext;

MutableContext context = new MutableContext("user-123");
context.add("country", "US");
context.add("plan", "premium");
context.add("email", "user@example.com");

await OpenFeatureAPI.shared.setEvaluationContextAndWait(
    evaluationContext: ImmutableContext(
        targetingKey: "user-123",
        structure: ImmutableStructure(attributes: [
            "country": .string("US"),
            "plan": .string("premium"),
            "email": .string("user@example.com"),
        ])
    )
)

import dev.openfeature.kotlin.sdk.ImmutableContext
import dev.openfeature.kotlin.sdk.OpenFeatureAPI
import dev.openfeature.kotlin.sdk.Value

OpenFeatureAPI.setEvaluationContextAndWait(
    ImmutableContext(
        targetingKey = "user-123",
        attributes = mapOf(
            "country" to Value.String("US"),
            "plan" to Value.String("premium"),
            "email" to Value.String("user@example.com"),
        ),
    ),
)

// Server SDK (async)
const enabled = await client.getBooleanValue("dark-mode", false, context);

// Returns full evaluation details (value, reason, variant, error)
const details = await client.getBooleanDetails("dark-mode", false, context);

# Synchronous
enabled = client.get_boolean_value("dark-mode", False, context)

# Async (returns FlagEvaluationDetails with value, reason, variant, etc.)
details = await provider.resolve_boolean_details_async("dark-mode", False, context)
enabled = details.value

// Returns the value with a default fallback
enabled, err := client.BooleanValue(context.Background(), "dark-mode", false, evalCtx)

// Returns full evaluation details (value, reason, variant, error)
details, err := client.BooleanValueDetails(context.Background(), "dark-mode", false, evalCtx)
enabled := details.Value

bool enabled = await client.GetBooleanValue("dark-mode", false, context);

boolean enabled = client.getBooleanValue("dark-mode", false, context);

let enabled = client.getBooleanValue(key: "dark-mode", defaultValue: false)

// Returns full evaluation details (value, reason, variant, error)
let details = client.getBooleanDetails(key: "dark-mode", defaultValue: false)

val enabled = client.getBooleanValue("dark-mode", false)

// Returns full evaluation details (value, reason, variant, error)
val details = client.getBooleanDetails("dark-mode", false)

const variant = await client.getStringValue("button-color", "blue", context);

variant = client.get_string_value("button-color", "blue", context)

variant, err := client.StringValue(context.Background(), "button-color", "blue", evalCtx)

string variant = await client.GetStringValue("button-color", "blue", context);

String variant = client.getStringValue("button-color", "blue", context);

let variant = client.getStringValue(key: "button-color", defaultValue: "blue")

val variant = client.getStringValue("button-color", "blue")

const requestLimit = await client.getNumberValue("api-request-limit", 100, context);
const price = await client.getNumberValue("subscription-price", 9.99, context);

request_limit = client.get_integer_value("api-request-limit", 100, context)
price         = client.get_float_value("subscription-price", 9.99, context)

requestLimit, err := client.IntValue(context.Background(), "api-request-limit", 100, evalCtx)
price, err         := client.FloatValue(context.Background(), "subscription-price", 9.99, evalCtx)

int    requestLimit = await client.GetIntegerValue("api-request-limit", 100, context);
double price        = await client.GetDoubleValue("subscription-price", 9.99, context);

int    requestLimit = client.getIntegerValue("api-request-limit", 100, context);
double price        = client.getDoubleValue("subscription-price", 9.99, context);

let requestLimit = client.getIntegerValue(key: "api-request-limit", defaultValue: 100) // Int64
let price        = client.getDoubleValue(key: "subscription-price", defaultValue: 9.99)

val requestLimit = client.getIntegerValue("api-request-limit", 100)
val price        = client.getDoubleValue("subscription-price", 9.99)

const config = await client.getObjectValue("theme-config", { color: "blue" }, context);

config = client.get_object_value("theme-config", {"color": "blue"}, context)

// Object values are returned as map[string]interface{}
config, err := client.ObjectValue(context.Background(), "theme-config", map[string]interface{}{}, evalCtx)

Value config = await client.GetObjectValue("theme-config",
    new Value(new Dictionary<string, Value>()), context);

Value config = client.getObjectValue("theme-config", new MutableStructure(), context);

let config = client.getObjectValue(key: "theme-config", defaultValue: .structure([:]))

val config = client.getObjectValue("theme-config", Value.Structure(emptyMap()))

await OpenFeature.close();

await provider.close()       # async
# or
provider.close_sync()        # sync

defer gbClient.Close()

provider.Dispose();

provider.shutdown();

// OpenFeature Swift doesn't shut providers down, so close the provider yourself
provider.close()

OpenFeatureAPI.shutdown() // from a coroutine