@nodii/onboarding 0.0.1 → 0.1.0

package/dist/model-mnjAEtKe.d.ts

@@ -0,0 +1,253 @@
+import { z } from 'zod/v3';
+
+/**
+ * D543 §4 ConsentPack spec model — the `consentPack` block that GET
+ * /api/v1/public/onboarding/spec grows on top of the D540 shape:
+ *
+ *   consentPack: {
+ *     documents: [
+ *       { doc_type, custom_key?, title, version_no, content_hash,
+ *         download_url, acceptance_level, required }
+ *     ]
+ *   }
+ *
+ * The intake projects ONLY `live` versions into this block (D543 §4);
+ * `download_url` is a short-TTL presigned GET the SDK renders/opens.
+ *
+ * `acceptance_level` (D543 §2) is a per-document GATE:
+ *   - "checkbox"            — a single accept checkbox (basic clickwrap).
+ *   - "scroll_then_accept"  — accept disabled until the doc is scrolled to
+ *                             the end (client asserts evidence.scrolled_to_end).
+ *   - "open_then_accept"    — accept disabled until the doc is opened/viewed
+ *                             (client asserts evidence.opened).
+ * (E-signature is a deferred future level, D543 §2 — NOT modeled here.)
+ *
+ * FAIL-CLOSED (R1 + D543 §5 / D540 §1): a malformed consentPack throws
+ * OnboardingSpecInvalidError at parse time — never rendered half-parsed
+ * (a dropped `required` doc would let a user submit without consent, and a
+ * missing `content_hash`/`version_no` would break the server's re-validation
+ * match). The SDK refuses to render a consent step it cannot trust.
+ *
+ * DOM-ID HARDENING: a document's DOM-id token is derived from `doc_type`
+ * (a fixed enum — safe) or, for custom docs, from `custom_key` (free-form
+ * from the served spec). Custom keys are interpolated into element ids and
+ * (historically) selectors by the widget layer, so they are constrained to
+ * the SAME strict identifier alphabet as field keys (CUSTOM_KEY_PATTERN,
+ * identical to the spec model's FIELD_KEY_PATTERN) and REJECTED at parse time
+ * if they carry CSS/selector metacharacters. This is layer 1; the widget also
+ * CSS.escapes every id token as defense-in-depth.
+ *
+ * SUBMIT PIN (P4): the submit array carries {legalDocumentId, versionNo,
+ * accepted, evidence} — the server matches on legalDocumentId + versionNo
+ * (contentHash is spec-side integrity metadata, NOT echoed on submit; a
+ * content change publishes a new versionNo, so versionNo is a complete pin).
+ *
+ * DRIFT 5e3df7a3 (2026-07-14, consumer-visible) — RESOLVED by the canonical
+ * shape: D543 §4 as literally written omitted `legal_document_id` from the
+ * spec block, yet the submit array is KEYED on it (the server matches
+ * legalDocumentId + versionNo against the live version). The
+ * canonical alignment (both tiers, camelCase) INCLUDES `legalDocumentId` in
+ * the spec `consentPack.documents[]`, exactly as the drift proposed. This
+ * model REQUIRES it (fail-closed OnboardingSpecInvalidError if missing).
+ */
+
+/** D543 §2 acceptance-level enum. Extensible (adding a level is additive). */
+declare const ACCEPTANCE_LEVELS: readonly ["checkbox", "scroll_then_accept", "open_then_accept"];
+type AcceptanceLevel = (typeof ACCEPTANCE_LEVELS)[number];
+declare const acceptanceLevelSchema: z.ZodEnum<["checkbox", "scroll_then_accept", "open_then_accept"]>;
+/** D543 §3 docType enum. */
+declare const DOC_TYPES: readonly ["tos", "privacy", "dpa", "custom"];
+type ConsentDocType = (typeof DOC_TYPES)[number];
+/**
+ * One live legal document projected into the consent step. Mirrors the D543
+ * §4 `consentPack.documents[]` element — CANONICAL camelCase wire shape (both
+ * tenant + platform tiers aligned to this): { legalDocumentId, docType,
+ * customKey (nullable), title, versionNo, contentHash, downloadUrl,
+ * acceptanceLevel, required }. The `acceptanceLevel` enum VALUES stay snake
+ * (checkbox | scroll_then_accept | open_then_accept).
+ *
+ * Cross-field invariant (D543 §3): `customKey` is a non-null identifier when
+ * `docType === "custom"` and MUST be null otherwise (a canonical tos/privacy/
+ * dpa doc is keyed by docType; only custom docs carry a key). The custom-key
+ * alphabet is DOM-id safe.
+ */
+declare const consentDocumentSchema: z.ZodEffects<z.ZodObject<{
+    legalDocumentId: z.ZodString;
+    docType: z.ZodEnum<["tos", "privacy", "dpa", "custom"]>;
+    customKey: z.ZodNullable<z.ZodString>;
+    title: z.ZodString;
+    versionNo: z.ZodNumber;
+    contentHash: z.ZodString;
+    downloadUrl: z.ZodString;
+    acceptanceLevel: z.ZodEnum<["checkbox", "scroll_then_accept", "open_then_accept"]>;
+    required: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    legalDocumentId: string;
+    docType: "custom" | "tos" | "privacy" | "dpa";
+    customKey: string | null;
+    title: string;
+    versionNo: number;
+    contentHash: string;
+    downloadUrl: string;
+    acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+    required: boolean;
+}, {
+    legalDocumentId: string;
+    docType: "custom" | "tos" | "privacy" | "dpa";
+    customKey: string | null;
+    title: string;
+    versionNo: number;
+    contentHash: string;
+    downloadUrl: string;
+    acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+    required: boolean;
+}>, {
+    legalDocumentId: string;
+    docType: "custom" | "tos" | "privacy" | "dpa";
+    customKey: string | null;
+    title: string;
+    versionNo: number;
+    contentHash: string;
+    downloadUrl: string;
+    acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+    required: boolean;
+}, {
+    legalDocumentId: string;
+    docType: "custom" | "tos" | "privacy" | "dpa";
+    customKey: string | null;
+    title: string;
+    versionNo: number;
+    contentHash: string;
+    downloadUrl: string;
+    acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+    required: boolean;
+}>;
+type ConsentDocument = z.infer<typeof consentDocumentSchema>;
+/**
+ * The `consentPack` block. `documents` may be empty (an onboarder with no
+ * required legal docs) — the consent stage is then omitted from the flow.
+ *
+ * Uniqueness: no two documents may share the same STABLE key (docType, or
+ * custom:<customKey> for custom docs). A duplicate would collide their DOM
+ * ids AND their consent records — fail-closed at parse (the server keys the
+ * registry on (scope, docType) / (scope, customKey) per D543 §3, so a
+ * duplicate here is a projection bug, not a renderable spec).
+ */
+declare const consentPackSchema: z.ZodEffects<z.ZodObject<{
+    documents: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        legalDocumentId: z.ZodString;
+        docType: z.ZodEnum<["tos", "privacy", "dpa", "custom"]>;
+        customKey: z.ZodNullable<z.ZodString>;
+        title: z.ZodString;
+        versionNo: z.ZodNumber;
+        contentHash: z.ZodString;
+        downloadUrl: z.ZodString;
+        acceptanceLevel: z.ZodEnum<["checkbox", "scroll_then_accept", "open_then_accept"]>;
+        required: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }, {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }>, {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }, {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    documents: {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }[];
+}, {
+    documents: {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }[];
+}>, {
+    documents: {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }[];
+}, {
+    documents: {
+        legalDocumentId: string;
+        docType: "custom" | "tos" | "privacy" | "dpa";
+        customKey: string | null;
+        title: string;
+        versionNo: number;
+        contentHash: string;
+        downloadUrl: string;
+        acceptanceLevel: "checkbox" | "scroll_then_accept" | "open_then_accept";
+        required: boolean;
+    }[];
+}>;
+type ConsentPack = z.infer<typeof consentPackSchema>;
+/**
+ * Stable, collision-proof identity for a consent document, used as the map
+ * key in the controller and the DOM-id token in the widget. `docType` is a
+ * fixed enum; `custom:` is prefixed for custom docs so a customKey of
+ * "tos" can never alias the canonical tos doc.
+ *
+ * Note: this is NOT the submit key — the submit array keys on the server's
+ * opaque `legalDocumentId` (D543 §4), which the SDK does not synthesize.
+ * This is a purely CLIENT-side identity for state + DOM.
+ */
+declare function consentDocKey(doc: {
+    docType: ConsentDocType;
+    customKey?: string | null | undefined;
+}): string;
+
+export { ACCEPTANCE_LEVELS as A, type ConsentDocType as C, DOC_TYPES as D, type AcceptanceLevel as a, type ConsentDocument as b, type ConsentPack as c, acceptanceLevelSchema as d, consentDocKey as e, consentDocumentSchema as f, consentPackSchema as g };

