@scalebun-release/react-native 2.5.0

package/lib/typescript/features/engage/EngageInAppView.d.ts

@@ -0,0 +1,164 @@
+/**
+ * ScaleBun SDK — Engage In-App Message View (shared cross-platform JS overlay, D4)
+ *
+ * One renderer, seven layout branches — chosen from `InAppMessageConfig.layout`
+ * delivered by the config lane. App developers import and mount ONE component
+ * (`EngageInAppView` or via `EngagePromptProvider`) and write zero layout code:
+ * the SDK reads the layout field and auto-selects the correct branch.
+ *
+ * Layout → branch mapping (1:1, config-driven):
+ *   modal        → centered dialog (backdrop + rounded card)
+ *   fullscreen   → edge-to-edge takeover (no margins, no rounded corners)
+ *   bottom_sheet → slides up from bottom (rounded top corners)
+ *   top_banner   → absolute strip pinned to top
+ *   bottom_banner→ absolute strip pinned to bottom
+ *   tooltip      → small compact popup (anchored look, top-right close)
+ *   toast        → transient strip, auto-dismisses after 3 seconds
+ *
+ * Legacy `banner` (old wire value) gracefully maps to `top_banner`.
+ *
+ * Callbacks (unchanged):
+ *   onShow()      — fired once when first visible (provider records impression)
+ *   onCta(cta)    — primary CTA tap (provider emits `click`; deep link surfaced to host)
+ *   onComplete()  — guided flow finished (provider emits `completion`)
+ *   onDismiss()   — secondary CTA / close / backdrop / auto-dismiss (provider emits `dismiss`)
+ */
+import { type ReactElement, type ReactNode } from 'react';
+import type { InAppGameRequestHandler, InAppGameResult, InAppMessageConfig, InAppRenderSpec } from './engageTypes';
+import { type EngageAnchorRect } from './EngageAnchor';
+import { type InAppMountModel, type ResolvedInAppPresentation } from './engageVariantResolver';
+import { type InAppOutcomeRequest } from './engageOutcome';
+/** The seven distinct presentation branches (config-driven, 1:1 with layout strings). */
+export type InAppLayout = 'modal' | 'fullscreen' | 'bottom_sheet' | 'top_banner' | 'bottom_banner' | 'tooltip' | 'toast';
+/**
+ * Map the contract `layout` string onto one of the seven render branches.
+ * Legacy `banner` value → `top_banner` for backward compat with old configs.
+ * Any unknown future value → `modal` (safe default).
+ */
+export declare function resolveInAppLayout(layout: InAppMessageConfig['layout']): InAppLayout;
+/** Props every in-app render branch receives (the Open/Closed contract). */
+export interface InAppBranchProps {
+    spec: InAppRenderSpec;
+    /** Canonical registry key, used to select family-specific content modes. */
+    variantKey?: string;
+    /** Resolved design tokens (dashboard-matching defaults + spec overrides). */
+    theme: InAppTheme;
+    /** Primary CTA tapped — provider emits `click` and surfaces `cta.deepLink`. */
+    onCta: (cta: NonNullable<InAppRenderSpec['cta']>) => void;
+    /** Dismissed (secondary CTA / close / backdrop / auto-timeout) — provider emits `dismiss`. */
+    onDismiss: () => void;
+    /** Finished a guided flow — provider emits `completion`, never a click/dismiss. */
+    onComplete?: () => void;
+    /** Present an authored terminal result/confirmation card before the final action. */
+    onOutcome?: (request: InAppOutcomeRequest) => void;
+    /** Optional additive gameplay telemetry; never used to determine a reward. */
+    onInteraction?: (interaction: InAppMechanicInteraction) => void;
+    /** Customer-backend result resolver. Retries reuse the same SDK-owned attempt id. */
+    requestGameResult?: (attempt?: number, input?: Record<string, unknown>) => Promise<InAppGameResult>;
+    /** Anchored surfaces call this only after their native target has been measured. */
+    onReady?: () => void;
+    /** Anchored surfaces report a missing/invalid target instead of faking a position. */
+    onRenderError?: (reason: string) => void;
+    /** Optional family-specific body. The layout branch remains responsible for mounting. */
+    children?: ReactNode;
+}
+export interface InAppMechanicInteraction {
+    mechanic: string;
+    phase: 'started' | 'progress' | 'decision' | 'resolved' | 'claimed' | 'completed';
+    attempt?: number;
+    progress?: number;
+    result?: string;
+    value?: string | number | boolean;
+    meta?: Record<string, unknown>;
+}
+/** A render branch for one in-app layout. */
+export type InAppRenderer = (props: InAppBranchProps) => ReactElement | null;
+export type CoachmarkPlacement = 'auto' | 'top' | 'bottom' | 'left' | 'right';
+export interface CoachmarkGeometry {
+    spotlight: EngageAnchorRect;
+    scrims: EngageAnchorRect[];
+    tooltip: {
+        left: number;
+        width: number;
+        top?: number;
+        bottom?: number;
+        maxHeight: number;
+        placement: Exclude<CoachmarkPlacement, 'auto'>;
+        arrowLeft?: number;
+        arrowTop?: number;
+    };
+}
+/** Pure geometry shared by iOS/Android and covered without a native measurement mock. */
+export declare function resolveCoachmarkGeometry(anchor: EngageAnchorRect, viewport: {
+    width: number;
+    height: number;
+}, preferred?: CoachmarkPlacement, options?: {
+    insets?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    cardHeight?: number;
+}): CoachmarkGeometry;
+export interface InAppTheme {
+    dark: boolean;
+    rtl: boolean;
+    accent: string;
+    cardBg: string;
+    titleColor: string;
+    bodyColor: string;
+    ctaText: string;
+    secondaryColor: string;
+    couponBg: string;
+    couponFg: string;
+    couponBorder: string;
+    backdrop: string;
+}
+/** Resolve dashboard-matching tokens, applying `spec.style` overrides on top. */
+export declare function resolveTheme(spec: InAppRenderSpec): InAppTheme;
+export declare function resolveToastDuration(value: unknown): number;
+export declare const INAPP_RENDERERS: Record<InAppLayout, InAppRenderer>;
+/** Resolve the render branch for a config layout (always defined). */
+export declare function resolveInAppRenderer(layout: InAppMessageConfig['layout']): InAppRenderer;
+/**
+ * Resolve canonical additive surfaces before degrading to the stable seven-layout
+ * registry. Content remains a child of the selected surface in either path.
+ */
+export declare function resolveInAppPresentationRenderer(presentation: Pick<ResolvedInAppPresentation, 'archetype' | 'mountModel' | 'legacyLayout' | 'variantKey'>, mountModelOverride?: InAppMountModel): InAppRenderer;
+export interface EngageInAppViewProps {
+    message: InAppMessageConfig | null;
+    visible: boolean;
+    /**
+     * Optional render spec override (A/B experiment, D8/J6). When supplied, this
+     * spec is rendered instead of `message.spec` — the provider resolves the chosen
+     * variant's content and passes it here. Omitted ⇒ render `message.spec`.
+     */
+    spec?: InAppRenderSpec;
+    /**
+     * Provider-only graceful degradation for an unavailable host placement.
+     * Content still resolves from the canonical variant; only its physical mount changes.
+     */
+    mountModelOverride?: InAppMountModel;
+    /** Fired once when the message first becomes visible (provider → impression). */
+    onShow: () => void;
+    /** Primary CTA tapped — provider emits `click` + surfaces the deep link. */
+    onCta: (cta: NonNullable<InAppRenderSpec['cta']>) => void;
+    /** Dismissed — provider emits `dismiss`. */
+    onDismiss: () => void;
+    /** Guided flow finished — provider emits `completion`. */
+    onComplete?: () => void;
+    /** Optional host-visible mechanic lifecycle callback. */
+    onInteraction?: (interaction: InAppMechanicInteraction) => void;
+    /** Customer-owned backend resolver for the eight gamified variants. */
+    onInAppGameRequest?: InAppGameRequestHandler;
+    /** Render failed (malformed spec / render throw) — provider emits `render_failed`. */
+    onRenderError?: (reason: string) => void;
+}
+/**
+ * Single mount point for in-app messages. Reads `message.layout`, auto-selects
+ * the correct renderer from the registry, fires `onShow()` exactly once per
+ * message. App developers write zero layout code.
+ */
+export declare function EngageInAppView({ message, visible, spec, mountModelOverride, onShow, onCta, onDismiss, onComplete, onInteraction, onInAppGameRequest, onRenderError, }: EngageInAppViewProps): ReactElement | null;
+//# sourceMappingURL=EngageInAppView.d.ts.map

