Visitor Context & Properties

import type {ContextInterface} from '@convertcom/js-sdk';

const userContext = convertSDK.createContext(
  'user-unique-id',
  {
    country: 'US',
    language: 'en'
  }
);

use ConvertSdk\Interfaces\ContextInterface;

$context = $sdk->createContext(
    'visitor-unique-id',
    [
        'country' => 'US',
        'language' => 'en',
    ]
);

val context = sdk.createContext(
    visitorId = "user-unique-id",
    attributes = mapOf("country" to "US", "language" to "en"),
)

context = CONVERT_SDK.create_context(
  "user-unique-id",
  { country: "US", language: "en" }
)

// Anonymous visitor → auto-generated UUID persisted in the Keychain.
let anon = sdk.createContext()

// Explicit visitor ID with initial attributes (scalars only):
let context = sdk.createContext(
    visitorId: "user-unique-id",
    attributes: ["country": "US", "language": "en"]
)

# visitor_attributes are copied defensively — later caller mutations don't leak in:
context = core.create_context(
    "user-unique-id",
    visitor_attributes={"country": "US", "language": "en"},
)

const variation = userContext.runExperience('experience-key', {
  locationProperties: { url: '/pricing' },
  visitorProperties: { plan: 'pro' },
  updateVisitorProperties: true,
  enableTracking: true
});

use OpenAPI\Client\BucketingAttributes;

$variation = $context->runExperience('experience-key', new BucketingAttributes([
    'locationProperties' => ['url' => '/pricing'],
    'visitorProperties' => ['plan' => 'pro'],
    'updateVisitorProperties' => true,
    'enableTracking' => true,
]));

// Targeting input is set on the context, then the experience is run:
ctx.setLocationProperties(mapOf("url" to "/pricing"))
ctx.setAttributes(mapOf("plan" to "pro"))
val variation = ctx.runExperience("experience-key")

# Visitor properties are flat top-level keys; location_properties, environment,
# and enable_tracking are the reserved keys here — experience_keys and type_casting
# are reserved too, but honoured only on run_feature/run_features. (There is no
# inline updateVisitorProperties flag — use update_visitor_properties below to persist.)
variation = context.run_experience("experience-key", {
  plan: "pro",
  location_properties: { url: "/pricing" },
  enable_tracking: true
})

// iOS has no per-call attributes argument (runExperience takes only `enableTracking`),
// and attributes are immutable for a context's lifetime. Set them once at creation:
let context = sdk.createContext(visitorId: "user-unique-id", attributes: ["plan": "pro"])
let variation = await context.runExperience("experience-key")

# Per-call overlays are keyword-only and ephemeral. Visitor audiences via
# attributes=, location rules via location_attributes=. enable_tracking (default
# True) is also keyword-only — set it False to bucket without reporting the
# bucketing event. There is no inline updateVisitorProperties flag — use
# set_attributes() to persist visitor properties:
variation = context.run_experience(
    "experience-key",
    attributes={"plan": "pro"},
    location_attributes={"url": "/pricing"},
    enable_tracking=True,
)

userContext.updateVisitorProperties({
  weather: 'rainy',
  plan: 'enterprise'
});

// Set a single attribute
$context->setAttribute('weather', 'rainy');

// Set multiple attributes (merges with existing)
$context->setAttributes([
    'weather' => 'rainy',
    'plan' => 'enterprise',
]);

// Update via the data store (persists across requests when using a persistent cache)
$context->updateVisitorProperties('visitor-unique-id', [
    'weather' => 'rainy',
    'plan' => 'enterprise',
]);

// setAttributes replaces the visitor's attributes; combine maps to merge.
ctx.setAttributes(mapOf("weather" to "rainy", "plan" to "enterprise"))

# Merges into the visitor's stored properties (persists via the configured store)
# and the in-memory context attributes.
context.update_visitor_properties(
  weather: "rainy",
  plan: "enterprise"
)

const variation = userContext.runExperience('experience-key', {
  visitorProperties: { weather: 'rainy' },
  updateVisitorProperties: true
});

use OpenAPI\Client\BucketingAttributes;

$variation = $context->runExperience('experience-key', new BucketingAttributes([
    'visitorProperties' => ['weather' => 'rainy'],
    'updateVisitorProperties' => true,
]));

userContext.runCustomSegments(['segment-key-1', 'segment-key-2'], {
  enabled: true
});

$context->runCustomSegments(['segment-key-1', 'segment-key-2'], [
    'ruleData' => ['enabled' => true],
]);

context.run_custom_segments(["segment-key-1", "segment-key-2"], {
  ruleData: { enabled: true }
})

userContext.setDefaultSegments({
  country: 'US',
  browser: 'chrome',
  devices: 'desktop'
});

$context->setDefaultSegments([
    'country' => 'US',
    'browser' => 'chrome',
    'devices' => 'desktop',
]);

ctx.setDefaultSegments(mapOf(
    "country" to "US",
    "browser" to "chrome",
    "devices" to "desktop",
))

context.set_default_segments(
  country: "US",
  browser: "chrome",
  devices: "desktop"
)

// Six recognised keys: browser, devices, source, campaign, visitorType, country.
// Each call merges over existing segments; unknown keys are WARN-logged and ignored.
await context.setDefaultSegments([
    "country": "US",
    "browser": "chrome",
    "devices": "desktop",
])

# The method is set_segments(); each call shallow-merges into the stored default
# segments, kept strictly separate from visitor attributes:
context.set_segments({
    "country": "US",
    "browser": "chrome",
    "devices": "desktop",
})

import ConvertSDK, {EntityType} from '@convertcom/js-sdk';
import type {Experience} from '@convertcom/js-sdk';

const experience = userContext.getConfigEntity(
  'experience-key',
  EntityType.EXPERIENCE
);

use ConvertSdk\Enums\EntityType;

$experience = $context->getConfigEntity('experience-key', EntityType::Experience->value);

# entity_type accepts :experience, :feature, or :goal (symbol or string).
experience = context.get_config_entity("experience-key", :experience)

# entity_type comes FIRST (opposite of the JS/PHP/Ruby order) and is a plain
# string — one of "experiences", "features", "goals", "audiences", "segments".
# Returns the entity mapping, or None on a normal miss (never raises):
experience = context.get_config_entity("experiences", "experience-key")

import ConvertSDK, {EntityType, VariationChangeType} from '@convertcom/js-sdk';
import type {BucketedVariation, Feature, VariationChange} from '@convertcom/js-sdk';

const variation = userContext.runExperience('experience-key');
const changesData = variation.changes.find(
  ({type}) => type === VariationChangeType.FULLSTACK_FEATURE
);
const feature = userContext.getConfigEntityById(
  changesData.data.feature_id,
  EntityType.FEATURE
);

use ConvertSdk\Enums\EntityType;

$variation = $context->runExperience('experience-key');
if ($variation !== null) {
    $changes = $variation->changes;
    foreach ($changes as $change) {
        if (isset($change['data']['feature_id'])) {
            $feature = $context->getConfigEntityById(
                (string) $change['data']['feature_id'],
                EntityType::Feature->value
            );
        }
    }
}

# get_config_entity_by_id also takes entity_type first, then the id. Returns the
# entity mapping, or None on a normal miss (never raises):
feature = context.get_config_entity_by_id("features", "feature-id")