package/dist/recaptcha/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * reCAPTCHA v3 loader and token executor.
+ *
+ * Per D537:
+ *   - Site key is public (supplied at mount time from the spec response).
+ *   - Secret key is NEVER in the browser — only the site key is here.
+ *   - v3 score-based by default; the operator may configure a v2 fallback
+ *     on the server side for low-score requests.
+ *   - The loader injects the reCAPTCHA script once and exposes execute()
+ *     to obtain a fresh token before each submit.
+ *
+ * Failure semantics (all recoverable, all bounded by opts.timeoutMs / 10s):
+ *   - A script load failure (adblock / CSP / offline) REJECTS with
+ *     RecaptchaError(kind:"load_failed"), EVICTS the cached promise, and
+ *     REMOVES the injected script tag — the next loadRecaptcha call starts
+ *     fresh. A transient failure never poisons the siteKey.
+ *   - EVERY wait is bounded, including grecaptcha.ready() AFTER onload and on
+ *     the adoption/poll paths: if api.js serves but the inner runtime never
+ *     boots (ready() never fires), the loader rejects RecaptchaError(
+ *     kind:"timeout") and evicts, rather than hanging the widget on
+ *     "Sending…" forever.
+ *   - The "existing script tag but no grecaptcha global" poll is BOUNDED,
+ *     then the subsequent ready() is bounded by the remaining budget.
+ *
+ * Multi-siteKey + foreign-global handling (honest):
+ *   - The v3 script loads with `?render=<siteKey>` and initializes for ONE
+ *     site key per page. A SECOND different siteKey after our first load is
+ *     rejected RecaptchaError(kind:"sitekey_mismatch").
+ *   - If the HOST page pre-loaded grecaptcha with an unknown render key (a
+ *     FOREIGN global this SDK did not create), we CANNOT introspect its key,
+ *     so executing our key against it would be the exact silent misfire we
+ *     promise to prevent. We reject RecaptchaError(kind:"sitekey_mismatch")
+ *     instead. (Detection: we only adopt a global we brought up ourselves or
+ *     that our own script tag is loading.)
+ *
+ * execute() rejections (invalid key at execute time, Google-internal errors,
+ * often plain strings) are wrapped in RecaptchaError(kind:"execute_failed").
+ *
+ * This module is browser-only. It accesses the `window` and `document`
+ * globals explicitly.
+ */
+declare global {
+    interface Window {
+        grecaptcha?: Grecaptcha;
+    }
+}
+interface Grecaptcha {
+    ready(callback: () => void): void;
+    execute(siteKey: string, options: {
+        action: string;
+    }): Promise<string>;
+}
+type RecaptchaErrorKind = "load_failed" | "timeout" | "sitekey_mismatch" | "execute_failed" | "unavailable";
+/** Typed error for every reCAPTCHA loader failure path. */
+declare class RecaptchaError extends Error {
+    readonly kind: RecaptchaErrorKind;
+    constructor(kind: RecaptchaErrorKind, message: string);
+}
+interface RecaptchaLoadOptions {
+    /**
+     * Max time to wait for the script / grecaptcha global to become ready
+     * before rejecting with RecaptchaError(kind:"timeout"). Default 10s.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Inject the reCAPTCHA v3 script for the given siteKey.
+ * Idempotent per siteKey: concurrent/repeated calls share one load.
+ * A FAILED load is evicted — the next call retries from scratch.
+ *
+ * @throws {RecaptchaError} kind:"sitekey_mismatch" — a different siteKey
+ *   is already active (single-render-script limitation, see module doc).
+ * @throws {RecaptchaError} kind:"load_failed" — script failed to load.
+ * @throws {RecaptchaError} kind:"timeout" — script/global never became ready.
+ * @throws {RecaptchaError} kind:"unavailable" — no DOM (not a browser).
+ */
+declare function loadRecaptcha(siteKey: string, opts?: RecaptchaLoadOptions): Promise<void>;
+/**
+ * Obtain a fresh reCAPTCHA v3 token for the given action.
+ * Loads the script if not already loaded. A previous load FAILURE does not
+ * block this call — the loader retries from scratch (see loadRecaptcha).
+ *
+ * @param siteKey - The public reCAPTCHA site key (from the spec endpoint).
+ * @param action  - The action name (e.g. "contact_submit"). Used for score analytics.
+ * @param opts    - Optional load options (timeoutMs — also bounds execute()).
+ * @returns A fresh reCAPTCHA token. Valid for ~2 minutes.
+ *
+ * @throws {RecaptchaError} kind:"timeout" if execute() does not settle within
+ *   the timeout (Google runtime hung) — bounded so the widget re-enables.
+ * @throws {RecaptchaError} on any load failure (see loadRecaptcha kinds) or
+ *   an execute() rejection (kind:"execute_failed").
+ */
+declare function executeRecaptcha(siteKey: string, action: string, opts?: RecaptchaLoadOptions): Promise<string>;
+/**
+ * Reset ALL loader state: cached load promise, active siteKey, and the
+ * injected script tag (removed from the DOM if present). Primarily for
+ * tests and for host pages that intentionally tear down reCAPTCHA.
+ * Does NOT unset window.grecaptcha (the script may still own it).
+ */
+declare function _resetRecaptchaState(): void;
+
+export { RecaptchaError, type RecaptchaErrorKind, type RecaptchaLoadOptions, _resetRecaptchaState, executeRecaptcha, loadRecaptcha };

package/dist/recaptcha/index.js

@@ -0,0 +1,4 @@
+import '../chunk-VH6FWDWI.js';
+export { RecaptchaError, _resetRecaptchaState, executeRecaptcha, loadRecaptcha } from '../chunk-7NS7ENJV.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/recaptcha/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/render-DC7P2BGQ.js

@@ -0,0 +1,5 @@
+export { _resetPdfWorkerState, renderConsentDocument } from './chunk-LVJM4CTG.js';
+import './chunk-SEKNVHD3.js';
+import './chunk-XJTJPBJB.js';
+//# sourceMappingURL=render-DC7P2BGQ.js.map
+//# sourceMappingURL=render-DC7P2BGQ.js.map

package/dist/render-DC7P2BGQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"render-DC7P2BGQ.js"}