package/lib/typescript/features/engage/EngageInlinePlacement.d.ts

@@ -0,0 +1,42 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type EngageInAppViewProps } from "./EngageInAppView";
+import type { InAppRenderSpec } from "./engageTypes";
+/** Everything a registered host slot needs to render one provider-owned message. */
+export type EngageInlineDelivery = Omit<EngageInAppViewProps, "visible">;
+type DeliverySink = (delivery: EngageInlineDelivery | null) => void;
+export interface EngageInlinePlacementRegistry {
+    register: (placementKey: string, sink: DeliverySink) => () => void;
+    deliver: (placementKey: string, delivery: EngageInlineDelivery) => boolean;
+    clear: (placementKey: string, messageId?: string) => void;
+    has: (placementKey: string) => boolean;
+    subscribe: (placementKey: string, listener: () => void) => () => void;
+}
+/**
+ * Pure React placement registry. A pending delivery is retained so provider effects
+ * and slot effects are order-independent. Only the newest slot owns a key; replacing
+ * one clears the older sink and stale cleanup cannot unregister the new owner.
+ */
+export declare function createEngageInlinePlacementRegistry(): EngageInlinePlacementRegistry;
+export interface EngageInlinePlacementRoute {
+    placementKey: string;
+    fallback: "overlay" | "skip";
+}
+/** Normalize the existing `ext.placementKey` / `ext.fallback` wire contract. */
+export declare function resolveEngageInlinePlacement(spec: InAppRenderSpec | undefined): EngageInlinePlacementRoute;
+export declare function EngageInlinePlacementProvider({ registry, children, }: {
+    registry: EngageInlinePlacementRegistry;
+    children: ReactNode;
+}): ReactElement;
+export interface ScaleBunInlineSlotProps {
+    /** Must match the dashboard-authored `placementKey` (for example `feed.top`). */
+    placementKey: string;
+    /** Host content shown while no campaign owns this placement. */
+    children?: ReactNode;
+}
+/**
+ * Host placeholder for provider-delivered inline campaigns. The active message is
+ * rendered here in the normal React Native layout tree, never as a root sibling.
+ */
+export declare function ScaleBunInlineSlot({ placementKey, children, }: ScaleBunInlineSlotProps): ReactElement;
+export {};
+//# sourceMappingURL=EngageInlinePlacement.d.ts.map

