@mrrocket/sdk 0.4.0 → 0.9.0

package/dist/react-native/index.d.ts

@@ -1,19 +1,408 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 
+/**
+ * The SDK's fetch client and the shapes it reads, without React, so the script tag's widgets (src/script) use it too.
+ * `./api` re-exports all of it with the `useApi` hook.
+ */
+type PostStatus = "review" | "planned" | "progress" | "shipped";
+interface FeedbackBoardInfo {
+    id: string;
+    label: string;
+}
+interface FeedbackPost {
+    id: string;
+    title: string;
+    body: string;
+    board: string;
+    status: PostStatus;
+    votes: number;
+    comments: number;
+    voted: boolean;
+    createdAt: string;
+    /** "Lena K.", "Anonymous" or "Team". Missing from servers before SDK 0.6. */
+    author?: string;
+}
+/** The product's public face for the board's header. */
+interface FeedbackProduct {
+    name: string;
+    logo: string | null;
+    /** The domain's favicon, tried when `logo` does not load. Older servers leave it out. */
+    logoFallback?: string | null;
+}
+interface FeedbackList {
+    boards: FeedbackBoardInfo[];
+    posts: FeedbackPost[];
+    product?: FeedbackProduct;
+}
+interface FeedbackRoadmap {
+    /** `review` (Backlog) comes from servers of SDK 0.6 on. */
+    columns: {
+        review?: FeedbackPost[];
+        planned: FeedbackPost[];
+        progress: FeedbackPost[];
+        shipped: FeedbackPost[];
+    };
+}
+interface ChangelogEntry {
+    id: string;
+    title: string;
+    body: string;
+    publishedAt: string;
+}
+interface FeedbackComment {
+    id: string;
+    body: string;
+    author: string;
+    isTeam: boolean;
+    postedAt: string;
+}
+type SurveyQuestionKind = "nps" | "rating" | "single" | "multi" | "text";
+interface SurveyQuestion {
+    key: string;
+    kind: SurveyQuestionKind;
+    title: string;
+    description?: string;
+    required: boolean;
+    options?: string[];
+    scale?: number;
+    low?: string;
+    high?: string;
+    placeholder?: string;
+}
+interface SurveyDefinition {
+    id: string;
+    name: string;
+    type: string;
+    thanks: string;
+    questions: SurveyQuestion[];
+}
+type SurveyAnswer = number | string | string[];
+/** One message of the messenger's chat. "visitor" is the person on the site; the rest come from the product's team. */
+interface ChatMessage {
+    id: string;
+    from: "visitor" | "team" | "ai" | "auto";
+    body: string;
+    at: string;
+    /** Help articles an answer drew on (servers from SDK 0.9 on). */
+    articles?: {
+        id: string;
+        title: string;
+    }[];
+}
+/** A published help article in a list (the messenger's Help tab). */
+interface ArticleSummary {
+    id: string;
+    title: string;
+    collection: string;
+    excerpt: string;
+    updatedAt: string;
+}
+/** A run of text inside an article block. Links are http(s), mailto or tel only. */
+interface ArticleSpan {
+    text: string;
+    href?: string;
+    bold?: boolean;
+    italic?: boolean;
+    code?: boolean;
+}
+/** An article's content as blocks, written with textContent (never parsed as HTML). */
+type ArticleBlock = {
+    type: "h2" | "h3" | "p" | "quote";
+    spans: ArticleSpan[];
+} | {
+    type: "ul" | "ol";
+    items: ArticleSpan[][];
+} | {
+    type: "code";
+    text: string;
+} | {
+    type: "hr";
+};
+interface Article {
+    id: string;
+    title: string;
+    collection: string;
+    updatedAt: string;
+    blocks: ArticleBlock[];
+}
+/** The messenger's look and texts as set in MRRocket › Support › Messenger (servers from SDK 0.9 on). */
+interface MessengerLook {
+    accent: string;
+    theme: "light" | "dark" | "auto";
+    position: "bottom-right" | "bottom-left";
+    title: string;
+    greeting: string;
+    label: string;
+    help: boolean;
+    sound: boolean;
+    preview: boolean;
+    askEmail: boolean;
+}
+/** The visitor's newest chat (open or closed) and its messages. */
+interface ChatThread {
+    conversation: {
+        id: string;
+        status: "open" | "solved";
+    } | null;
+    messages: ChatMessage[];
+    /** The visitor gave an email already: the messenger stops asking. */
+    hasEmail: boolean;
+}
+interface Conn {
+    host: string;
+    apiKey: string;
+    distinctId: string;
+    user?: {
+        id?: string;
+        [key: string]: unknown;
+    };
+}
+/** The small fetch client behind the widgets. Every read takes an AbortSignal so unmounting cancels it. */
+declare const createApi: (c: Conn) => {
+    list: (o: {
+        board?: string;
+        sort?: "top" | "new";
+        q?: string;
+    }, signal?: AbortSignal) => Promise<FeedbackList>;
+    post: (id: string, signal?: AbortSignal) => Promise<FeedbackPost>;
+    roadmap: (signal?: AbortSignal) => Promise<FeedbackRoadmap>;
+    changelog: (signal?: AbortSignal) => Promise<{
+        entries: ChangelogEntry[];
+    }>;
+    submit: (p: {
+        title: string;
+        body?: string;
+        board: string;
+    }) => Promise<FeedbackPost>;
+    vote: (id: string) => Promise<{
+        voted: boolean;
+        votes: number;
+    }>;
+    comments: (id: string, signal?: AbortSignal) => Promise<{
+        comments: FeedbackComment[];
+    }>;
+    comment: (id: string, body: string) => Promise<FeedbackComment>;
+    survey: (url: string, signal?: AbortSignal) => Promise<{
+        survey: SurveyDefinition | null;
+    }>;
+    seen: (id: string) => Promise<unknown>;
+    respond: (id: string, r: {
+        answers: Record<string, SurveyAnswer>;
+        completed: boolean;
+        seconds: number;
+    }) => Promise<unknown>;
+    chat: (signal?: AbortSignal) => Promise<ChatThread>;
+    sendChat: (m: {
+        body: string;
+        email?: string;
+        url?: string;
+    }) => Promise<ChatThread>;
+    articles: (q?: string, signal?: AbortSignal) => Promise<{
+        articles: ArticleSummary[];
+    }>;
+    article: (id: string, signal?: AbortSignal) => Promise<Article>;
+    messengerLook: (signal?: AbortSignal) => Promise<MessengerLook>;
+    rateArticle: (id: string, helpful: boolean) => Promise<{
+        counted: boolean;
+    }>;
+};
+type Api = ReturnType<typeof createApi>;
+
+/**
+ * The cancel flow, onboarding and in-app messages (SDK 0.7.0): what MRRocket's config and `GET /api/sdk/inapp` serve,
+ * and one controller that decides what shows when and records what the person did. No DOM and no React: the web
+ * renderer (flows-ui.ts, loaded only when something shows) and the React Native one (native/flows-view.ts) draw
+ * `view()` and call the actions.
+ *
+ * What it records, as normal events under the SDK's analytics consent (nothing with consent "off"):
+ * - `$cancel_flow` `{action: "shown" | "answered" | "offer" | "finished", run, version, …}`. MRRocket turns a
+ *   `finished` with `outcome: "saved"` into a save and with `outcome: "cancelled"` into a cancellation on the Churn page.
+ *   MRRocket never changes a subscription: an accepted offer goes to the app's `onSave`, a confirmed cancel to its
+ *   `onCancel`, and only after they succeed is the outcome recorded.
+ * - `$onboarding` `{flow, step?, action: "started" | "shown" | "completed" | "dismissed"}`.
+ * - `$inapp` `{message, journey, action: "shown" | "clicked" | "dismissed"}`; the journey moves the person on.
+ */
+
+type CancelOfferKind = "discount" | "pause" | "downgrade" | "contact";
+/** What one answer of the survey offers before the confirmation. An answer without one goes straight to it. */
+interface CancelOffer {
+    kind: CancelOfferKind;
+    headline: string;
+    /** Discount: percent off. */
+    percent?: number;
+    /** Discount: for how many months; pause: up to how many months. */
+    months?: number;
+    /** Downgrade: the plan to switch to, as MRRocket knows it from the payment provider. */
+    plan?: string;
+    planName?: string;
+}
+/** The product's live cancel flow (MRRocket › Churn › Cancel flow). */
+interface CancelFlowConfig {
+    /** Grows with every publish. */
+    version: number;
+    question: string;
+    /** The survey's answers, in order. */
+    reasons: {
+        id: string;
+        label: string;
+    }[];
+    /** The offer per answer id. */
+    offers: Record<string, CancelOffer>;
+    confirm: {
+        title: string;
+        body: string;
+        button: string;
+    };
+    /**
+     * Who gets the survey and the offers: business customers only. Anyone else (a consumer, or a customer the app does
+     * not say) gets the plain confirmation, with nothing in the way of cancelling (§ 312k BGB).
+     */
+    offersFor: "business";
+}
+type OnboardingStepKind = "tour" | "checklist" | "modal";
+interface OnboardingStep {
+    id: string;
+    kind: OnboardingStepKind;
+    title: string;
+    body?: string;
+    button?: string;
+    /** Tour steps: the element they point at, marked `data-ck-target="<target>"` in the app. Without it: a card. */
+    target?: string;
+    /** Checklist items: the event that ticks them (`track("<event>")`). Without it the person ticks it themselves. */
+    event?: string;
+}
+/** A live onboarding flow's in-app steps (MRRocket › Conversion › Onboarding); its emails go out from MRRocket. */
+interface OnboardingFlow {
+    id: string;
+    name: string;
+    /** When it starts: an event's words ("Signed up", "First export"), or "First launch" / "First visit". */
+    trigger: string;
+    steps: OnboardingStep[];
+}
+/** An in-app message a Lifecycle journey has for this person. */
+interface InAppMessage {
+    id: string;
+    journey?: string;
+    title: string;
+    body?: string;
+    button?: string;
+    /** Where the button goes (http(s) or a path of the app). */
+    url?: string;
+    style: "banner" | "modal";
+}
+interface CancelFlowResult {
+    /** "cancelled": confirmed; "saved": took the offer; "kept": closed the dialog without cancelling. */
+    outcome: "cancelled" | "saved" | "kept";
+    reason?: string;
+    reasonLabel?: string;
+    offer?: CancelOffer;
+    /** What the customer wrote on the confirmation, if anything. */
+    comment?: string;
+    /** This run's id, the same as in the events. */
+    run: string;
+}
+interface CancelFlowOptions {
+    /**
+     * "business" shows the survey and the offers; anything else (the default) only the plain confirmation, so a
+     * consumer can always cancel in one step (§ 312k BGB).
+     */
+    customer?: "business" | "consumer";
+    /** The customer's current price, to show what a discount costs (`{ amount: 29, currency: "EUR" }`). */
+    price?: {
+        amount: number;
+        currency: string;
+        interval?: "month" | "year";
+    };
+    /** The customer confirmed: cancel the subscription in your code. Throwing keeps the dialog open with an error. */
+    onCancel?: (result: CancelFlowResult) => unknown;
+    /** The customer took an offer: apply it in your code (coupon, pause, plan change). Throwing keeps the dialog open. */
+    onSave?: (result: CancelFlowResult) => unknown;
+    /** Closed without cancelling or taking an offer. */
+    onClose?: (result: CancelFlowResult) => void;
+}
+/** What a renderer draws. */
+type FlowView = {
+    type: "cancel";
+    screen: "survey" | "offer" | "confirm";
+    flow: CancelFlowConfig;
+    /** The answer picked on the survey. */
+    reason?: string;
+    offer?: CancelOffer;
+    price?: CancelFlowOptions["price"];
+    busy: boolean;
+    error?: string;
+    /** The step for the dots, 1 to `steps`. */
+    step: number;
+    steps: number;
+} | {
+    type: "step";
+    flow: OnboardingFlow;
+    step: OnboardingStep;
+    index: number;
+    total: number;
+    last: boolean;
+} | {
+    type: "checklist";
+    flow: OnboardingFlow;
+    items: {
+        step: OnboardingStep;
+        done: boolean;
+    }[];
+} | {
+    type: "message";
+    message: InAppMessage;
+};
+interface FlowsController {
+    setConfig(config: CockpitConfig | null): void;
+    /** The person changed (identify, reset, consent): loads their messages and onboarding progress. */
+    refresh(): Promise<void>;
+    /** An event the app recorded: starts flows whose trigger it is and ticks checklist items. */
+    onEvent(name: string): void;
+    openCancelFlow(options?: CancelFlowOptions): Promise<CancelFlowResult>;
+    /** Starts an onboarding flow now (the first live one without an id). False when there is none to start. */
+    startOnboarding(id?: string): boolean;
+    view(): FlowView | null;
+    subscribe(listener: () => void): () => void;
+    /** `accept(comment)`: a "Talk to us" offer sends what the customer wrote with it. */
+    cancel: {
+        pick(reason: string): void;
+        next(): void;
+        accept(comment?: string): void;
+        decline(): void;
+        confirm(comment?: string): void;
+        close(): void;
+    };
+    onboarding: {
+        next(): void;
+        check(stepId: string): void;
+        dismiss(): void;
+    };
+    message: {
+        click(): void;
+        dismiss(): void;
+    };
+}
+
 /**
  * The part of the SDK that runs anywhere: experiment config, variant assignment, preview links and event shapes.
  * No React, no browser APIs, so the server helper, the proxy helper and the client share it.
  */
