import { type SwappedInboundMessage, type SwappedOutboundMessage, type SwappedTransport } from '@funkit/connect-core';
/**
 * Marker key on host → embed envelopes (see {@link buildSwappedSendScript}).
 * The injected bridge recognizes the mark, unwraps the payload, and delivers it
 * to the page; everything unmarked is embed traffic and goes to native.
 */
export declare const FUNKIT_ENVELOPE_KEY = "__funkitSwapped";
/**
 * Injected into the Swapped WebView before its content loads. Installs one
 * bridged `postMessage` that routes BOTH directions:
 *
 * - **embed → native**: the embed talks to its host by calling
 *   `window.parent.postMessage(obj, origin)` (the web iframe contract); at the
 *   top level `window.parent === window`, so overriding `window.postMessage`
 *   intercepts those calls and forwards them — JSON-stringified — to React
 *   Native via `window.ReactNativeWebView.postMessage`. The RN side parses +
 *   origin-validates via {@link handleWebViewMessage}.
 * - **native → embed**: messages injected by {@link buildSwappedSendScript}
 *   arrive at the same bridged function wrapped in a funkit-marked envelope
 *   ({@link FUNKIT_ENVELOPE_KEY}); the bridge unwraps them and re-dispatches
 *   the payload through the REAL `postMessage` (captured before the override),
 *   so the embed's `message` listeners receive a genuine, trusted MessageEvent
 *   with an object `event.data` — exactly what they get from an iframe parent.
 *
 * It also installs a fake `window.opener` wired to the native channel: with no
 * parent frame the widget posts its lifecycle messages (`SWAPPED_READY`, …) to
 * `opener` instead of `parent`, and a top-level WebView has neither — without
 * the shim those messages are silently dropped.
 */
export declare const SWAPPED_WEBVIEW_INJECTED_JS = "(function () {\n  if (window.__funkitSwappedBridge) { return; }\n  window.__funkitSwappedBridge = true;\n  // The REAL postMessage, captured before the override below.\n  var postToPage = window.postMessage.bind(window);\n  function forwardToNative(message) {\n    try {\n      var data = typeof message === 'string' ? message : JSON.stringify(message);\n      window.ReactNativeWebView && window.ReactNativeWebView.postMessage(data);\n    } catch (e) {}\n  }\n  function bridged(message) {\n    // funkit envelope (host \u2192 embed): unwrap + deliver to the page's listeners.\n    if (message && message.__funkitSwapped) {\n      try { postToPage(message.payload, '*'); } catch (e) {}\n      return;\n    }\n    // Anything else is the embed talking to its host \u2192 forward to native.\n    forwardToNative(message);\n  }\n  try { window.postMessage = bridged; } catch (e) {}\n  // The widget only emits some messages (notably SWAPPED_ORDER_DATA, the sell\n  // deposit address) when it believes it is embedded in a parent frame \u2014 on web\n  // that's a real <iframe> so window.parent !== window. A top-level WebView has\n  // window.parent === window, so present a DISTINCT parent/top (a proxy over\n  // window) whose postMessage forwards to native; the get-trap delegates every\n  // other property to the real window so the widget's other parent.* access works.\n  var frameProxy = window;\n  try {\n    frameProxy = new Proxy(window, {\n      get: function (target, prop) {\n        if (prop === 'postMessage') { return bridged; }\n        var value = target[prop];\n        return typeof value === 'function' ? value.bind(target) : value;\n      },\n    });\n  } catch (e) {\n    // Proxy unavailable \u2192 fall back to bridging the real parent.\n    try { if (window.parent) { window.parent.postMessage = bridged; } } catch (e2) {}\n  }\n  // Guard parent/top independently: parent is [Replaceable] so it sticks, but\n  // top is [LegacyUnforgeable] (HTML spec) and throws on conforming engines\n  // while succeeding on the WebView builds that gate embed detection on it \u2014\n  // isolating them means a throw on one never skips the other.\n  try { Object.defineProperty(window, 'parent', { configurable: true, get: function () { return frameProxy; } }); } catch (e) {}\n  try { Object.defineProperty(window, 'top', { configurable: true, get: function () { return frameProxy; } }); } catch (e) {}\n  // No parent frame \u2192 the widget posts lifecycle messages to window.opener.\n  try { if (!window.opener) { window.opener = { postMessage: forwardToNative }; } } catch (e) {}\n  true;\n})();\ntrue;";
/**
 * Build the JS snippet that delivers an outbound message INTO the embed, run
 * via `webView.injectJavaScript`. One shape for every message type: the payload
 * is wrapped in a funkit-marked envelope and handed to the (bridged)
 * `window.postMessage` — the bridge unwraps it and re-dispatches via the real
 * `postMessage` (see {@link SWAPPED_WEBVIEW_INJECTED_JS}). If the bridge isn't
 * installed, the envelope dispatches as-is and the embed ignores it (no `type`).
 */
export declare function buildSwappedSendScript(msg: SwappedOutboundMessage): string;
/**
 * Parse + validate a raw WebView `onMessage` payload into a typed inbound
 * Swapped message. Returns `null` (drop the message) when the payload isn't
 * valid JSON with a string `type`, or `url`'s origin isn't a Swapped origin
 * (mirrors web's `isSwappedOrigin(event.origin)` iframe guard).
 *
 * `url` is the page URL to validate against. The caller passes `nativeEvent.url`,
 * falling back to the last committed navigation URL when a webview build omits it
 * (see {@link SwappedWebView}) — so a missing url here means no trustworthy
 * source, and we fail closed.
 */
export declare function handleWebViewMessage(rawData: unknown, url?: string): SwappedInboundMessage | null;
/** Minimal surface of `react-native-webview`'s ref the transport needs. */
export interface WebViewLike {
    injectJavaScript(script: string): void;
}
export interface WebViewSwappedTransport {
    /** Implements the shared {@link SwappedTransport} contract. */
    transport: SwappedTransport;
    /**
     * Feed a raw WebView `onMessage` payload (+ optional page url) through origin
     * validation and fan it out to `transport.onMessage` subscribers.
     */
    dispatch(rawData: unknown, url?: string): void;
}
/**
 * React Native {@link SwappedTransport}: bridges the typed Swapped message
 * contract over a `WebView` instead of web's `<iframe>` + `window.postMessage`.
 * `send` delivers into the embed by injecting an in-page `postMessage` call
 * ({@link buildSwappedSendScript}); inbound messages arrive through
 * {@link dispatch} (wired to the WebView's `onMessage`).
 */
export declare function createWebViewSwappedTransport({ getWebView, }: {
    getWebView: () => WebViewLike | null;
}): WebViewSwappedTransport;
//# sourceMappingURL=webViewSwappedTransport.d.ts.map