@parag.more.withsurface.com/forms-sdk 0.1.4 → 0.1.6

package/dist/types/bind/scheduler/types.d.ts

@@ -0,0 +1,65 @@
+import type { SchedulerQuestion } from "../../core/client/runtimeConfig";
+import type { SchedulerBookingSummary, SchedulerLifecycleEvent } from "../../core/engine/schedulerEvents";
+import type { SurfaceForm } from "../../surfaceForms";
+import type { BookingWidgetOptions } from "../bookingWidget";
+export type MountSchedulerOptions = {
+    form: SurfaceForm;
+    container: Element;
+    
+    questionId?: string;
+    
+    stepId?: string;
+    
+    styled?: boolean;
+    
+    persist?: boolean;
+    
+    prefill?: {
+        name?: string;
+        lastName?: string;
+        email?: string;
+    };
+    
+    formatters?: BookingWidgetOptions["formatters"];
+    
+    calendarId?: string;
+    onEvent?: (event: SchedulerLifecycleEvent) => void;
+    
+    onComplete?: (booking: SchedulerBookingSummary) => void;
+};
+
+export type ProviderEvent = SchedulerLifecycleEvent extends infer T ? T extends {
+    questionId: string;
+    stepId: string;
+    provider: unknown;
+} ? Omit<T, "questionId" | "stepId" | "provider"> : never : never;
+
+export type ProviderContext = {
+    form: SurfaceForm;
+    container: Element;
+    question: SchedulerQuestion;
+    
+    content: SchedulerQuestion["content"];
+    prefill: {
+        name?: string;
+        lastName?: string;
+        email?: string;
+    };
+    
+    urlParams: Record<string, string>;
+    formatters?: BookingWidgetOptions["formatters"];
+    styled: boolean;
+    emit: (event: ProviderEvent) => void;
+    
+    confirmBooking: (booking: Omit<SchedulerBookingSummary, "provider">, extraAnswer?: Record<string, unknown>) => void;
+    
+    cancelBooking: (reason?: string) => void;
+    
+    mergeAnswer: (partial: Record<string, unknown>, opts?: {
+        save?: boolean;
+    }) => void;
+    
+    ensureResponseId: () => Promise<string | null>;
+};
+
+export type ProviderMount = (ctx: ProviderContext) => () => void;

package/dist/types/core/client/emailValidation.d.ts

