@revturbine/sdk 0.11.5 → 0.11.7

package/dist/index.d.ts

@@ -3581,6 +3581,138 @@ declare const AnalyticsCatalogConceptSchema: z.ZodObject<{
         }>>;
     }, z.core.$strip>>;
     livemode_qualified: z.ZodOptional<z.ZodBoolean>;
+    record_contract: z.ZodOptional<z.ZodObject<{
+        record_id: z.ZodArray<z.ZodString>;
+        source_namespace: z.ZodString;
+        occurred_time_field: z.ZodString;
+        received_time_field: z.ZodOptional<z.ZodString>;
+        dedup: z.ZodEnum<{
+            unknown: "unknown";
+            deduplicated_on_record_id: "deduplicated_on_record_id";
+            summed_on_sorting_key: "summed_on_sorting_key";
+            append_only: "append_only";
+            upsert_on_primary_key: "upsert_on_primary_key";
+            recomputed_at_query: "recomputed_at_query";
+        }>;
+        revision: z.ZodEnum<{
+            unknown: "unknown";
+            immutable: "immutable";
+            re_emit_higher_version: "re_emit_higher_version";
+            in_place_update: "in_place_update";
+            recomputed_from_source: "recomputed_from_source";
+        }>;
+        late_arrival: z.ZodEnum<{
+            unknown: "unknown";
+            accepted: "accepted";
+            accepted_within_retention: "accepted_within_retention";
+            rejected: "rejected";
+        }>;
+        correlation_keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        livemode_field: z.ZodOptional<z.ZodString>;
+        policy_version_fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        path: z.ZodString;
+        resolution: z.ZodEnum<{
+            source: "source";
+            enriched: "enriched";
+            absent: "absent";
+        }>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    measures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        unit: z.ZodEnum<{
+            count: "count";
+            ratio: "ratio";
+            seconds: "seconds";
+            currency_minor: "currency_minor";
+            timestamp: "timestamp";
+            usage_unit: "usage_unit";
+            polymorphic: "polymorphic";
+        }>;
+        temporal: z.ZodEnum<{
+            stock: "stock";
+            flow: "flow";
+            gauge: "gauge";
+        }>;
+        sign: z.ZodEnum<{
+            signed: "signed";
+            positive_magnitude: "positive_magnitude";
+            unsigned: "unsigned";
+        }>;
+        aggregation_semantics: z.ZodEnum<{
+            additive: "additive";
+            semi_additive: "semi_additive";
+            non_additive: "non_additive";
+        }>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    event_attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            unavailable: "unavailable";
+            ingested_event: "ingested_event";
+            datasource: "datasource";
+            control_plane_table: "control_plane_table";
+            build: "build";
+        }>;
+        ref: z.ZodString;
+        blocker: z.ZodOptional<z.ZodString>;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    build: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            unavailable: "unavailable";
+            materialized_view: "materialized_view";
+            worker: "worker";
+            query_time: "query_time";
+        }>;
+        ref: z.ZodString;
+        inputs: z.ZodArray<z.ZodString>;
+        blocker: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    maturity: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            unavailable: "unavailable";
+            declared: "declared";
+        }>;
+        horizon_field: z.ZodOptional<z.ZodString>;
+        observed_through_field: z.ZodOptional<z.ZodString>;
+        blocker: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    oracle_family: z.ZodOptional<z.ZodObject<{
+        family: z.ZodEnum<{
+            none: "none";
+            funnel: "funnel";
+            revenue: "revenue";
+            gate: "gate";
+            presentation: "presentation";
+            attribution: "attribution";
+            event_count: "event_count";
+            cohort: "cohort";
+            read_through: "read_through";
+        }>;
+        blocker: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    policy_dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            attribution: "attribution";
+            mrr: "mrr";
+            lifecycle: "lifecycle";
+            engagement: "engagement";
+        }>;
+        stamped: z.ZodBoolean;
+        blocker: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
     deprecation: z.ZodOptional<z.ZodObject<{
         deprecated: z.ZodBoolean;
         replaced_by: z.ZodOptional<z.ZodString>;
@@ -5770,6 +5902,138 @@ declare const AnalyticsCatalogSchema: z.ZodObject<{
             }>>;
         }, z.core.$strip>>;
         livemode_qualified: z.ZodOptional<z.ZodBoolean>;