package/dist/schema-BrXb9gnh.d.ts

@@ -0,0 +1,267 @@
+import { z } from 'zod/v3';
+
+/**
+ * Contact-form Zod schema — mirrors the LOCKED hub REST contract exactly:
+ *   POST /api/v1/public/onboarding/leads
+ *   Schema: PublicOnboardingLeadsRequest (hub id 8686dd33)
+ *
+ * Constraints (per hub JSON Schema):
+ *   name     — string, 1-200 chars, required
+ *   email    — email format, required
+ *   phone    — string, optional (no server-side constraint beyond string)
+ *   message  — string, ≤4000 chars, optional
+ *   botToken — string, required (reCAPTCHA token, D537)
+ *
+ *   additionalProperties: false
+ *
+ * The schema intentionally does NOT include botToken in the public-facing
+ * ContactFormValues type — that field is injected by the submit client right
+ * before the POST (the widget/form never exposes it to the user).
+ */
+
+/**
+ * The user-visible contact form fields. Validated client-side for UX.
+ * Server re-validates authoritatively (D540 §2).
+ */
+declare const contactFormSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    companyName: z.ZodString;
+    contactName: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    interestModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sizeBand: z.ZodOptional<z.ZodString>;
+    attribution: z.ZodOptional<z.ZodObject<{
+        campaignTags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        referringSite: z.ZodOptional<z.ZodString>;
+        landingPage: z.ZodOptional<z.ZodString>;
+        button: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    }, {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    }>>;
+    privacyNoticeAcknowledged: z.ZodEffects<z.ZodBoolean, boolean, boolean>;
+    marketingOptIn: z.ZodBoolean;
+    intakeKind: z.ZodEnum<["contact", "enquiry"]>;
+    website: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    interestModules: string[];
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+}, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    interestModules?: string[] | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+}>;
+type ContactFormValues = z.infer<typeof contactFormSchema>;
+/**
+ * The full wire payload — contactFormSchema + botToken.
+ *
+ * STRICT mode: unknown keys are REJECTED (not stripped), mirroring the
+ * server's `additionalProperties: false`. `submitLead` runs every outgoing
+ * payload through this schema before the POST — an extra key never reaches
+ * the wire; it fails fast client-side with OnboardingValidationError.
+ */
+declare const leadsWireSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    companyName: z.ZodString;
+    contactName: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    interestModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    sizeBand: z.ZodOptional<z.ZodString>;
+    attribution: z.ZodOptional<z.ZodObject<{
+        campaignTags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        referringSite: z.ZodOptional<z.ZodString>;
+        landingPage: z.ZodOptional<z.ZodString>;
+        button: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    }, {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    }>>;
+    privacyNoticeAcknowledged: z.ZodEffects<z.ZodBoolean, boolean, boolean>;
+    marketingOptIn: z.ZodBoolean;
+    intakeKind: z.ZodEnum<["contact", "enquiry"]>;
+    website: z.ZodOptional<z.ZodString>;
+} & {
+    botToken: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    interestModules: string[];
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+    botToken?: string | undefined;
+}, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    interestModules?: string[] | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+    botToken?: string | undefined;
+}>;
+type LeadsWirePayload = z.infer<typeof leadsWireSchema>;
+/**
+ * Validate user-visible form values (no botToken required here).
+ * Returns a Zod SafeParseReturnType (inferred).
+ */
+declare function validateContactForm(values: unknown): z.SafeParseReturnType<{
+    companyName: string;
+    contactName: string;
+    email: string;
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    interestModules?: string[] | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+}, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    interestModules: string[];
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+}>;
+/**
+ * Validate the full wire payload (including botToken) before submission.
+ * STRICT: unknown keys are rejected, matching additionalProperties:false.
+ * This is the exact validation `submitLead` applies on the wire path.
+ * Returns a Zod SafeParseReturnType (inferred).
+ */
+declare function validateLeadsPayload(payload: unknown): z.SafeParseReturnType<{
+    companyName: string;
+    contactName: string;
+    email: string;
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    interestModules?: string[] | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+    botToken?: string | undefined;
+}, {
+    companyName: string;
+    contactName: string;
+    email: string;
+    interestModules: string[];
+    privacyNoticeAcknowledged: boolean;
+    marketingOptIn: boolean;
+    intakeKind: "contact" | "enquiry";
+    name?: string | undefined;
+    phone?: string | undefined;
+    message?: string | undefined;
+    sizeBand?: string | undefined;
+    attribution?: {
+        campaignTags?: Record<string, string> | undefined;
+        referringSite?: string | undefined;
+        landingPage?: string | undefined;
+        button?: string | undefined;
+    } | undefined;
+    website?: string | undefined;
+    botToken?: string | undefined;
+}>;
+
+export { type ContactFormValues as C, type LeadsWirePayload as L, validateLeadsPayload as a, contactFormSchema as c, leadsWireSchema as l, validateContactForm as v };