/**
 * Nexus Serialize — Lossless server→client data transport.
 *
 * The POJO Barrier problem:
 *   JSON.stringify(new Date())      → '"2026-04-03T..."'  (string, not Date)
 *   JSON.stringify(new Map(...))    → '{}'                (empty object!)
 *   JSON.stringify(new Set(...))    → '{}'                (empty object!)
 *   JSON.stringify(42n)             → throws TypeError
 *   JSON.stringify(/foo/gi)         → '{}'                (empty object!)
 *
 * Nexus Serialize encodes rich types into a tagged wire format and
 * reconstructs them faithfully on the client — with zero external deps.
 *
 * Wire format: JSON with tagged wrapper objects
 *   { __t: 'Date',    v: '2026-04-03T...' }
 *   { __t: 'Map',     v: [[key, value], ...] }
 *   { __t: 'Set',     v: [item, ...] }
 *   { __t: 'BigInt',  v: '9007199254740993' }
 *   { __t: 'RegExp',  v: { src: 'foo', flags: 'gi' } }
 *   { __t: 'URL',     v: 'https://nexusjs.dev' }
 *   { __t: 'Undef' }
 *   { __t: 'NaN' }
 *   { __t: 'Inf',     v: 1 | -1 }
 *   { __t: 'Buf',     v: '<base64>' }   (Uint8Array / Buffer)
 *   { __t: 'Err',     v: { msg, name, stack? } }
 *
 * Usage:
 *   // Server (frontmatter or Server Action)
 *   const wire = serialize({ user, createdAt: new Date(), tags: new Set(['a', 'b']) });
 *
 *   // Client (island)
 *   const { user, createdAt, tags } = deserialize(wire);
 *   createdAt instanceof Date // true ✓
 *   tags instanceof Set       // true ✓
 */
/**
 * Serializes any JavaScript value to a JSON string.
 * Preserves: Date, Map, Set, BigInt, RegExp, URL, Uint8Array,
 *            undefined, NaN, Infinity, Error, nested objects/arrays.
 */
/**
 * Serializes to a JSON string safe to embed in `<script type="application/json">` or inline payloads.
 * Escapes `<` as `\u003c` in the **serialized text** so `</script>` cannot terminate the host tag;
 * `JSON.parse` still yields the original string values (round-trip preserves `<`).
 */
export declare function serialize(value: unknown): string;
/**
 * Encodes a value for the wire format (pre-JSON.stringify step).
 */
export declare function encode(value: unknown): unknown;
/**
 * Deserializes a Nexus wire-format JSON string back to rich JavaScript values.
 */
export declare function deserialize<T = unknown>(json: string): T;
/**
 * Decodes a pre-parsed wire-format value.
 */
export declare function decode(value: unknown): unknown;
/**
 * Generates an inline <script> tag that injects server props into the page
 * for island hydration. The client runtime reads `window.__NEXUS_PROPS__`.
 *
 * Security: values are JSON-encoded with HTML entity escaping to prevent XSS.
 *
 * Usage in renderer:
 *   const propsScript = injectProps('island_a3f9c1', { user, createdAt });
 *   html = html.replace('</body>', propsScript + '</body>');
 */
export declare function injectProps(islandId: string, props: unknown): string;
/**
 * Reads injected props in the browser.
 * Called by island mount functions before hydration.
 */
export declare function readProps<T = unknown>(islandId: string): T | null;
/**
 * Encodes a value for streaming (newline-delimited JSON chunks).
 * Used by the streaming SSR renderer for out-of-order flushing.
 */
export declare function encodeChunk(id: string, data: unknown): string;
export declare function decodeChunk(line: string): {
    id: string;
    data: unknown;
} | null;
/**
 * Typed fetch for Server Actions — automatically serializes input and
 * deserializes the response using Nexus transport.
 */
export declare function callAction<TInput, TOutput>(actionName: string, input: TInput): Promise<{
    data: TOutput;
    error: null;
} | {
    data: null;
    error: string;
}>;
/**
 * Escapes a value for safe **HTML text** insertion (not for raw `innerHTML` of trusted markup).
 * Prefer {@link serialize} for server→client props; use this when rendering strings into HTML templates.
 *
 * @example
 * import { sanitize } from '@nexus_js/serialize';
 * // Template: <p>${sanitize(userBio)}</p>
 */
export declare function sanitize(input: unknown): string;
/**
 * Recursively applies {@link sanitize} to every string in plain objects and arrays.
 * **Do not** use on payloads that will be passed through `serialize` for JSON (double-escaping risk).
 * Use when **all** string leaves are meant for HTML display (e.g. previewing pretext in a dev panel).
 */
export declare function sanitizeDeep<T = unknown>(value: T): T;
/**
 * Returns true if the string looks like it contains HTML/script-like markup (heuristic for dev / lint).
 * Not exhaustive; safe output still requires {@link sanitize} or proper parsing.
 */
export declare function looksLikeHtmlInjection(s: string): boolean;
//# sourceMappingURL=index.d.ts.map