+        record_contract: z.ZodOptional<z.ZodObject<{
+            record_id: z.ZodArray<z.ZodString>;
+            source_namespace: z.ZodString;
+            occurred_time_field: z.ZodString;
+            received_time_field: z.ZodOptional<z.ZodString>;
+            dedup: z.ZodEnum<{
+                unknown: "unknown";
+                deduplicated_on_record_id: "deduplicated_on_record_id";
+                summed_on_sorting_key: "summed_on_sorting_key";
+                append_only: "append_only";
+                upsert_on_primary_key: "upsert_on_primary_key";
+                recomputed_at_query: "recomputed_at_query";
+            }>;
+            revision: z.ZodEnum<{
+                unknown: "unknown";
+                immutable: "immutable";
+                re_emit_higher_version: "re_emit_higher_version";
+                in_place_update: "in_place_update";
+                recomputed_from_source: "recomputed_from_source";
+            }>;
+            late_arrival: z.ZodEnum<{
+                unknown: "unknown";
+                accepted: "accepted";
+                accepted_within_retention: "accepted_within_retention";
+                rejected: "rejected";
+            }>;
+            correlation_keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            livemode_field: z.ZodOptional<z.ZodString>;
+            policy_version_fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        keys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            path: z.ZodString;
+            resolution: z.ZodEnum<{
+                source: "source";
+                enriched: "enriched";
+                absent: "absent";
+            }>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        measures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodString;
+            unit: z.ZodEnum<{
+                count: "count";
+                ratio: "ratio";
+                seconds: "seconds";
+                currency_minor: "currency_minor";
+                timestamp: "timestamp";
+                usage_unit: "usage_unit";
+                polymorphic: "polymorphic";
+            }>;
+            temporal: z.ZodEnum<{
+                stock: "stock";
+                flow: "flow";
+                gauge: "gauge";
+            }>;
+            sign: z.ZodEnum<{
+                signed: "signed";
+                positive_magnitude: "positive_magnitude";
+                unsigned: "unsigned";
+            }>;
+            aggregation_semantics: z.ZodEnum<{
+                additive: "additive";
+                semi_additive: "semi_additive";
+                non_additive: "non_additive";
+            }>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        event_attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                unavailable: "unavailable";
+                ingested_event: "ingested_event";
+                datasource: "datasource";
+                control_plane_table: "control_plane_table";
+                build: "build";
+            }>;
+            ref: z.ZodString;
+            blocker: z.ZodOptional<z.ZodString>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        build: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                pipe: "pipe";
+                unavailable: "unavailable";
+                materialized_view: "materialized_view";
+                worker: "worker";
+                query_time: "query_time";
+            }>;
+            ref: z.ZodString;
+            inputs: z.ZodArray<z.ZodString>;
+            blocker: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        maturity: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                unavailable: "unavailable";
+                declared: "declared";
+            }>;
+            horizon_field: z.ZodOptional<z.ZodString>;
+            observed_through_field: z.ZodOptional<z.ZodString>;
+            blocker: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        oracle_family: z.ZodOptional<z.ZodObject<{
+            family: z.ZodEnum<{
+                none: "none";
+                funnel: "funnel";
+                revenue: "revenue";
+                gate: "gate";
+                presentation: "presentation";
+                attribution: "attribution";
+                event_count: "event_count";
+                cohort: "cohort";
+                read_through: "read_through";
+            }>;
+            blocker: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        policy_dependencies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                attribution: "attribution";
+                mrr: "mrr";
+                lifecycle: "lifecycle";
+                engagement: "engagement";
+            }>;
+            stamped: z.ZodBoolean;
+            blocker: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
         deprecation: z.ZodOptional<z.ZodObject<{
             deprecated: z.ZodBoolean;
             replaced_by: z.ZodOptional<z.ZodString>;
@@ -7959,9 +8223,9 @@ declare const WebhookProcessingStatusSchema: z.ZodEnum<{
  */
 declare const WebhookDispatchStatusSchema: z.ZodEnum<{
     unknown: "unknown";
+    accepted: "accepted";
     failed: "failed";
     pending: "pending";
-    accepted: "accepted";
     terminal: "terminal";
     not_required: "not_required";
     dispatching: "dispatching";
@@ -8017,9 +8281,9 @@ declare const WebhookDeliverySchema: z.ZodObject<{
     }>>;
     dispatch_status: z.ZodDefault<z.ZodEnum<{
         unknown: "unknown";
+        accepted: "accepted";
         failed: "failed";
         pending: "pending";
-        accepted: "accepted";
         terminal: "terminal";
         not_required: "not_required";
         dispatching: "dispatching";
@@ -9172,6 +9436,9 @@ declare const TrialInstanceSchema: z.ZodObject<{
     usage_limit_value: z.ZodOptional<z.ZodNumber>;
     converted_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     cancelled_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    trial_episode_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stripe_subscription_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    actual_end_at: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 declare const trialPaths: ZodOpenApiPathsObject;
@@ -15738,12 +16005,12 @@ declare const ServerEvaluationPayloadSchema: z.ZodObject<{
 
 declare const PlaybookVersionStatusSchema: z.ZodEnum<{
     draft: "draft";
+    rejected: "rejected";
     archived: "archived";
     awaiting_approval: "awaiting_approval";
     approved: "approved";
     deploying: "deploying";
     deployed: "deployed";
-    rejected: "rejected";
 }>;
 declare const PlaybookVersionSchema: z.ZodObject<{
     id: z.ZodString;
@@ -15755,12 +16022,12 @@ declare const PlaybookVersionSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     status: z.ZodDefault<z.ZodEnum<{
         draft: "draft";
+        rejected: "rejected";
         archived: "archived";
         awaiting_approval: "awaiting_approval";
         approved: "approved";
         deploying: "deploying";
         deployed: "deployed";
-        rejected: "rejected";
     }>>;
     labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
     created_by: z.ZodString;
@@ -16271,9 +16538,9 @@ declare const AuthMemberSchema: z.ZodObject<{
 declare const InvitationStatusSchema: z.ZodEnum<{
     canceled: "canceled";
     expired: "expired";
-    pending: "pending";
     accepted: "accepted";
     rejected: "rejected";
+    pending: "pending";
 }>;
 declare const AuthInvitationSchema: z.ZodObject<{
     id: z.ZodString;
@@ -16288,9 +16555,9 @@ declare const AuthInvitationSchema: z.ZodObject<{
     status: z.ZodDefault<z.ZodEnum<{
         canceled: "canceled";
         expired: "expired";
-        pending: "pending";
         accepted: "accepted";
         rejected: "rejected";
+        pending: "pending";
     }>>;
     expires_at: z.ZodString;
     created_at: z.ZodString;
@@ -17171,11 +17438,14 @@ interface RevTurbineTreatmentInteractionInput {
      * `PlacementOutput.rule_id` — projected onto the `placement_interaction`
      * clickstream payload as `rule_handle` (BL-0182).
      *
-     * Unlike its neighbours this does NOT reach the wire
-     * `TreatmentInteractionInputSchema` / `placement_presentations`: that path is
-     * column-shaped and would need a datasource migration. The clickstream
-     * carries payload fields inside a JSON column, so the rule slice for
-     * interactions is readable the moment producers send it.
+     * It reaches the wire `TreatmentInteractionInputSchema` too, as of BL-0200.
+     * It deliberately did not under BL-0182: that path is column-shaped and the
+     * rule would have needed a datasource migration, while the clickstream
+     * carries payload fields inside a JSON column and was readable at once.
+     * `placement_exposure_attribution.rule_handle` exists now (web ledger 015),
+     * so the base exposure row records the rule the exposure was DECIDED by
+     * rather than waiting for attribution to reconstruct one when a conversion
+     * lands — which is what makes presentation-grain rule cuts servable.
      *
      * Omitted, never sent empty, when no decision is in scope — a bare
      * `trackTreatmentInteraction` caller supplies no rule, and absence is what
@@ -21339,6 +21609,12 @@ declare class RevTurbineCustomerSdk {
      * redundant segment re-evaluation.
      */
     private lastServerContextHash?;
+    /**
+     * The plan move an optimistic `convert()` made ahead of the server (BL-0004),
+     * held only until a `client-context` read stops reporting the old plan. See
+     * {@link dropStalePostConversionPlan}.
+     */
+    private pendingConversionPlan?;
     private usageBalances;
     private localDecisionsByPlacementId;
     private localPlacementsByLookupKey;
@@ -22483,12 +22759,16 @@ declare class RevTurbineCustomerSdk {
     /** Map the client-safe context response into a UserContext patch (plan 157). */
     private mapClientSafeContext;
     /**
-     * Apply a server-derived UserContext patch (plan 157) — mirrors setUserContext
-     * but accepts a partial. The patch's RevTurbine-authoritative fields (trial,
-     * billing signals) overlay the held context; undefined fields are skipped by
-     * the merge, so app-set values are never nulled.
+     * Apply a UserContext patch — mirrors setUserContext but accepts a partial.
+     * RevTurbine-authoritative fields (trial, billing signals, server plan)
+     * overlay the held context; undefined fields are skipped by the merge, so
+     * app-set values are never nulled.
+     *
+     * Two callers: the server client-context fetch (plan 157) and the optimistic
+     * post-conversion plan move (BL-0004). Both notify subscribers, which is what
+     * makes mounted slots and gates re-resolve.
      */
-    private applyServerContextPatch;
+    private applyUserContextPatch;
     /**
      * Record that a placement was rendered to the user. Plan 43 TASK-9.
      *
@@ -22665,13 +22945,73 @@ declare class RevTurbineCustomerSdk {
      */
     snooze(outputId: string, seconds?: number): Promise<void>;
     /**
-     * Record a confirmed CTA completion and retire the decision's placement
-     * permanently — future calls to `getPlacementDecision` for it will not
-     * return it again.
+     * Record a confirmed CTA completion, then reload the UserContext so every
+     * mounted surface re-decides against the plan the user just converted to.
+     *
+     * Conversion is **not** a suppression: it writes no cooldown and no permanent
+     * retirement (spec §"interaction" table; Kent's plan 254 D-9 ruling). What
+     * makes a converted upgrade banner leave the screen is the user no longer
+     * matching it — so a conversion that did not refresh the context left the
+     * placement mounted until something else happened to re-resolve it. Kent,
+     * 2026-09-25 (BL-0004): *"Converting should trigger a reloading of UserContext
+     * with the new plan/billing state the user has converted to."*
+     *
+     * Ordering, and why it is this way round:
+     *
+     * 1. The interaction is recorded (analytics + attribution), as before.
+     * 2. **Optimistically**, locally: when the converted output's CTA names a
+     *    target plan (`cta_path.plan_handle`), the held context moves to that plan
+     *    immediately. Billing truth arrives by Stripe webhook, so
+     *    `GET /api/sdk/client-context` can still report the OLD plan for seconds
+     *    after a successful checkout — waiting for it would leave the upgrade
+     *    prompt on screen exactly when the user has just paid.
+     * 3. Subscribers are notified either way — a conversion whose CTA names no
+     *    plan still re-decides mounted slots and re-checks mounted gates, which is
+     *    what turns a plan change the host applied itself into a re-render.
+     * 4. **Then** the server refresh (`fetchClientContext()`), which overlays the
+     *    RevTurbine-authoritative trial / billing-health / plan fields and
+     *    notifies again if it changed anything. It is best-effort and never
+     *    throws, so awaiting it cannot fail a conversion; with no client-session
+     *    minter configured it is a no-op and the optimistic state stands.
+     *
+     * Mounted `PlacementController`s re-decide and mounted `EntitlementGate`s
+     * re-check through their `watchUserContext()` subscriptions — which the React
+     * bindings attach for you. Re-resolution emits the normal lifecycle events
+     * once per final decision; the transient states emit nothing.
+     * `PlacementController.ctaComplete()` is unchanged and remains the
+     * component-level path.
      *
      * @public
      */
     convert(outputId: string): Promise<void>;
+    /**
+     * The BL-0004 post-conversion context reload: optimistic local plan move,
+     * then the server refresh. See {@link convert} for the ordering rationale.
+     */
+    private reloadUserContextAfterConversion;
+    /**
+     * Keep a stale server plan from undoing an optimistic conversion (BL-0004).
+     *
+     * Billing truth arrives by Stripe webhook, so a `client-context` read that
+     * races the webhook reports the PRE-conversion plan — and the server plan
+     * deliberately overlays the app-supplied one (plan 179 TASK-1), so applying
+     * that read verbatim would put the upgrade prompt straight back on screen
+     * seconds after the user paid.
+     *
+     * So while a conversion is pending, a server plan equal to the plan converted
+     * AWAY from is dropped — only the plan fields, never the trial or billing-health
+     * signals, which are authoritative regardless. Any other value (the new plan,
+     * or a third one the user was moved to out-of-band) clears the pending state
+     * and applies, so this can suppress at most the one value it was created for
+     * and cannot outlive the lag it exists to cover.
+     */
+    private dropStalePostConversionPlan;
+    /**
+     * The display name the loaded Playbook gives a plan handle, else the handle.
+     * Keeps an optimistic plan move from putting a raw handle in front of a user
+     * when the Playbook already knows the plan's name.
+     */
+    private planNameForHandle;
     /**
      * Emit a canonical trigger event. There is no in-SDK consumer that matches
      * on trigger names — the shipped behavior is ingest to `events_clickstream`
@@ -23135,12 +23475,41 @@ declare class PlacementController {
     private _awaitingConfig;
     private _configRetries;
     private _playbookUnsubscribe;
+    private _userContextUnsubscribe;
     constructor(sdk: RevTurbineCustomerSdk, options: PlacementControllerOptions);
     /**
-     * Stop listening for Playbook loads. Idempotent; call it when the owning
-     * component unmounts (`usePlacement` does).
+     * Stop listening for Playbook loads and user-context changes. Idempotent; call
+     * it when the owning component unmounts (`usePlacement` does).
      */
     dispose(): void;
+    /**
+     * Drop only the Playbook-load subscription — the within-load-cycle teardown
+     * (BL-0177). A mounted controller keeps watching the user context (BL-0004).
+     */
+    private unsubscribePlaybook;
+    /**
+     * Re-decide whenever the user context changes (BL-0004).
+     *
+     * The counterpart to {@link EntitlementGate.watchUserContext}, and the reason
+     * `sdk.convert()` now removes a converted placement in place: conversion writes
+     * no suppression — eligibility is a function of the user's CURRENT plan and
+     * targeting — so the only thing that can take a converted upgrade banner off
+     * screen is a re-decide against the reloaded context. Without this the
+     * placement stayed mounted until something else happened to re-resolve it, and
+     * the host had to call `refresh()` itself or use the component's
+     * `ctaComplete()` (the limitation plan 236 TASK-13 recorded).
+     *
+     * Only re-decides a controller that has already resolved something: before the
+     * first `load()` there is nothing on screen to be stale, and firing then would
+     * turn every startup `identify()` into a duplicate decision.
+     *
+     * Calls `load()` rather than `refresh()` on purpose — `refresh()` clears
+     * impression/exposure tracking, so a context change would re-credit a
+     * presentation the user never saw again.
+     *
+     * Returns an unsubscribe function; {@link dispose} also drops it.
+     */
+    watchUserContext(): () => void;
     /**
      * Is this decision a race against a Playbook load rather than a verdict?
      *
@@ -23358,12 +23727,18 @@ declare class EntitlementGate {
     private _awaitedResult;
     private _configRetries;
     private _playbookUnsubscribe;
+    private _userContextUnsubscribe;
     constructor(sdk: RevTurbineCustomerSdk, options: EntitlementGateOptions);
     /**
-     * Stop listening for Playbook loads. Idempotent; call it when the owning
-     * component unmounts (`useEntitlement` does).
+     * Stop listening for Playbook loads and user-context changes. Idempotent; call
+     * it when the owning component unmounts (`useEntitlement` does).
      */
     dispose(): void;
+    /**
+     * Drop only the Playbook-load subscription — the within-check-cycle teardown
+     * (BL-0179). A mounted gate keeps watching the user context (BL-0004).
+     */
+    private unsubscribePlaybook;
     /** Current state snapshot. */
     get state(): EntitlementGateState;
     /** Convenience: `true` when the entitlement is allowed. */
@@ -23463,8 +23838,13 @@ declare class EntitlementGate {
      * `check()` there is nothing on screen to be stale, and firing then would
      * turn every `identify()` at startup into a redundant evaluation.
      *
+     * `sdk.convert()` reloads the UserContext (BL-0004), so this is also what
+     * flips a mounted `useCan` gate to allowed after a conversion.
+     *
      * Returns an unsubscribe function. Call it when the gate is discarded —
      * without that, a gate outlives its consumer and keeps re-checking.
+     * Idempotent: a second call returns the first subscription rather than
+     * orphaning it, and {@link dispose} drops it too.
      */
     watchUserContext(): () => void;
     private notify;