+
 type VariantId = string;
 /** This build of the SDK. Sent with the config request so MRRocket knows what the site runs (error tracking, flags). */
-declare const SDK_VERSION = "0.4.0";
+declare const SDK_VERSION = "0.9.0";
 /** One variant of an experiment. `changes` replaces texts that the page marks with `<Text id>`. */
 interface VariantConfig {
     id: VariantId;
     /** Share of traffic, 0 to 1. The weights of an experiment add up to 1. */
     weight: number;
     changes?: Record<string, string>;
+    /**
+     * A redirect test: where this variant sends the visitor instead of the test's page (a path like "/pricing-b" or a
+     * full address). Control has none and stays. SDK 0.7.0+.
+     */
+    url?: string;
 }
 interface ExperimentConfig {
     /** The experiment's key, the same as in Cockpit. */
@@ -23,6 +412,15 @@ interface ExperimentConfig {
     variants: VariantConfig[];
     /** A winner that shipped: everyone gets it, and nobody is assigned anymore. */
     winner?: VariantId;
+    /** A redirect test: the path of the page it runs on ("/pricing"). Visitors there are sent to their variant's `url`. */
+    path?: string;
+}
+/** A page redirect set in MRRocket (Conversion › Landing pages › Redirect): everyone on `from` goes to `to`. SDK 0.7.0+. */
+interface RedirectConfig {
+    /** A path of the site, like "/old-pricing". */
+    from: string;
+    /** A path or a full address. */
+    to: string;
 }
 interface CockpitConfig {
     /** The product the public key belongs to. */
@@ -36,6 +434,20 @@ interface CockpitConfig {
     replay?: ReplayConfig;
     /** Feature flags of the product in Production (MRRocket › Build › Feature flags), evaluated by `useFlag` and `getFlag`. */
     flags?: FlagConfig[];
+    /**
+     * Published copy for texts the site marks (`<Text id>`, `data-ck-text`): a landing page's headline, subheadline and
+     * button (`pricing.headline` …) and a paywall's (`paywall.<placement>.headline` …) as published in MRRocket. A
+     * running test's variant changes them on top. Missing when nothing is published. SDK 0.5.0+.
+     */
+    texts?: Record<string, string>;
+    /** The product's live cancel flow (MRRocket › Churn › Cancel flow), for `cancelFlow.open()`. SDK 0.7.0+. */
+    cancelFlow?: CancelFlowConfig;
+    /** The in-app steps of live onboarding flows (tours, checklists, modals). SDK 0.7.0+. */
+    onboarding?: OnboardingFlow[];
+    /** A live Lifecycle journey has in-app messages: signed-in people ask `/api/sdk/inapp` for theirs. SDK 0.7.0+. */
+    messages?: boolean;
+    /** Page redirects set in MRRocket; the SDK sends visitors on before the page shows (`redirectFor`). SDK 0.7.0+. */
+    redirects?: RedirectConfig[];
 }
 /** One condition of a flag's audience, on a property of the person (`identify(id, props)`), the id or the page. */
 interface FlagCondition {
@@ -118,6 +530,14 @@ interface AppContext {
     locale?: string;
 }
 
+/**
+ * The React Native client without React: the event queue (batched, persisted for offline use, retried with backoff),
+ * the app lifecycle (`$app_open`, `$app_background`, a new session after 30 minutes away), screens, identity and
+ * consent, the cached config for flags and experiments, install attribution from the first open's deep link, and error
+ * capture. Everything the platform gives (storage, AppState, ErrorUtils, device info, fetch) comes in as `deps`, so
+ * it runs in tests without React Native; `platform.ts` builds the real ones.
+ */
+
 /**
  * What the app may send and store.
  * - "anonymous" (default): no id is stored on the device. Events go without a person id until `identify()` (MRRocket
@@ -147,6 +567,16 @@ interface MRRocketOptions {
     maxQueue?: number;
     /** Log what the SDK does to the console. */
     debug?: boolean;
+    /** Onboarding flows start on their own when the person does their trigger (default true). False: only `startOnboarding()`. */
+    onboarding?: boolean;
+    /** Taps go to Heatmaps as clicks on the screen they happened on (default true; `MRRocketProvider` captures them). */
+    heatmaps?: boolean;
+    /**
+     * The person agreed to session recordings (default false; ask them first). Needs `react-native-view-shot` and the
+     * product's recordings switched on in MRRocket. No frame while the keyboard is open; wrap private views in
+     * `<MRRocketMask>`. Change it later with `setReplay`.
+     */
+    replay?: boolean;
 }
 /** AsyncStorage's shape. */
 interface KeyValueStorage {
@@ -154,11 +584,29 @@ interface KeyValueStorage {
     setItem(key: string, value: string): Promise<void>;
     removeItem(key: string): Promise<void>;
 }
+interface RegisterForPushOptions {
+    /** Ask for the permission when it was not decided yet (default true). False: only register when already allowed. */
+    ask?: boolean;
+    /** Your EAS project id; default: the one in your app config (`expo-constants`). */
+    projectId?: string;
+}
+type NativePushStatus = "registered" | "denied" | "not-asked" | "unavailable" | "not-signed-in" | "error";
+interface NativePushResult {
+    status: NativePushStatus;
+    /** The Expo push token, once registered. */
+    token?: string;
+    /** Why it is unavailable or failed. */
+    reason?: string;
+}
 /** What the app (and the React hooks) use. */
 interface MRRocketClient {
     track(event: string, props?: Record<string, unknown>): void;
     /** A screen view: a route name ("Settings") or an Expo Router path ("/settings"). */
     screen(name: string, props?: Record<string, unknown>): void;
+    /** A tap at screen points (x, y) for Heatmaps, on the current screen; `MRRocketProvider` calls it. */
+    tap(x: number, y: number): void;
+    /** The person's answer to session recordings (`replay` in the options); false stops and forgets what was not sent. */
+    setReplay(on: boolean): void;
     identify(id: string, props?: Record<string, unknown>): void;
     /** Forgets the signed-in person (sign-out): a new anonymous id and a new session. */
     reset(): void;
@@ -172,6 +620,35 @@ interface MRRocketClient {
     peekVariant(key: string): VariantId;
     /** Records that the person saw `variant` of `key`, once per screen. */
     expose(key: string, variant: VariantId): void;
+    /**
+     * The copy for text `id` as published in MRRocket (a paywall's `paywall.<placement>.headline`, an onboarding title …)
+     * with this person's experiment variant applied on top, the same rules as `<Text id>` on the web; `fallback` (your
+     * own words) while nothing is published or the config is unknown. Records the exposure to every test that changes
+     * `id`, once per screen.
+     */
+    getText(id: string, fallback: string): string;
+    /** The text without recording anything (render code); undefined when MRRocket has none. Pair it with `exposeText`. */
+    peekText(id: string): string | undefined;
+    /** Records that the person saw text `id`: an exposure to each test that changes it, once per screen. */
+    exposeText(id: string): void;
+    /**
+     * Shows the cancel flow built in MRRocket › Churn (drawn by `<MRRocketProvider>`), resolves with what the customer
+     * did. MRRocket never changes the subscription: your `onCancel` and `onSave` do.
+     */
+    openCancelFlow(options?: CancelFlowOptions): Promise<CancelFlowResult>;
+    /** Starts an onboarding flow now (the first live one without an id). False when there is none. */
+    startOnboarding(id?: string): boolean;
+    /**
+     * Push notifications from your Lifecycle journeys for the signed-in person (call `identify` first). Asks the
+     * permission (unless `ask: false`), gets the Expo push token and sends it to MRRocket. Needs `expo-notifications`.
+     * Safe to call on every start: an existing token is sent again without asking. Opens of MRRocket's notifications
+     * are counted from then on.
+     */
+    registerForPush(options?: RegisterForPushOptions): Promise<NativePushResult>;
+    /** Removes this device's token for the signed-in person (sign-out does it on its own in `reset`). */
+    unregisterForPush(): Promise<boolean>;
+    /** The cancel flow, onboarding and messages for a renderer (the provider's, or your own). */
+    flows: FlowsController;
     /** Sends what is queued now. */
     flush(): Promise<void>;
     /** Resolves once stored state and the config (cached or fetched) are known. */
@@ -179,6 +656,23 @@ interface MRRocketClient {
     isReady(): boolean;
     getDistinctId(): string;
     getConsent(): NativeConsent;
+    /**
+     * The client of the SDK's widget API (surveys, feedback, the messenger) for the person now: their id, and the name and
+     * email given to identify (or `as`, typed into a widget). Null while the consent is off or without a key.
+     */
+    api(as?: {
+        name?: string;
+        email?: string;
+    }): Api | null;
+    /** The signed-in person (identify): their id, and the name and email given there. Undefined before identify. */
+    getUser(): {
+        id: string;
+        name?: string;
+        email?: string;
+    } | undefined;
+    /** Surveys answered or closed on this device: not shown again (kept on the device only with "persistent"). */
+    isSurveyDone(id: string): boolean;
+    markSurveyDone(id: string): void;
     getConfig(): CockpitConfig | null;
     /** For React: called after every change flags, variants or the consent depend on. Returns the unsubscribe. */
     subscribe(listener: () => void): () => void;
@@ -192,6 +686,93 @@ interface MRRocketClient {
 /** The name of the screen a React Navigation state shows: the focused route, followed into nested navigators. */
 declare const activeRouteName: (state: unknown) => string | undefined;
 
+interface NativeAppearance {
+    theme?: "light" | "dark" | "auto";
+    accent?: string;
+}
+declare const MRRocketFlows: ({ flows, appearance }: {
+    flows: FlowsController;
+    appearance?: NativeAppearance;
+}) => react.FunctionComponentElement<Record<string, unknown>> | null;
+
+interface Palette {
+    accent: string;
+    bg: string;
+    fg: string;
+    muted: string;
+    soft: string;
+    line: string;
+    danger: string;
+}
+/** Asks the person the survey MRRocket picks for them, a few seconds after start and again for a new person. */
+declare const MRRocketSurveys: ({ client, appearance }: {
+    client: MRRocketClient;
+    appearance?: NativeAppearance;
+}) => react.FunctionComponentElement<{
+    survey: SurveyDefinition;
+    api: Api;
+    p: Palette;
+    onDone: () => void;
+}> | null;
+/** Opens the feedback sheet: the top requests with votes, and a form to suggest one. */
+declare const useFeedback: () => {
+    open: () => void;
+    close: () => void;
+};
+interface NativeFeedbackOptions {
+    /** The sheet's title. Default "Feedback". */
+    title?: string;
+}
+declare const MRRocketFeedback: ({ client, appearance, options }: {
+    client: MRRocketClient;
+    appearance?: NativeAppearance;
+    options?: NativeFeedbackOptions;
+}) => react.FunctionComponentElement<{
+    client: MRRocketClient;
+    p: Palette;
+    title: string;
+}> | null;
+type MsgView = "home" | "messages" | "help" | {
+    article: string;
+};
+/** Opens (on Home, a tab or `{ article: id }`), closes or toggles the messenger. */
+declare const useMessenger: () => {
+    open: (view?: MsgView) => void;
+    close: () => void;
+    toggle: () => void;
+};
+interface NativeMessengerOptions {
+    /** A round chat button bottom right (default false: open it with `useMessenger().open()` from your own button). */
+    launcher?: boolean;
+    title?: string;
+    /** The big line on Home and the first line of an empty chat. */
+    greeting?: string;
+    /** Ask people the app did not identify with an email for an email (optional for them). Default true. */
+    askEmail?: boolean;
+    /** The Help tab with your published help articles (default true; hidden while there are none). */
+    help?: boolean;
+    /** A banner at the top when an answer arrives while the messenger is closed (default true). */
+    preview?: boolean;
+    /** A light haptic when an answer arrives (default true; needs expo-haptics). */
+    haptics?: boolean;
+}
+declare const MRRocketMessenger: ({ client, appearance, options: given }: {
+    client: MRRocketClient;
+    appearance?: NativeAppearance;
+    options?: NativeMessengerOptions;
+}) => react.FunctionComponentElement<Record<string, unknown>> | null;
+
+/**
+ * Hides what it wraps in session recordings: its area is painted black on every frame before the frame is stored. Use
+ * it for anything private on screen (balances, addresses, messages). Text fields need no wrapper: nothing is recorded
+ * while the keyboard is open.
+ *
+ *     <MRRocketMask><Text>{iban}</Text></MRRocketMask>
+ */
+declare const MRRocketMask: ({ children, style }: {
+    children?: ReactNode;
+    style?: unknown;
+}) => react.FunctionComponentElement<Record<string, unknown>>;
 /**
  * The SDK's client outside React (a background task, a store, an API layer): the one the provider made, or a new one.
  * One client per app; a second call returns the first.
@@ -208,6 +789,24 @@ interface MRRocketProviderProps extends Partial<MRRocketOptions> {
     storage?: KeyValueStorage | null;
     /** A client you made with createMRRocket; the other props are then ignored. */
     client?: MRRocketClient;
+    /**
+     * Draw the cancel flow, onboarding and in-app messages (default true). False: draw `client.flows` yourself, or
+     * place `<MRRocketFlows flows={client.flows} />` where you want it.
+     */
+    flows?: boolean;
+    /** The look of those dialogs and the widgets: `{ theme: "light" | "dark" | "auto", accent: "#0f766e" }`. */
+    appearance?: NativeAppearance;
+    /** Show the live in-app survey MRRocket picks for the person, a few seconds after start (default true). */
+    surveys?: boolean;
+    /** The chat with your team, opened with `useMessenger().open()`; `{ launcher: true }` adds a round button. False: none. */
+    messenger?: NativeMessengerOptions | false;
+    /** The feedback sheet opened with `useFeedback().open()` (`{ title }`). False: none. */
+    feedback?: NativeFeedbackOptions | false;
+    /**
+     * Taps for Heatmaps (default true). The provider then wraps the app in one `View` with `flex: 1` to see them; false
+     * leaves the app as it is.
+     */
+    heatmaps?: boolean;
     children?: ReactNode;
 }
 /**
@@ -215,7 +814,7 @@ interface MRRocketProviderProps extends Partial<MRRocketOptions> {
  * starts the SDK: lifecycle events, the event queue, flags and experiments, error capture. Changing `consent` later
  * calls setConsent.
  */
-declare const MRRocketProvider: ({ client: given, children, consent, ...options }: MRRocketProviderProps) => react.FunctionComponentElement<react.ProviderProps<MRRocketClient | null>>;
+declare const MRRocketProvider: ({ client: given, children, consent, flows, appearance, surveys, messenger, feedback, heatmaps, ...options }: MRRocketProviderProps) => react.FunctionComponentElement<react.ProviderProps<MRRocketClient | null>>;
 /**
  * `track`, `screen`, `identify`, `reset`, `setConsent`, `captureError`, `flush`, the visitor id, the consent and whether
  * flags and experiments have loaded.
@@ -226,12 +825,40 @@ declare const useMRRocket: () => {
     identify: (id: string, props?: Record<string, unknown>) => void;
     reset: () => void;
     setConsent: (consent: NativeConsent) => void;
+    setReplay: (on: boolean) => void;
     captureError: (error: unknown) => void;
     flush: () => Promise<void>;
     distinctId: string;
     consent: NativeConsent;
     ready: boolean;
 };
+/**
+ * The cancel flow built in MRRocket › Churn › Cancel flow. Call `open` from your Cancel button; the provider draws it.
+ * MRRocket never changes the subscription: your `onCancel` and `onSave` do (RevenueCat, your server, the store's
+ * subscription page).
+ *
+ *     const cancelFlow = useCancelFlow();
+ *     <Button title="Cancel subscription" onPress={() => cancelFlow.open({ customer: "consumer", onCancel: openStoreSubscriptions })} />
+ */
+declare const useCancelFlow: () => {
+    open: (options?: CancelFlowOptions) => Promise<CancelFlowResult>;
+};
+/**
+ * Push notifications from your Lifecycle journeys (needs `expo-notifications`). After sign-in (`identify`), call
+ * `register()`: it asks the permission, gets the Expo push token and sends it to MRRocket. Sign-out (`reset`) takes the
+ * token back on its own.
+ *
+ *     const push = usePush();
+ *     useEffect(() => { if (user) void push.register(); }, [user]);
+ */
+declare const usePush: () => {
+    register: MRRocketClient["registerForPush"];
+    unregister: MRRocketClient["unregisterForPush"];
+};
+/** Starts an onboarding flow now (the first live one without an id), whatever its trigger. */
+declare const useOnboarding: () => {
+    start: (id?: string) => boolean;
+};
 /** A feature flag from MRRocket › Build › Feature flags: true while it is on for this person; false while off, unknown or loading. */
 declare const useFlag: (key: string) => boolean;
 /** The variant of a multivariate flag ("control", "test" …), or null while it is off. */
@@ -241,6 +868,16 @@ declare const useFlagVariant: (key: string) => string | null;
  * cold start, so the first screen is already stable). Records the exposure once per screen.
  */
 declare const useVariant: (key: string) => VariantId;
+/**
+ * Copy MRRocket can change without an app update: the text published for `id` (a paywall's
+ * `paywall.<placement>.headline`, `.body`, `.cta`), with this person's variant of a running text test on top,
+ * the same rules as `<Text id>` on the web. Write your own words as `fallback`: they show while nothing is published
+ * and on a first start before the config arrives. Records the exposure to every test that changes `id`, once per screen.
+ *
+ *     const headline = useText("paywall.onboarding.headline", "Unlock everything");
+ *     <Text style={styles.title}>{headline}</Text>
+ */
+declare const useText: (id: string, fallback: string) => string;
 /**
  * Screen views for Expo Router: one `$screen` per path ("/settings", "/product/[id]" as its real path). Call it in a
  * component inside both the router and MRRocketProvider, for example the root layout's child.
@@ -256,4 +893,4 @@ declare const useExpoRouterTracking: () => void;
  */
 declare const useNavigationTracking: () => (state: unknown) => void;
 
-export { type AppContext, type CockpitConfig, type FlagConfig, type KeyValueStorage, type MRRocketClient, type MRRocketOptions, MRRocketProvider, type MRRocketProviderProps, type NativeConsent, SDK_VERSION, type VariantId, activeRouteName, createMRRocket, getMRRocket, useExpoRouterTracking, useFlag, useFlagVariant, useMRRocket, useNavigationTracking, useVariant };
+export { type AppContext, type CancelFlowConfig, type CancelFlowOptions, type CancelFlowResult, type CancelOffer, type ChatMessage, type ChatThread, type CockpitConfig, type FeedbackPost, type FlagConfig, type FlowView, type InAppMessage, type KeyValueStorage, type MRRocketClient, MRRocketFeedback, MRRocketFlows, MRRocketMask, MRRocketMessenger, type MRRocketOptions, MRRocketProvider, type MRRocketProviderProps, MRRocketSurveys, type NativeAppearance, type NativeConsent, type NativeFeedbackOptions, type NativeMessengerOptions, type NativePushResult, type NativePushStatus, type OnboardingFlow, type OnboardingStep, type RegisterForPushOptions, SDK_VERSION, type SurveyDefinition, type VariantId, activeRouteName, createMRRocket, getMRRocket, useCancelFlow, useExpoRouterTracking, useFeedback, useFlag, useFlagVariant, useMRRocket, useMessenger, useNavigationTracking, useOnboarding, usePush, useText, useVariant };