package/lib/typescript/features/engage/EngagePromptProvider.d.ts

@@ -0,0 +1,233 @@
+/**
+ * ScaleBun SDK — Engage Prompt Provider (campaign renderer core, D4)
+ *
+ * Wraps the host app and owns the campaign-render lifecycle for the shared
+ * cross-platform JS overlay:
+ *   1. on a trigger (app-controlled via `showEngagePrompt()` and/or the campaign's
+ *      own `trigger` from config), calls `facade.engage.fetchConfig()`,
+ *   2. runs the throttle/decision core (`selectCampaignToRender`) to pick which
+ *      campaign — if any — is eligible, honoring frequency caps,
+ *   3. mounts the parameterized `EngagePromptView` (Open/Closed: NPS now,
+ *      ratings/feedback/survey later via the renderer registry),
+ *   4. on submit → `facade.engage.submitResponse({ surveyId, score, text })`
+ *      (transport stamps `responseId` UUID + `schemaVersion` per contract),
+ *      records the impression as completed, and emits an in-app dismiss/submit
+ *      tracking event,
+ *   5. on dismiss → `facade.engage.trackEvent` with a `dismiss` event.
+ *
+ * The provider depends only on the `engage` namespace shape — NOT the whole
+ * facade — so it stays decoupled and testable, and reuses the existing transport
+ * (no second HTTP path).
+ *
+ * IN-APP MESSAGES (the second Engage family, §2.4/§2.5) are surfaced by this SAME
+ * provider — NOT a parallel one. `showInAppMessage()` fetches the config, picks an
+ * eligible message from `inAppMessages[]` (shared throttle store), and mounts the
+ * config-driven `EngageInAppView` (banner/modal/overlay). Events: `impression` on
+ * show, `click` on CTA tap (the resolved deep link is surfaced to the host via
+ * `onInAppDeepLink` — the SDK never opens URLs), `dismiss` on close.
+ *
+ * PRECEDENCE (campaign vs in-app): a campaign prompt wins the screen. If a
+ * campaign prompt is already visible, `showInAppMessage()` is a no-op (returns
+ * false) and the mounted in-app view is hidden while a campaign is up, so the two
+ * families never fight for the screen.
+ */
+import { type ReactNode, type ReactElement } from 'react';
+import { type RatingPromptConfig } from './EngagePromptView';
+import type { SubmitStage } from './EngageTransport';
+import type { EngageAttachmentDraft, EngageCampaignConfig, EngageCampaignType, EngageConfigContext, EngageConfigResponse, EngageEventInput, InAppGameRequestHandler, EngageResponseInput, InAppMessageConfig, InAppRenderSpec, RatingFunnelEventInput, SurveyAnswer, SurveyImpressionInput } from './engageTypes';
+/** Preserve a multi-question survey answer in the keyed wire shape (§1.4). */
+export declare function toWireAnswers(answers: SurveyAnswer[]): {
+    key: string;
+    value: string | number | string[];
+}[];
+/**
+ * The slice of the SDK facade the renderer consumes (the `engage` namespace).
+ * Matching this shape — rather than importing the facade — keeps the renderer a
+ * pure consumer of the foundation transport and trivially testable.
+ */
+export interface EngageRendererFacade {
+    /** External user id last supplied through ScaleBun.identify(). */
+    getIdentifiedUserId?: () => string | undefined;
+    fetchConfig: (context?: EngageConfigContext) => Promise<EngageConfigResponse | null>;
+    trackCoachmarkEvent?: (name: string, properties: Record<string, unknown>) => void;
+    submitResponse: (input: EngageResponseInput) => void;
+    /**
+     * [P3-e] Submit a response with native attachments (screenshot/voice). Optional
+     * so a host wired to an older facade still renders prompts (media silently
+     * degrades to a plain response).
+     */
+    submitResponseWithAttachments?: (input: EngageResponseInput, attachments: EngageAttachmentDraft[]) => void;
+    /**
+     * [Slice D5] CONFIRMED submit used by the reusable submitting→success→error state
+     * machine: resolves only on real server persistence, rejects on failure, idempotent
+     * on `responseId`. Optional so an older facade still renders prompts (falls back to
+     * the fire-and-forget lanes, which resolve immediately).
+     */
+    submitResponseConfirmed?: (input: EngageResponseInput, attachments: EngageAttachmentDraft[], opts: {
+        responseId: string;
+        onStage?: (stage: SubmitStage) => void;
+    }) => Promise<void>;
+    trackEvent: (input: EngageEventInput) => void;
+    trackSurveyImpression?: (input: SurveyImpressionInput) => void;
+    /**
+     * Force-flush queued in-app events immediately (bypassing the batch threshold/timer).
+     * Called right after a TEST preview's impression/dismiss ACK so the backend consumes
+     * the one-shot preview row before the app can be backgrounded/killed — otherwise a
+     * still-`delivered` row re-serves on the next reopen. Optional: an older facade simply
+     * relies on the periodic flush (eventual consistency).
+     */
+    flushEvents?: () => void;
+    /**
+     * Submit a 1–5 app-store rating via the EXISTING rating lane (NOT
+     * submitResponse — D1 keeps app-ratings a distinct funnel). The provider
+     * passes a client `clientRatingId` for idempotency (D8). Optional so a host
+     * that never shows RATING_PROMPT need not supply it.
+     */
+    submitRating?: (input: {
+        rating: number;
+        comment?: string;
+        source?: 'in_app' | 'prompt' | 'manual';
+        clientRatingId?: string;
+    }) => unknown;
+    /**
+     * Emit a rating-funnel tracking fact (ratings-rebuild CONTRACT §1.2) — eligible/
+     * shown/dismissed/selected/redirect. NOT a campaign response (D1). Optional so an
+     * older facade still renders rating prompts (the funnel just goes uninstrumented).
+     */
+    emitRatingEvent?: (input: RatingFunnelEventInput) => void;
+    /**
+     * Trigger the native in-app review sheet (D5). Resolves `true` only when the OS
+     * flow ran/resolved after a positive route, so the provider emits
+     * `store_redirect_clicked` solely on a `true` result. Optional/fail-soft.
+     */
+    requestStoreReview?: () => Promise<boolean>;
+}
+/**
+ * Host-app RATING_PROMPT routing config. The store deeplink is NEVER hardcoded —
+ * the host supplies either a static `storeUrl` or an `onHighRating` callback (e.g.
+ * `Linking.openURL(...)` / native `requestReview()`), and an `onLowRating` for the
+ * feedback hand-off. The provider only decides WHICH callback to invoke.
+ */
+export interface EngageRatingRouting extends RatingPromptConfig {
+    /** App-store deeplink opened on a high rating (host owns the navigation). */
+    storeUrl?: string;
+    /** Called on a high rating (>= threshold). Receives the resolved store URL if set. */
+    onHighRating?: (info: {
+        rating: number;
+        campaign: EngageCampaignConfig;
+        storeUrl?: string;
+    }) => void;
+    /** Called on a low rating when routing to feedback (host opens its form). */
+    onLowRating?: (info: {
+        rating: number;
+        campaign: EngageCampaignConfig;
+    }) => void;
+}
+export interface ShowEngagePromptOptions {
+    /** Restrict to specific campaign types. Defaults to `['NPS']` (NPS-first slice). */
+    types?: EngageCampaignType[];
+    /** Match a campaign's `targetScreen` to the current screen. */
+    screen?: string;
+    /**
+     * Restrict to campaigns whose `trigger` equals this value (behavioral-trigger
+     * path, e.g. `'screen_exit'`). Omitted ⇒ trigger-agnostic (manual fire).
+     */
+    trigger?: string;
+    /** Event name for `custom_event` / `after_purchase` (matches `triggerConfig.event`). */
+    event?: string;
+    /** Action label for `failed_action` (matches `triggerConfig.action`). */
+    action?: string;
+    /** Fired `time_in_app` threshold, used to select only that configured timer. */
+    seconds?: number;
+    /** App/user context forwarded to the config fetch for server-side targeting. */
+    context?: EngageConfigContext;
+}
+export interface ShowInAppMessageOptions {
+    /** Match a message's `targetScreen` to the current screen. */
+    screen?: string;
+    /**
+     * Restrict to messages whose `trigger` equals this value (behavioral-trigger
+     * path, e.g. `'session_start'`). Omitted ⇒ trigger-agnostic (manual host call).
+     */
+    trigger?: string;
+    /** Fired business/custom event name, matched against `message.eventName`. */
+    event?: string;
+    /** Fired action value for forward-compatible action-specific messages. */
+    action?: string;
+    /** Fired `time_delay` threshold, used to select only that configured message. */
+    seconds?: number;
+    /** App/user context forwarded to the config fetch for server-side targeting. */
+    context?: EngageConfigContext;
+}
+/**
+ * The host's deep-link sink for an in-app CTA tap. The SDK NEVER opens a URL — it
+ * hands the resolved `deepLink` (and full message/cta) to the host, which decides
+ * how to navigate (e.g. `Linking.openURL` / a router push). Only fired for a CTA
+ * whose `action` resolves to a link with a `deepLink`.
+ */
+export type InAppDeepLinkHandler = (info: {
+    message: InAppMessageConfig;
+    cta: NonNullable<InAppRenderSpec['cta']>;
+    deepLink: string;
+}) => void;
+/** Imperative controller a host app uses to trigger a prompt / in-app message. */
+export interface EngagePromptController {
+    /** Fetch config, pick an eligible campaign, and show it. Returns whether one was shown. */
+    showEngagePrompt: (options?: ShowEngagePromptOptions) => Promise<boolean>;
+    /** Dismiss the currently visible prompt (no response submitted). */
+    dismissEngagePrompt: () => void;
+    /**
+     * Fetch config, pick an eligible in-app message (`inAppMessages[]`), and show
+     * it. Returns whether one was shown. PRECEDENCE: a campaign prompt already on
+     * screen wins — an in-app message is NOT shown over it (see provider doc).
+     */
+    showInAppMessage: (options?: ShowInAppMessageOptions) => Promise<boolean>;
+    /** Dismiss the currently visible in-app message (emits a `dismiss` event). */
+    dismissInAppMessage: () => void;
+}
+export interface EngagePromptProviderProps {
+    /** The SDK facade's `engage` namespace (e.g. `ScaleBun.engage`). */
+    engage: EngageRendererFacade;
+    /** Default campaign types to consider. Defaults to NPS-first. */
+    defaultTypes?: EngageCampaignType[];
+    /**
+     * RATING_PROMPT routing config (host-supplied). The app-store deeplink and
+     * feedback hand-off are NEVER hardcoded in the SDK — supplied here.
+     */
+    ratingRouting?: EngageRatingRouting;
+    /**
+     * Host sink for an in-app message CTA deep link. The SDK never opens URLs —
+     * it surfaces the resolved `deepLink` here for the host to navigate. Optional:
+     * a host that never uses link-action CTAs need not supply it.
+     */
+    onInAppDeepLink?: InAppDeepLinkHandler;
+    /**
+     * Required when a production gamified campaign is used. The SDK calls this
+     * only at play/load/check-in/quiz resolution time; the host's authenticated
+     * backend owns eligibility, granting, and the returned result.
+     */
+    onInAppGameRequest?: InAppGameRequestHandler;
+    /**
+     * DEV/TEST ONLY — poll interval (ms) for queued test previews while the app is
+     * already foregrounded. `checkForPreview` runs on mount + every AppState→active,
+     * which covers "reopen the app". But if you press "Send Test" while the app is
+     * ALREADY open and in the foreground, there is no background→foreground edge to
+     * trigger a refetch. Setting e.g. `previewPollMs={4000}` makes a warm, foreground
+     * app pick up a Send Test within a few seconds with no app switch. Leave UNSET in
+     * production (0/undefined ⇒ no polling — the foreground/cold-start fetch is enough).
+     */
+    previewPollMs?: number;
+    children: ReactNode;
+}
+/**
+ * Provider that mounts the shared overlay and exposes the imperative controller
+ * via `useEngagePrompt()`.
+ */
+export declare function EngagePromptProvider({ engage, defaultTypes, ratingRouting, onInAppDeepLink, onInAppGameRequest, previewPollMs, children, }: EngagePromptProviderProps): ReactElement;
+/**
+ * Hook a host app uses to trigger/dismiss the prompt:
+ *   const { showEngagePrompt } = useEngagePrompt();
+ *   showEngagePrompt({ types: ['NPS'] });
+ */
+export declare function useEngagePrompt(): EngagePromptController;
+//# sourceMappingURL=EngagePromptProvider.d.ts.map