@@ -1,12 +1,12 @@
 import type { Transport } from "./transport";
 export type EmailValidationResult = {
     email: string;
-    /** Deliverable per the waterfall + blacklist; fail-open true when validation could not run. */
+    
     isValid: boolean;
     status?: string;
     reason?: string;
     blacklistEntryIds?: string[];
-    /** Validation did not actually run (network/server failure) — `isValid` is the fail-open default. */
+    
     failed?: boolean;
 };
 export type EmailValidator = {
@@ -16,8 +16,7 @@ export type EmailValidator = {
 export type CreateEmailValidatorOptions = {
     transport: Transport;
     environmentId: string;
-    /** Preview never spends validator quota: every email reports a synthetic valid result. */
+    
     preview?: boolean;
 };
 export declare const createEmailValidator: ({ transport, environmentId, preview, }: CreateEmailValidatorOptions) => EmailValidator;
-//# sourceMappingURL=emailValidation.d.ts.map

package/dist/types/core/client/responses.d.ts

@@ -3,33 +3,21 @@ import type { Transport, TransportResult } from "./transport";
 export type CreateResponseResult = {
     responseId: string;
     leadId: string | null;
-    /** Authorizes the token-gated read-back (resume); persist alongside the responseId. */
+    
     resumeToken: string | null;
 };
 export declare const submitResponse: (transport: Transport, payload: FormResponsePayload) => Promise<TransportResult<CreateResponseResult>>;
 export declare const updateResponse: (transport: Transport, payload: FormUpdateResponsePayload) => void;
-/**
- * Awaited delivery for the FINISHING update (the 2026-08 field run measured
- * the beacon path silently dropping the terminal write on fast page close:
- * `submit()` resolved, `saved` fired, and the server kept a step-1 partial).
- * `keepalive` lets the request survive an immediate navigation; credentials
- * match the beacon path's `${formId}_pa` cookie round-trip.
- */
+
 export declare const updateResponseConfirmed: (transport: Transport, payload: FormUpdateResponsePayload) => Promise<TransportResult<unknown>>;
 export type StoredAnswerRow = {
     questionId: string;
     response: Record<string, unknown>;
 };
-/**
- * Read-back of a stored response for resume (Decisions #11: the route is
- * token-gated; the create reply issued the token). External-state
- * pseudo-answers (URL_DATA) are stripped — they are attribution snapshots the
- * engine re-derives from its own page context, not visitor answers.
- */
+
 export declare const fetchStoredResponse: (transport: Transport, { responseId, resumeToken }: {
     responseId: string;
     resumeToken: string;
 }) => Promise<TransportResult<{
     answers: StoredAnswerRow[];
 }>>;
-//# sourceMappingURL=responses.d.ts.map

package/dist/types/core/client/runtimeConfig.d.ts

@@ -1,19 +1,5 @@
 import type { Transport, TransportResult } from "./transport";
-/**
- * Boot-time fetch of the published form record (forms-sdk-plan.md §2.3,
- * Decisions #7): `GET /api/v1/public/forms/[formId]/runtime-config` serves the
- * same `TCachedForm` payload the hosted `/s/[formId]` page reads — config
- * (steps + components, the data contract) and settings (behavioral gates like
- * `trackPartialResponses`; tracking ids for the Phase-2 tracking module).
- * `settings.password` never arrives — the server strips it and the SDK
- * validates gated forms through `/api/v1/check-password`.
- *
- * The step/question extraction mirrors `extractFlatComponentsFromStep`
- * (form-render gridLayoutUtils): a step's `components` is either a flat
- * component array or a ComponentGridLayout whose rows hold components or
- * `GridLayoutRowItem` wrappers; stateful components carry `state.questionId` —
- * the same discriminator the MCP validator's `collectQuestionIds` uses.
- */
+
 type RuntimeStep = {
     id: string;
     endStepKind?: "thank_you" | "disqualified";
@@ -31,14 +17,14 @@ export type RuntimeConfig = {
         trackCookie?: boolean;
     } & Record<string, unknown>) | null;
 };
-/** `preview` asks the server for the draft config of a never-published form (authoring loop); published forms serve live either way. */
+
 export declare const fetchRuntimeConfig: (transport: Transport, formId: string, { preview, previewToken }?: {
     preview?: boolean;
     previewToken?: string;
 }) => Promise<TransportResult<{
     data?: RuntimeConfig;
 }>>;
-/** Step order + ending kinds — the engine's traversal contract, including where submit/disqualify land. */
+
 export declare const stepsOf: (config: RuntimeConfig["config"]) => Array<{
     id: string;
     endStepKind?: "thank_you" | "disqualified";
@@ -48,25 +34,47 @@ export declare const statefulQuestionsOf: (config: RuntimeConfig["config"]) => A
     componentType?: string;
 }>;
 export declare const statefulQuestionIdsOf: (config: RuntimeConfig["config"]) => string[];
-/**
- * Questions whose answers can trigger real-time enrichment, with the state
- * keys to watch — the native renderer's blur triggers translated to data
- * (identityInfo.tsx handleOnBlur): IdentityInfo fires on its configured
- * `enrichmentSourceField` (default emailAddress) and always on `websiteUrl`;
- * EmailForm fires on its email.
- */
+
 export declare const enrichmentSourcesOf: (config: RuntimeConfig["config"]) => Array<{
     questionId: string;
     fieldNames: string[];
 }>;
-/**
- * True when a component EXPLICITLY declares `enrichmentSourceField` — the
- * authoring-time signal that the owner expects enrichment to run. Implicit
- * sources (every EmailForm / IdentityInfo default) don't count: they make any
- * form with an email question look enrichment-configured.
- */
+
+export type SchedulerStateRef = {
+    stepId: string;
+    questionId: string;
+};
+
+export type SchedulerParamRef = SchedulerStateRef & {
+    variable: string;
+};
+export type SchedulerQuestion = {
+    questionId: string;
+    stepId: string;
+    
+    componentType: "CalendlyScreen" | "DynamicScheduler";
+    
+    calendarType: string;
+    content: {
+        dataUrl?: string;
+        eventTypeId?: string;
+        savvyCalLinkId?: string;
+        revenueHeroRouterId?: string;
+        dataUrlParams?: Record<string, SchedulerParamRef>;
+        linkNameToStep?: SchedulerStateRef;
+        linkLastNameToStep?: SchedulerStateRef;
+        linkEmailToStep?: SchedulerStateRef;
+        addSchedulerQueryParams?: boolean;
+        skipFormIfPrefilled?: boolean;
+        
+        calendars?: unknown[];
+        defaultCalendar?: unknown;
+    };
+};
+
+export declare const schedulerQuestionsOf: (config: RuntimeConfig["config"]) => SchedulerQuestion[];
+
 export declare const hasDeclaredEnrichmentSource: (config: RuntimeConfig["config"]) => boolean;
-/** Mirrors form-render's provider gate (buildExternalStateStore): v2 config with at least one enabled provider exposing fields. */
+
 export declare const hasEnabledEnrichmentProvider: (settings: RuntimeConfig["settings"]) => boolean;
 export {};
-//# sourceMappingURL=runtimeConfig.d.ts.map

package/dist/types/core/client/scheduler.d.ts

@@ -1,22 +1,5 @@
 import type { Transport, TransportResult } from "./transport";
-/**
- * Thin wrap of the public Surface-native scheduler endpoints (forms-sdk-plan.md
- * row 46 — Phase-1 MVP scope by product decision). Query and payload shapes
- * mirror `@surface/scheduler-ui`'s hooks byte-for-byte (that package is
- * AGPL-tree and cannot ship in the MIT SDK — plan §2.9), including the split
- * of `YYYY-MM` into numeric month/year params and the booking `meta` block
- * that drives server-side booking↔response linkage.
- *
- * `preview: true` mirrors the native BookingForm exactly: queries carry
- * `preview=true`, and `book()` resolves a fabricated preview booking without
- * any network call — draft interactions never create real bookings.
- *
- * `toSchedulerAnswerState` reproduces `SurfaceScheduler.handleBookingComplete`:
- * the persisted DynamicScheduler component state whose `eventScheduled`/`uri`
- * pair the payload builder's bookingId detection and the server's booking
- * meta injection key on. `googleMeetLink` is the frozen persisted key even
- * though the API field is `meetingJoinLink`.
- */
+
 export type BookingAttendee = {
     name: string;
     email: string;
@@ -62,7 +45,7 @@ export type SchedulerClient = {
     }>>;
     getMonthAvailability: (args: {
         eventTypeId: string;
-        /** Calendar month as `YYYY-MM`; split into numeric month/year params like native. */
+        
         month: string;
         timezone: string;
         duration?: number;
@@ -85,12 +68,7 @@ export type SchedulerClient = {
     book: (args: {
         eventTypeId: string;
         startTime: string;
-        /**
-         * The selected slot's end. Required — every booking comes from a picked
-         * slot, and a fallback would fabricate zero-length preview meetings. Only
-         * preview fabrication reads it (the server derives real end times); it is
-         * never sent on the wire.
-         */
+        
         endTime: string;
         timezone: string;
         inviteeName: string;
@@ -115,7 +93,6 @@ export declare const createSchedulerClient: ({ transport, preview, }: {
     transport: Transport;
     preview?: boolean;
 }) => SchedulerClient;
-/** The persisted DynamicScheduler component state for a completed booking. */
+
 export declare const toSchedulerAnswerState: (booking: Booking) => Record<string, unknown>;
 export {};
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/types/core/client/transport.d.ts

@@ -1,30 +1,7 @@
-/**
- * Delivery layer for the SDK's first-party requests, mirroring the native
- * runtime's two transports (forms-sdk-plan.md §2.4):
- *
- * - `post` — plain `fetch` for calls whose response body the engine needs
- *   (response create returns `responseId`/`meta`, identify returns
- *   `leadId`/`sessionId`). Never throws: resolves to a typed result so
- *   callers keep the never-break-the-host-page guarantee (§2.6).
- * - `beacon` — `sendBeacon`-first with `fetch(keepalive)` fallback for
- *   fire-and-forget writes (response updates, events, journey), the same
- *   semantics as form-render's `updateResponse.ts` / `sendPushEventRequest.ts`.
- *   Failures are swallowed by design: the server's drop-off sweep reconciles
- *   missed updates, and events are best-effort.
- *
- * Unlike form-render (relative paths, same-origin only), every request is
- * absolute against a configurable base URL — SDK pages are customer-hosted
- * and always cross-origin (§4.1).
- */
-/** The host the public tag already targets (scripts:src/constants.ts). */
+
+
 export declare const DEFAULT_API_BASE_URL = "https://forms.withsurface.com";
-/**
- * Sent as `X-Surface-Sdk-Version` on every fetch-path request (Decisions #14:
- * SDK 429s must be measurable before rate limits are revisited). `sendBeacon`
- * cannot carry headers, so beacon deliveries carry the version as the `sdv`
- * query param instead — the server reads both. Bumped manually until
- * extraction wires it to package.json at build time.
- */
+
 export declare const SDK_VERSION = "0.1.0";
 export type TransportResult<TData> = {
     ok: true;
@@ -47,10 +24,9 @@ export type Transport = {
         keepalive?: boolean;
         credentials?: boolean;
     }) => Promise<TransportResult<TData>>;
-    /** Returns true only when `sendBeacon` queued the payload; the fire-and-forget fetch fallback reports false. */
+    
     beacon: (path: string, payload: unknown) => boolean;
 };
 export declare const createTransport: ({ apiBaseUrl, }?: {
     apiBaseUrl?: string;
 }) => Transport;
-//# sourceMappingURL=transport.d.ts.map

package/dist/types/core/engine/answerAudit.d.ts

@@ -1,21 +1,12 @@
-/**
- * `init({ debug: true })` answer auditing: the bind layer always produces
- * valid shapes, but headless `setAnswer` callers are one label-string away
- * from the ingest 400 that static gates cannot see (2026-08 field run). The
- * auditor checks only facts that cannot false-positive — unknown questionId,
- * wrong `type` discriminator, a merged state with no `type` at all, and a
- * choice-list answer whose `choices` is not an array — and logs every
- * captured answer so a session is replayable from the console.
- */
+
 export type AuditedQuestion = {
     questionId: string;
     componentType?: string;
 };
 export declare const auditAnswer: ({ questions, questionId, merged, }: {
-    /** Stateful questions of the record; empty when the record wasn't fetched (caller-provided steps). */
+    
     questions: Map<string, AuditedQuestion>;
     questionId: string;
-    /** The post-merge state (setAnswer patches accumulate per question). */
+    
     merged: Record<string, unknown>;
 }) => void;
-//# sourceMappingURL=answerAudit.d.ts.map

package/dist/types/core/engine/answerStates.d.ts

@@ -1,16 +1,4 @@
-/**
- * Typed answer states for headless callers (plan §2.9): the bind layer builds
- * these automatically, but React/headless code hands them to `setAnswer` by
- * hand — and shipping a bare label string where a structured state belongs is
- * the classic production 400 (2026-08 field run). These local types mirror
- * each component's wire schema and are contract-tested against
- * `@surface/types` (dev dependency only — the SDK ships zero runtime deps).
- *
- * `setAnswer` itself stays structurally typed (`Record<string, unknown>`):
- * legacy component types not listed here remain settable, and answers merge
- * per question, so partial patches are legal. Annotate call sites with these
- * types to get the compiler's help.
- */
+
 export type ShortInputAnswer = {
     type: "ShortInput";
     input: string;
@@ -36,7 +24,7 @@ export type FileUploaderAnswer = {
     type: "FileUploader";
     fileUrl?: string;
 };
-/** The ENTIRE option list, one entry per record option — never only the picked one. */
+
 export type MultipleOptionsAnswer = {
     type: "MultipleOptionsQuestion";
     choices: Array<{
@@ -70,13 +58,13 @@ export type MultipleChoiceSingleAnswerAnswer = {
     value: string;
     index: number;
 };
-/** Canonical IdentityInfo answer keys (mirrors IdentityInfoKeysArray; contract-tested). */
+
 export declare const IDENTITY_INFO_ANSWER_KEYS: readonly ["firstName", "lastName", "fullName", "emailAddress", "workEmailAddress", "phoneNumber", "companyName", "numberOfEmployees", "websiteUrl", "title", "streetAddress", "aptSuiteEtc", "city", "state", "country", "zipCode", "companyRevenue", "profilePictureUrl"];
 export type IdentityInfoAnswerKey = (typeof IDENTITY_INFO_ANSWER_KEYS)[number];
 export type IdentityInfoAnswer = {
     type: "IdentityInfo";
 } & Partial<Record<IdentityInfoAnswerKey, string>>;
-/** Booking answers; `toSchedulerAnswerState` produces this — override `type` to the record's component type. */
+
 export type SchedulerAnswer = {
     type: "CalendlyScreen" | "DynamicScheduler";
     eventScheduled: boolean;
@@ -89,4 +77,3 @@ export type SchedulerAnswer = {
     googleMeetLink?: string;
 };
 export type KnownAnswerState = ShortInputAnswer | LongInputAnswer | EmailFormAnswer | DropdownAnswer | DisclaimerAnswer | FileUploaderAnswer | MultipleOptionsAnswer | MMChoiceAnswer | MultipleChoiceAnswer | GraphicOptionsAnswer | MultipleChoiceSingleAnswerAnswer | IdentityInfoAnswer | SchedulerAnswer;
-//# sourceMappingURL=answerStates.d.ts.map

package/dist/types/core/engine/formEngine.d.ts

@@ -3,37 +3,8 @@ import { type Unsubscribe } from "../events/emitter";
 import type { FormJourneyTracker, FormJourneyTransitionReason } from "../events/formJourneyTracker";
 import { type PushEventClient } from "../events/pushEvents";
 import { type AnswerStates, type ExternalStates } from "./responsePayload";
-/**
- * The headless step engine (forms-sdk-plan.md §2.2): answers, traversal,
- * response writes, and lifecycle events over the modules this stack built.
- * Native semantics preserved:
- *
- * - **Partial saves on forward step change only** (row 23): first forward
- *   move creates the response, later moves update it, and every write sends
- *   the id of the step being *left* — all gated by
- *   `settings.trackPartialResponses` except the finishing write, which always
- *   happens.
- * - **Finished/invalid derivation** (row 27): a resolved next step of
- *   `"END"`/`"INVALID"`/`undefined` finishes the form; `"INVALID"`
- *   disqualifies.
- * - **Step transition events** (row 31): the `form_step_submitted` +
- *   `form_step_viewed` batch with `stepCompletionTime` in seconds since the
- *   engine was created (native's `initialRenderTime`), skipped when the form
- *   finishes (native returns before emitting on `"END"`).
- * - `markViewed` mirrors native's view actions: `form_viewed` + first-step
- *   `form_step_viewed`, once.
- * - Backward navigation never writes (native only re-arms `stepIdToSubmit`).
- *
- * **The engine does not evaluate routing** (Decisions #6): the customer's own
- * code owns navigation. `next()`/`back()` are linear conveniences,
- * `goToStep()` is the explicit move — forward jumps carry full forward
- * semantics (step events, journey transition, partial write), jumps to an
- * already-visited step rewind like `back()` (no write). Disqualification is
- * the explicit `disqualify()` verb — in native it was a routing outcome (the
- * `INVALID` sentinel), so without routing it needs its own API. The pluggable
- * `resolveNextStep` remains as the headless hook for callers who express
- * their routing as a resolver instead of imperative `goToStep` calls.
- */
+import type { SchedulerLifecycleEvent } from "./schedulerEvents";
+
 export type ResolvedNextStep = {
     stepId: string;
     reason?: FormJourneyTransitionReason;
@@ -68,34 +39,37 @@ export type FormEngineEvents = {
         scope: "submit";
         error: unknown;
     };
+    scheduler: SchedulerLifecycleEvent;
 };
 export type FormEngineState = {
     currentStepId: string;
     answers: AnswerStates;
-    /** Pseudo-answer states riding every write (URL_DATA attribution, enrichment results, …). */
+    
     externalStates: ExternalStates;
     responseId: string | null;
-    /** From the create reply; with the responseId it authorizes a later resume (persist both). */
+    
     resumeToken: string | null;
     finished: boolean;
 };
 export type FormEngine = {
     setAnswer: (questionId: string, state: Record<string, unknown>) => void;
-    /** Writes a pseudo-answer external state (enrichment results, custom attribution) that rides every subsequent save. */
+    
     setExternalState: (id: string, state: {
         type: string;
     } & Record<string, unknown>) => void;
-    /** Merges keys into the response `meta` object carried by every subsequent save (post-finish it amends the stored response). */
+    
     mergeMeta: (partial: Record<string, unknown>) => void;
     next: () => Promise<void>;
     back: () => void;
-    /** Customer-owned navigation (Decisions #6): forward jumps save like next(), visited-step jumps rewind like back(). */
+    
     goToStep: (stepId: string) => Promise<void>;
     submit: () => Promise<void>;
-    /** Finishes the form as disqualified (`invalidResponse: true`) — the explicit replacement for native's INVALID routing outcome. */
+    
     disqualify: () => Promise<void>;
     savePartial: () => Promise<void>;
-    /** Resolves when every write queued so far has settled — await it before tearing the page down (test harnesses, SPA unmounts). */
+    
+    notifyScheduler: (event: SchedulerLifecycleEvent) => void;
+    
     flush: () => Promise<void>;
     markViewed: () => void;
     on: <K extends keyof FormEngineEvents>(event: K, handler: (payload: FormEngineEvents[K]) => void) => Unsubscribe;
@@ -105,7 +79,7 @@ export type FormEngine = {
 export declare const createFormEngine: ({ formId, environmentId, steps, transport, resolveNextStep, trackPartialResponses, trackCookies, externalStates, meta, identity, pushEvents, formJourney, preview, resume, }: {
     formId: string;
     environmentId?: string;
-    /** Ordered logical steps of the form record (the data contract). */
+    
     steps: Array<{
         id: string;
         endStepKind?: "thank_you" | "disqualified";
@@ -116,11 +90,7 @@ export declare const createFormEngine: ({ formId, environmentId, steps, transpor
     trackCookies?: boolean;
     externalStates?: ExternalStates;
     meta?: Record<string, unknown>;
-    /**
-     * Read at every write/event, not captured at construction — a re-identify
-     * (SurfaceForm.identify after cache expiry) must attribute subsequent
-     * responses and events to the current visitor, not the boot-time one.
-     */
+    
     identity?: () => {
         fingerprint?: string;
         leadSessionId?: string;
@@ -128,18 +98,11 @@ export declare const createFormEngine: ({ formId, environmentId, steps, transpor
     };
     pushEvents?: PushEventClient;
     formJourney?: FormJourneyTracker;
-    /** Preview mode never writes (§2.2): traversal and events run, responses are never created. */
+    
     preview?: boolean;
-    /**
-     * Resume a stored response (row 28): the seeded responseId turns every write
-     * into an update (no duplicate row), and the seeded answers ride along in
-     * the full-answer-set resend. Answers are keyed by questionId and seeded
-     * under the first step — the wire flattens steps, and presentation (which
-     * step to show) is the caller's own navigation.
-     */
+    
     resume?: {
         responseId: string;
         answers?: Record<string, Record<string, unknown>>;
     };
 }) => FormEngine;
-//# sourceMappingURL=formEngine.d.ts.map

package/dist/types/core/engine/redirect.d.ts

@@ -1,25 +1,4 @@
-/**
- * Redirect handling (forms-sdk-plan.md rows 17/48), mirroring form-render's
- * `handleRedirect.ts`:
- *
- * - Identity handoff: `leadId` and `sessionId` are appended as query params so
- *   the destination page's tag/SDK resolves the same visitor (row 17).
- * - Protocol default matches `addProtocolToUrl` verbatim, including its quirk:
- *   the check is `startsWith("https")`, so an explicit `http://` URL gets
- *   double-prefixed. Replicated, not fixed — it's on the plan's
- *   replicate-then-review list territory (Phase 0 item 5); the parity harness
- *   compares against native.
- * - Unparseable URLs pass through unchanged, blank URLs redirect nowhere.
- * - `CurrentWindow` navigates `window.location` — the SDK runs first-party,
- *   which is exactly what native's `window.parent.location` resolves to on a
- *   top-level page. `NewTab` opens `_blank`.
- * - Preview never navigates (native gates on preview/editing screens).
- *
- * The step engine owns *when* to redirect (per-step + thank-you triggers and
- * the `redirectTimeout ?? 400 ms` delay — the default is exported here);
- * parent-param forwarding via `redirectUrlParams` templating lands with the
- * external-state store work (row 56).
- */
+
 export type RedirectType = "NewTab" | "CurrentWindow";
 export declare const DEFAULT_REDIRECT_TIMEOUT_MS = 400;
 export declare const buildRedirectUrl: (url: string, { leadId, sessionId }?: {
@@ -33,4 +12,3 @@ export declare const performRedirect: ({ url, redirectType, leadId, sessionId, p
     sessionId?: string;
     preview?: boolean;
 }) => void;
-//# sourceMappingURL=redirect.d.ts.map

package/dist/types/core/engine/responsePayload.d.ts

@@ -1,34 +1,11 @@
-/**
- * Response payload builders (forms-sdk-plan.md rows 24-26), mirroring
- * form-render's `createResponseApiPayload` exactly — the semantics here are
- * load-bearing server contracts:
- *
- * - **Full answer-set resend on every write** (row 26): all steps' answers
- *   plus every external-state entry as a pseudo-answer keyed by its stateId.
- *   Server-side UTM preservation depends on the URL_DATA entry riding every
- *   update.
- * - `SCHEDULER_AVAILABILITY_DATA` entries are transient client-only data and
- *   are never persisted.
- * - Surface-native booking detection: the first answer with
- *   `eventScheduled: true` and a non-Calendly/Cal.com `uri` stamps
- *   `meta.bookingId`.
- * - `enrichedFields` precedence: person-attribute enrichment wins over the
- *   processed APOLLO_EMAIL_ENRICHMENT external state, `{}` as the floor.
- * - `meta.cookies` is stripped when `trackCookies` is off.
- * - Creates pin `responseShapeVersion: "2.0"`; updates carry `responseId`.
- *
- * Types are local structural mirrors of `ZFormResponseData` /
- * `ZFormUpdateResponseData` (zero-runtime-deps); the contract test validates
- * built payloads against the real schemas. Answer/external-state entry shapes
- * are pass-through records — component state shapes belong to the engine.
- */
+
 export type SingleFormResponse = {
     questionId: string;
     response: Record<string, unknown>;
 };
-/** Answers grouped per step, keyed stepId → questionId → component state. */
+
 export type AnswerStates = Record<string, Record<string, Record<string, unknown>>>;
-/** External state entries keyed by stateId; `type` discriminates (URL_DATA, enrichment, …). */
+
 export type ExternalStates = Record<string, {
     type: string;
 } & Record<string, unknown>>;
@@ -61,7 +38,7 @@ type BuildPayloadOptions = {
     invalidResponse: boolean;
     trackCookies: boolean;
     meta?: Record<string, unknown>;
-    /** Person-attribute enrichment; wins over external-state enrichment like native. */
+    
     personAttributeEnrichedFields?: Record<string, unknown>;
     fingerprint?: string;
     leadSessionId?: string;
@@ -71,4 +48,3 @@ export declare const createUpdateResponsePayload: (options: BuildPayloadOptions
     responseId: string;
 }) => FormUpdateResponsePayload;
 export {};
-//# sourceMappingURL=responsePayload.d.ts.map

package/dist/types/core/engine/schedulerEvents.d.ts

@@ -0,0 +1,40 @@
+
+
+export type SchedulerProvider = "Surface" | "Calendly" | "Hubspot" | "Cal" | "SavvyCal" | "RevenueHero" | "ReclaimAI" | "Clari" | "ChiliCal" | "Zoom";
+export type SchedulerBookingSummary = {
+    provider: SchedulerProvider;
+    
+    uri: string;
+    meetingTime?: string;
+    meetingEndTime?: string;
+    inviteeName?: string;
+    guestEmails?: string;
+    ownerEmails?: string;
+    joinLink?: string;
+    
+    raw?: unknown;
+};
+export type SchedulerLifecycleEvent = {
+    questionId: string;
+    stepId: string;
+    provider: SchedulerProvider;
+} & ({
+    type: "viewed";
+} | {
+    type: "date_selected";
+    date?: string;
+} | {
+    type: "slot_selected";
+    slot?: {
+        start: string;
+        end?: string;
+    };
+} | {
+    type: "form_opened";
+} | {
+    type: "booking_confirmed";
+    booking: SchedulerBookingSummary;
+} | {
+    type: "booking_cancelled";
+    reason?: string;
+});