package/lib/typescript/features/engage/EngagePromptView.d.ts

@@ -0,0 +1,97 @@
+/**
+ * ScaleBun SDK — Engage Prompt View (shared cross-platform JS overlay, D4)
+ *
+ * The ONE reusable campaign renderer. It is parameterized by config (Open/Closed):
+ * a `PROMPT_RENDERERS` registry maps an `EngageCampaignType` to a render branch.
+ * NPS is implemented now; ratings/feedback/survey plug in later as ADDITIONAL
+ * entries in that registry — NOT four copies of this overlay.
+ *
+ * The view is presentation-minimal but real (a genuine 0–10 NPS selector + an
+ * optional reason field). It is fully controlled: it owns no transport/throttle
+ * logic — it raises `onSubmit(result)` / `onDismiss()` and the provider wires
+ * those to `facade.engage.submitResponse` / `facade.engage.trackEvent`.
+ */
+import { type ReactElement } from 'react';
+import type { EngageAttachmentDraft, EngageCampaignConfig, EngageCampaignType, SurveyAnswer } from './engageTypes';
+import type { SubmitStage } from './EngageTransport';
+/**
+ * [Slice D5] The ONE submit state machine status, shared by EVERY question type.
+ * The overlay renders from this — bespoke per-type submit UIs are not allowed.
+ */
+export type EngageSubmitStatus = {
+    phase: 'idle';
+} | {
+    phase: 'submitting';
+    stage: SubmitStage;
+} | {
+    phase: 'success';
+} | {
+    phase: 'error';
+    message?: string;
+};
+/** How a RATING_PROMPT star selection should be routed by the host app. */
+export type RatingRoute = 'store' | 'feedback' | 'submit';
+/** Normalized result a prompt branch raises on submit. */
+export interface EngagePromptResult {
+    /** Selected numeric value (NPS 0–10 / CSAT 1–5 / RATING_PROMPT 1–5 stars). */
+    score?: number;
+    /** Optional free-text follow-up (NPS reason / feedback body). */
+    reason?: string;
+    /** Optional categorization tags (FEEDBACK). */
+    tags?: string[];
+    /** Per-question answers (SURVEY multi-question). */
+    answers?: SurveyAnswer[];
+    /** [P3-e] Native attachments captured in the prompt (screenshot/voice). */
+    attachments?: EngageAttachmentDraft[];
+    /**
+     * For RATING_PROMPT: how the provider should route this rating. `store` =
+     * high rating → app-store deeplink; `feedback` = low rating → feedback form;
+     * `submit` = record only. The provider, not the view, owns the side effect.
+     */
+    route?: RatingRoute;
+}
+/** Props every prompt-type render branch receives (the Open/Closed contract). */
+export interface PromptBranchProps {
+    campaign: EngageCampaignConfig;
+    onSubmit: (result: EngagePromptResult) => void;
+    onDismiss: () => void;
+    onStart?: () => void;
+    /**
+     * RATING_PROMPT routing config (host-app supplied, never hardcoded). The star
+     * branch reads `highRatingThreshold` to decide store vs feedback routing.
+     */
+    rating?: RatingPromptConfig;
+}
+/** Host-app-supplied RATING_PROMPT routing config (deeplink is NEVER hardcoded). */
+export interface RatingPromptConfig {
+    /** Ratings >= this go to the app-store route; below go to feedback. Default 4. */
+    highRatingThreshold?: number;
+    /** Whether a low rating routes to the in-app feedback form (else just submits). */
+    routeLowToFeedback?: boolean;
+}
+/** A render branch for one campaign type. Add entries to extend the renderer. */
+export type PromptRenderer = (props: PromptBranchProps) => ReactElement | null;
+export declare const PROMPT_RENDERERS: Partial<Record<EngageCampaignType, PromptRenderer>>;
+/** Resolve the render branch for a campaign, or null if its type isn't supported yet. */
+export declare function resolvePromptRenderer(type: EngageCampaignType): PromptRenderer | null;
+export interface EngagePromptViewProps {
+    campaign: EngageCampaignConfig | null;
+    visible: boolean;
+    onSubmit: (result: EngagePromptResult) => void;
+    onDismiss: () => void;
+    onStart?: () => void;
+    /** RATING_PROMPT routing config forwarded to the star branch (host-supplied). */
+    rating?: RatingPromptConfig;
+    /** [Slice D5] Reusable submit state — drives the in-prompt submitting/success/error overlay. */
+    submitStatus?: EngageSubmitStatus;
+    /** Retry the last submit (same idempotent responseId). */
+    onRetrySubmit?: () => void;
+    /** Close the prompt after a terminal submit state (success/error). */
+    onCloseSubmit?: () => void;
+}
+/**
+ * Modal overlay shell. Branches on `campaign.type` via the registry — renders the
+ * matching prompt or nothing. This is the single mount point a host app shows.
+ */
+export declare function EngagePromptView({ campaign, visible, onSubmit, onDismiss, onStart, rating, submitStatus, onRetrySubmit, onCloseSubmit, }: EngagePromptViewProps): ReactElement | null;
+//# sourceMappingURL=EngagePromptView.d.ts.map