@businessdash/sdk 0.9.60

package/dist/react.d.ts

@@ -0,0 +1,727 @@
+import { type CSSProperties, type ReactNode } from "react";
+import type { ChatbotAvailability, ChatbotChatResponse, ChatbotConfig, ChatbotFormDefinition, ChatbotFormSubmitInput, ChatbotFormSubmitResponse, CheckoutSessionInput, GetSiteMarketingPageResponse, SiteMarketingPage, SiteMarketingPageSummary } from "./contracts.js";
+import { type BiabFormsClient, type CreateFormControllerOptions } from "./forms-core/index.js";
+import type { FormSchema, FormSubmitResult } from "./sdk.js";
+type SessionState<T> = {
+    status: "idle";
+} | {
+    status: "loading";
+} | {
+    status: "ready";
+    session: T;
+} | {
+    status: "error";
+    error: Error;
+};
+export type BiabEmbedEvent = {
+    type: "biab:ready";
+    surface: string;
+} | {
+    type: "biab:cart:update";
+    count: number;
+    subtotalCents: number;
+} | {
+    type: "biab:cart:checkout-requested";
+    lines: Array<{
+        productId: string;
+        variantId: string;
+        combinationKey?: string;
+        quantity: number;
+    }>;
+} | {
+    type: "biab:checkout:success";
+    sessionId: string;
+    orderId?: string | null;
+} | {
+    type: "biab:checkout:cancel";
+    sessionId: string;
+} | {
+    type: "biab:checkout:error";
+    message: string;
+} | {
+    type: "biab:chatbot:user-message";
+    content: string;
+} | {
+    type: "biab:chatbot:assistant-message";
+    content: string;
+    model?: string;
+} | {
+    type: "biab:chatbot:error";
+    message: string;
+};
+type DashboardContextValue = {
+    state: SessionState<{
+        url: string;
+        token: string;
+        expiresAt: string;
+    }>;
+    refresh: () => Promise<void>;
+};
+export type DashboardProviderProps = {
+    apiKey: string;
+    baseUrl: string;
+    children: ReactNode;
+    refreshLeadMs?: number;
+};
+export declare function DashboardProvider({ apiKey, baseUrl, children, refreshLeadMs, }: DashboardProviderProps): import("react").JSX.Element;
+export declare function useDashboardSession(): DashboardContextValue;
+export type DashboardProps = {
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+};
+export declare function Dashboard({ className, style, title, loadingFallback, errorFallback, }?: DashboardProps): import("react").JSX.Element;
+export type StorefrontProps = {
+    apiKey: string;
+    baseUrl: string;
+    productId?: string;
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+    /** Fires for every event the embed posts. */
+    onEvent?: (event: BiabEmbedEvent) => void;
+    /** Convenience: fires only on cart updates. */
+    onCartChange?: (count: number, subtotalCents: number) => void;
+    refreshLeadMs?: number;
+};
+export declare function Storefront({ apiKey, baseUrl, productId, className, style, title, loadingFallback, errorFallback, onEvent, onCartChange, refreshLeadMs, }: StorefrontProps): import("react").JSX.Element;
+export type CartProps = {
+    apiKey: string;
+    baseUrl: string;
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+    onEvent?: (event: BiabEmbedEvent) => void;
+    onCartChange?: (count: number, subtotalCents: number) => void;
+    refreshLeadMs?: number;
+};
+export declare function Cart({ apiKey, baseUrl, className, style, title, loadingFallback, errorFallback, onEvent, onCartChange, refreshLeadMs, }: CartProps): import("react").JSX.Element;
+export type CheckoutProps = {
+    apiKey: string;
+    baseUrl: string;
+    cart: CheckoutSessionInput;
+    /** Render mode. `"redirect"` (default): button → top-level Stripe redirect.
+     * `"iframe"`: shows the embed iframe; Stripe opens in a new tab via
+     * `allow-top-navigation`. */
+    mode?: "redirect" | "iframe";
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    children?: ReactNode;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+    onEvent?: (event: BiabEmbedEvent) => void;
+    onSuccess?: (sessionId: string) => void;
+    onCancel?: (sessionId: string) => void;
+    onError?: (error: Error) => void;
+};
+export declare function Checkout(props: CheckoutProps): import("react").JSX.Element;
+/**
+ * Pair with `<Checkout/>` in `redirect` mode. Drop on the host's success URL
+ * (the URL passed as `cart.successUrl` when calling `client.checkout`). Reads
+ * `?session_id=…` from the URL and renders the resolved order summary.
+ */
+export type CheckoutResultProps = {
+    apiKey: string;
+    baseUrl: string;
+    orgSlug: string;
+    sessionIdParam?: string;
+    render?: (state: {
+        status: "loading" | "paid" | "unpaid" | "error";
+        error?: Error;
+        amountTotalCents?: number | null;
+        currency?: string | null;
+        customerEmail?: string | null;
+    }) => ReactNode;
+};
+export declare function CheckoutResult(props: CheckoutResultProps): import("react").JSX.Element;
+export type BlogProps = {
+    apiKey: string;
+    baseUrl: string;
+    postSlug?: string;
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+    onEvent?: (event: BiabEmbedEvent) => void;
+    refreshLeadMs?: number;
+};
+export type ChatbotProps = {
+    apiKey: string;
+    baseUrl: string;
+    className?: string;
+    style?: CSSProperties;
+    title?: string;
+    loadingFallback?: ReactNode;
+    errorFallback?: (error: Error, refresh: () => void) => ReactNode;
+    onEvent?: (event: BiabEmbedEvent) => void;
+    /** Convenience: fires when the assistant replies. */
+    onAssistantMessage?: (content: string, model?: string) => void;
+    refreshLeadMs?: number;
+};
+export declare function Chatbot({ apiKey, baseUrl, className, style, title, loadingFallback, errorFallback, onEvent, onAssistantMessage, refreshLeadMs, }: ChatbotProps): import("react").JSX.Element;
+/**
+ * Headless chat hook — for hosts that want to render their own chat UI but
+ * still drive every turn through the org's persisted chatbot config.
+ *
+ * Beyond `messages` and `send`, the hook tracks the latest `uiActions` (e.g.
+ * `show_form` — call {@link useChatbot}.getForm to fetch the definition and
+ * {@link useChatbot}.submitForm to POST a filled form back), and the latest
+ * `availability` snapshot (front-desk presence + wait-time hint) so the
+ * consumer can show or hide its "Talk to a person" CTA.
+ */
+export declare function useChatbot(options: {
+    apiKey: string;
+    baseUrl: string;
+}): {
+    messages: {
+        role: "user" | "assistant" | "system";
+        content: string;
+    }[];
+    send: (content: string) => Promise<ChatbotChatResponse | null>;
+    reset: () => void;
+    isPending: boolean;
+    error: Error | null;
+    getConfig: () => Promise<ChatbotConfig>;
+    latestUiActions: {
+        kind: "show_form";
+        formSlug: string;
+    }[];
+    availability: {
+        offline: boolean;
+        frontDeskEnabled: boolean;
+        staffAvailable: boolean;
+        estimateLabel: string | null;
+        onlineHandlers: {
+            name: string;
+            userId: string;
+            avatarUrl: string | null;
+        }[];
+    } | null;
+    refreshAvailability: () => Promise<ChatbotAvailability | null>;
+    getForm: (slug: string) => Promise<ChatbotFormDefinition | null>;
+    submitForm: (slug: string, input: ChatbotFormSubmitInput) => Promise<ChatbotFormSubmitResponse | null>;
+    uploadFile: (args: {
+        sessionId: string;
+        file: File;
+        uploaderEmail?: string | null;
+    }) => Promise<{
+        url: string;
+        name: string;
+        type: string;
+        size: number;
+    }>;
+};
+/**
+ * Slot-based className overrides for {@link ChatbotInline}. Every slot
+ * defaults to an empty string so the consumer's CSS / Tailwind owns the
+ * look. The component only ships the layout-essential inline styles
+ * (flex, overflow, scroll) — everything else is yours.
+ */
+export type ChatbotInlineClassNames = {
+    root?: string;
+    header?: string;
+    headerTitle?: string;
+    headerSubtitle?: string;
+    presenceStrip?: string;
+    presenceStripOnline?: string;
+    presenceStripAway?: string;
+    presenceStripOffline?: string;
+    presenceLabel?: string;
+    presenceEstimate?: string;
+    messageList?: string;
+    messageRow?: string;
+    messageUser?: string;
+    messageAssistant?: string;
+    messagePending?: string;
+    formCard?: string;
+    formTitle?: string;
+    formDescription?: string;
+    formField?: string;
+    formLabel?: string;
+    formInput?: string;
+    formTextarea?: string;
+    formSelect?: string;
+    formSubmit?: string;
+    formError?: string;
+    formReceipt?: string;
+    inputBar?: string;
+    inputField?: string;
+    sendButton?: string;
+    jumpButton?: string;
+    errorText?: string;
+};
+export type ChatbotInlineProps = {
+    apiKey: string;
+    baseUrl: string;
+    /** Optional welcome message shown before the visitor sends anything. */
+    welcomeMessage?: string;
+    /** Title shown in the header. Set to `null` to hide the header entirely. */
+    title?: string | null;
+    /** Subtitle shown beneath the title (e.g. the model id). Hidden when null. */
+    subtitle?: string | null;
+    classNames?: ChatbotInlineClassNames;
+    className?: string;
+    style?: CSSProperties;
+    /**
+     * Skip the injected default visual theme and render bare divs (the previous
+     * behavior). Leave false for the polished drop-in look; the defaults are
+     * zero-specificity, so any `classNames` you pass already override them — set
+     * this only if you want a completely unstyled baseline.
+     */
+    unstyled?: boolean;
+    /** Polling interval for availability (ms). Default 30s. Set to 0 to disable polling. */
+    availabilityPollMs?: number;
+    /**
+     * Optional render-prop overrides. When provided, replaces the default
+     * markup for that slot — full freedom for consumers who want to ship
+     * their own message bubbles, form cards, or presence strip.
+     */
+    renderMessage?: (item: {
+        kind: "text";
+        role: "user" | "assistant";
+        content: string;
+    } | {
+        kind: "form";
+        form: ChatbotFormDefinition;
+        submitted: boolean;
+    } | {
+        kind: "file";
+        file: {
+            url: string;
+            name: string;
+            type: string;
+            size: number;
+        };
+    }, index: number) => ReactNode;
+    renderPresenceStrip?: (availability: ChatbotAvailability) => ReactNode;
+    onAssistantMessage?: (content: string) => void;
+};
+/**
+ * In-tree React chatbot component. Same backend wiring as the iframe
+ * `<Chatbot />` (chat → uiActions → form fetch → submit + CRM mirrors,
+ * plus availability polling) but rendered directly in the consumer's
+ * DOM tree so they can style every piece with their own CSS / Tailwind.
+ *
+ * For zero-customization drop-in use, prefer `<Chatbot />` (iframe).
+ * For fully custom UI, use the `useChatbot()` hook directly.
+ */
+export declare function ChatbotInline({ apiKey, baseUrl, welcomeMessage, title, subtitle, classNames, className, style, unstyled, availabilityPollMs, renderMessage, renderPresenceStrip, onAssistantMessage, }: ChatbotInlineProps): import("react").JSX.Element;
+export declare function Blog({ apiKey, baseUrl, postSlug, className, style, title, loadingFallback, errorFallback, onEvent, refreshLeadMs, }: BlogProps): import("react").JSX.Element;
+import type { TenantAuthMeResponse } from "./contracts.js";
+type AuthLinkProps = {
+    /** Where to send the user after auth completes. */
+    returnTo?: string;
+    /** Pre-fill the email field on the platform-hosted page. */
+    loginHint?: string;
+    /** Override the basePath the auth-handler is mounted at. */
+    basePath?: string;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+};
+export declare function SignIn({ children, ...rest }: AuthLinkProps): import("react").JSX.Element;
+export declare function SignUp({ children, ...rest }: AuthLinkProps): import("react").JSX.Element;
+export declare function SignOut({ children, basePath, className, style, }: AuthLinkProps): import("react").JSX.Element;
+export type ProgrammaticAuthOptions = {
+    /** Where to send the user after auth completes. Defaults server-side. */
+    returnTo?: string;
+    /** Pre-fill the email on the platform-hosted page (sign-in / sign-up only). */
+    loginHint?: string;
+    /** Override the auth-handler basePath. Defaults to "/api/biab-auth". */
+    basePath?: string;
+};
+/**
+ * Programmatic sign-in — navigates the browser through the auth handler's
+ * `/sign-in` route. Equivalent to clicking `<SignIn />`. Browser-only.
+ */
+export declare function signIn(options?: ProgrammaticAuthOptions): void;
+/**
+ * Programmatic sign-up — navigates through `/sign-up`. Equivalent to
+ * clicking `<SignUp />`. Browser-only.
+ */
+export declare function signUp(options?: ProgrammaticAuthOptions): void;
+export type ProgrammaticSignOutOptions = {
+    /** Override the auth-handler basePath. Defaults to "/api/biab-auth". */
+    basePath?: string;
+    /**
+     * Default `"redirect"` — navigates through `/sign-out` (matches the
+     * `<SignOut />` anchor). Use `"fetch"` when you want to clear the
+     * session without a top-level navigation (e.g. just before showing
+     * a "signed out" state in your own UI). The fetch path returns
+     * `{ ok: true }` after clearing the cookie.
+     */
+    mode?: "redirect" | "fetch";
+};
+/**
+ * Programmatic sign-out. Defaults to a redirect through the auth
+ * handler's `/sign-out` route (same as `<SignOut />`). Pass
+ * `{ mode: "fetch" }` for a fetch-based clear that resolves with
+ * `{ ok: true }` and does not navigate.
+ */
+export declare function signOut(options?: ProgrammaticSignOutOptions): Promise<{
+    ok: boolean;
+}>;
+export type ProgrammaticPasswordResetInput = {
+    email: string;
+    /** Override the auth-handler basePath. Defaults to "/api/biab-auth". */
+    basePath?: string;
+    /**
+     * Optional return path the platform-hosted reset page sends the user to
+     * after they set a new password. Server-side falls back to the org's
+     * sign-in landing page when omitted.
+     */
+    returnTo?: string;
+};
+/**
+ * Programmatic "forgot password" — POSTs to the auth handler's
+ * `/password-reset` route, which the SDK forwards to BIAB. The server
+ * returns `{ ok: true }` regardless of whether an account matched
+ * (intentional anti-leak), and emails the platform-hosted reset link
+ * out-of-band when a match exists.
+ */
+export declare function requestPasswordReset(input: ProgrammaticPasswordResetInput): Promise<{
+    ok: boolean;
+}>;
+type UseUserState = {
+    status: "loading";
+    user: null;
+} | {
+    status: "signed-in";
+    user: NonNullable<TenantAuthMeResponse>;
+} | {
+    status: "signed-out";
+    user: null;
+};
+/**
+ * Reads the current tenant session by hitting the `/me` route the SDK's
+ * auth-handler exposes on the tenant's own domain. No props needed because
+ * the cookie + handler path are the source of truth.
+ */
+export declare function useUser(options?: {
+    basePath?: string;
+}): UseUserState;
+export type UseFollowersOptions = {
+    /** Publishable token (`pk_…`) — browser-safe (origin-locked, rate-limited,
+     *  scoped to `followers:self`). */
+    token: string;
+    /** Site id (shown in Site Builder → Developer). */
+    siteId: string;
+    /** Package-API base URL. Defaults to production (the apex). */
+    baseUrl?: string;
+};
+/**
+ * Visitor-facing followers/subscribe client, bound to a publishable token so it
+ * works browser-side with no backend.
+ *
+ *   const f = useFollowers({ token: pk, siteId });
+ *   if (!f.subscribedLocally) showForm();          // anonymous "already subscribed?" hint
+ *   await f.join({ email, name, source: "footer" }); // subscribe (+ remembers this browser)
+ *   const { follower } = await f.me(user.email);     // authoritative status (logged-in)
+ *   await f.leave(email);                            // unsubscribe (+ forgets)
+ *
+ * Source of truth for "is this visitor subscribed":
+ *   - Logged-in → pass `user.email` to `me()` (authoritative, cross-device).
+ *   - Anonymous → `subscribedLocally` — a per-browser flag set on `join()`.
+ *     Email is the real key; this is just a privacy-friendly UX hint so an
+ *     anonymous visitor isn't shown the form forever. Clearing storage / a new
+ *     device re-shows it, and re-subscribing is idempotent (no dupes). IP is
+ *     deliberately NOT used (shared NAT hides the form from non-subscribers).
+ *
+ * `useUser()` covers the auth session; this covers follower status + subscribe,
+ * which the session doesn't include. All actions are `followers:self`, so a
+ * publishable token can run them.
+ */
+export declare function useFollowers(options: UseFollowersOptions): {
+    join: (input: {
+        email: string;
+        name?: string;
+        source?: string;
+    }) => Promise<{
+        follower: {
+            email: string;
+            id: string;
+            isActive: boolean;
+            joinedAt: string;
+            name?: string | null | undefined;
+            source?: string | null | undefined;
+            unsubscribedAt?: string | null | undefined;
+        };
+        created: boolean;
+    }>;
+    leave: (email: string) => Promise<{
+        follower: {
+            email: string;
+            id: string;
+            isActive: boolean;
+            joinedAt: string;
+            name?: string | null | undefined;
+            source?: string | null | undefined;
+            unsubscribedAt?: string | null | undefined;
+        } | null;
+    }>;
+    me: (email: string) => Promise<{
+        follower: {
+            email: string;
+            id: string;
+            isActive: boolean;
+            joinedAt: string;
+            name?: string | null | undefined;
+            source?: string | null | undefined;
+            unsubscribedAt?: string | null | undefined;
+        } | null;
+    }>;
+    edit: (email: string, patch: {
+        name?: string;
+        source?: string;
+    }) => Promise<{
+        follower: {
+            email: string;
+            id: string;
+            isActive: boolean;
+            joinedAt: string;
+            name?: string | null | undefined;
+            source?: string | null | undefined;
+            unsubscribedAt?: string | null | undefined;
+        };
+    }>;
+    /** This browser already subscribed (instant, no network). Use to hide a
+     *  newsletter form for anonymous visitors. */
+    subscribedLocally: boolean;
+    /** Email this browser subscribed with — pass to `me()` for an
+     *  authoritative re-check, or `null` if this browser hasn't subscribed. */
+    localEmail: string | null;
+};
+type MarketingPageState = {
+    status: "idle";
+    page: null;
+} | {
+    status: "loading";
+    page: null;
+} | {
+    status: "ready";
+    page: SiteMarketingPage | null;
+} | {
+    status: "error";
+    page: null;
+    error: Error;
+};
+/**
+ * Lazy-fetch a single marketing page by `pageKey`. The hook reads from the
+ * SDK's shared cache when present (warmed by `useMarketingPagePreloader` or
+ * a previous `useMarketingPage` render) and only hits the network when the
+ * cache is empty — so navigating between pages on a many-page site only
+ * fetches the page the visitor actually views.
+ *
+ * Pass `enabled: false` to gate the request on something async (e.g., wait
+ * for the visitor to consent before loading the privacy page).
+ */
+export declare function useMarketingPage(options: {
+    apiKey: string;
+    baseUrl: string;
+    siteId: string;
+    pageKey: string;
+    enabled?: boolean;
+}): MarketingPageState & {
+    refresh: () => Promise<void>;
+};
+type MarketingPageListState = {
+    status: "idle";
+    pages: null;
+} | {
+    status: "loading";
+    pages: null;
+} | {
+    status: "ready";
+    pages: SiteMarketingPageSummary[];
+} | {
+    status: "error";
+    pages: null;
+    error: Error;
+};
+/**
+ * Loads the payload-free directory of marketing pages for a site. Pair with
+ * `useMarketingPage(siteId, pageKey)` to render the selected page lazily.
+ */
+export declare function useMarketingPagesList(options: {
+    apiKey: string;
+    baseUrl: string;
+    siteId: string;
+    enabled?: boolean;
+}): MarketingPageListState & {
+    refresh: () => Promise<void>;
+};
+/**
+ * Returns a stable `preload(pageKey)` function that warms the SDK cache for
+ * the next page without rendering anything yet. Common pattern: wire it to
+ * `<Link onPointerEnter>` / `onFocus` so the next page is ready by the time
+ * the visitor clicks. Idempotent — repeat calls are free.
+ */
+export declare function useMarketingPagePreloader(options: {
+    apiKey: string;
+    baseUrl: string;
+    siteId: string;
+}): (pageKey: string) => Promise<GetSiteMarketingPageResponse | null>;
+export { useMarketingBundlePreloader, useMarketingLocales, useMarketingPageBundle, useMarketingPageSeo, useMarketingSection, usePublishedMarketingSchema, } from "./react-marketing.js";
+/**
+ * Drop-in email-verification widget for the customer's notification
+ * preferences page. Customer enters an email, we mint + send a
+ * verification link, they click the link, the deep-link target
+ * page consumes the token via {@link VerifyEmailConfirm}.
+ */
+export declare function VerifyEmailFlow(props: {
+    apiKey: string;
+    baseUrl: string;
+    sessionToken: string;
+    currentEmail?: string | null;
+    onSent?: (destination: string) => void;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * Deep-link target for an email verification flow. Reads the `token`
+ * prop (typically pulled from the URL query string), confirms it
+ * server-side, and renders success / failure.
+ */
+export declare function VerifyEmailConfirm(props: {
+    apiKey: string;
+    baseUrl: string;
+    sessionToken: string;
+    token: string;
+    onVerified?: (destination: string) => void;
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * Inline SMS-OTP verification flow. Two phases, no round-trip
+ * deep link. 6-digit OTP, 5-minute TTL.
+ */
+export declare function VerifyPhoneFlow(props: {
+    apiKey: string;
+    baseUrl: string;
+    sessionToken: string;
+    currentPhone?: string | null;
+    onVerified?: (destination: string) => void;
+    className?: string;
+}): import("react").JSX.Element;
+export type { BiabFormsClient };
+/** Production package-API base URL — the default target for a publishable token
+ *  when no `baseUrl` is supplied. Override via the `baseUrl` prop for staging or
+ *  a custom host. Use the **apex** host: `www.biab.app` 307-redirects to the
+ *  apex, and a CORS preflight does not follow redirects (the browser fails the
+ *  request), so a browser publishable-token client must target the apex. */
+export declare const DEFAULT_PACKAGE_BASE_URL = "https://biab.app/api/package/v1";
+export type BiabFormProviderProps = {
+    /** A forms client (or same-origin proxy). Provide this OR a publishable `token`. */
+    client?: BiabFormsClient;
+    /**
+     * A publishable token (`pk_…`) — builds a browser client that calls BIAB
+     * directly. Safe in browser JS: it's origin-locked (the browser sends Origin
+     * automatically), rate-limited, and scoped to public read/submit actions
+     * only. Requires `siteId`. Use instead of `client` for the zero-backend path.
+     */
+    token?: string;
+    /** Site id for the `token` client (shown in Site Builder → Developer). */
+    siteId?: string;
+    /** Package-API base URL for the `token` client. Defaults to production. */
+    baseUrl?: string;
+    children: ReactNode;
+};
+/** Provide a BIAB forms client to every nested `<BiabForm>`. Pass a `client`, or
+ *  a publishable `token` + `siteId` (+ optional `baseUrl`) to build a browser
+ *  client. */
+export declare function BiabFormProvider({ client, token, siteId, baseUrl, children, }: BiabFormProviderProps): import("react").JSX.Element;
+/** Read the client from a surrounding `<BiabFormProvider>`, if any. */
+export declare function useBiabFormsClient(): BiabFormsClient | null;
+export type BiabFormProps = {
+    /** Form slug to load via the client. Omit when passing a pre-fetched `schema`. */
+    slug?: string;
+    /**
+     * SDK client (or same-origin proxy). Falls back to `token`, then to a
+     * surrounding `<BiabFormProvider>`. Required unless a pre-fetched `schema` is
+     * supplied AND no submit is needed (submit needs a client).
+     */
+    client?: BiabFormsClient;
+    /**
+     * A publishable token (`pk_…`) — builds a browser client that calls BIAB
+     * directly, so `<BiabForm slug token siteId />` works with zero backend
+     * wiring. Safe in browser JS (origin-locked, rate-limited, public
+     * read/submit only). Requires `siteId`.
+     */
+    token?: string;
+    /** Site id for the `token` client (shown in Site Builder → Developer). */
+    siteId?: string;
+    /** Package-API base URL for the `token` client. Defaults to production. */
+    baseUrl?: string;
+    /** Pre-fetched schema (SSR / RSC). Adopted synchronously; no schema fetch. */
+    schema?: FormSchema;
+    /** Provenance / recipient passthrough merged into every submit. */
+    submitOptions?: CreateFormControllerOptions["submitOptions"];
+    /** Validate against the live schema server-side but store nothing. */
+    dryRun?: boolean;
+    /** Label for the final Submit button. */
+    submitLabel?: string;
+    /** Called with the final values after the controller validates locally and the
+     *  submit resolves successfully. */
+    onSubmit?: (values: Record<string, unknown>) => void;
+    onSuccess?: (result: Extract<FormSubmitResult, {
+        ok: true;
+    }>) => void;
+    onError?: (result: Extract<FormSubmitResult, {
+        ok: false;
+    }>) => void;
+    /** Render when the schema is loading. */
+    loadingFallback?: ReactNode;
+    /** Render when the schema fails to load (receives the message). */
+    errorFallback?: (message: string) => ReactNode;
+    /** Render after a successful submit instead of the default confirmation. */
+    successFallback?: (result: Extract<FormSubmitResult, {
+        ok: true;
+    }>) => ReactNode;
+    /**
+     * HTML autofill default for every input in the form. `true` (default) infers
+     * a sensible `autocomplete` token per field (name/email/tel/address/…) so
+     * browsers offer autofill; `false` emits `autocomplete="off"` on all inputs.
+     * Override individual fields with `fieldAutoComplete`.
+     */
+    autoComplete?: boolean;
+    /**
+     * Per-field autofill overrides, keyed by field id. A literal token
+     * (e.g. "email", "given-name", "off"), `true` (force inference), or `false`
+     * (off). Wins over `autoComplete` and any schema-level token.
+     */
+    fieldAutoComplete?: Record<string, string | boolean>;
+    /** Extra class on the root `.biab-form` element. `class` is accepted as an
+     *  alias for non-JSX callers / parity with other framework bindings. */
+    className?: string;
+    class?: string;
+    style?: CSSProperties;
+};
+export declare function BiabForm(props: BiabFormProps): import("react").JSX.Element;
+export type SocialLinksProps = {
+    /** The company profile's `socials` record (e.g. `storefrontMeta().socials`). */
+    socials: unknown;
+    /**
+     * Icon color for branded glyphs — a hex (no `#`) or CSS color keyword passed
+     * to the simple-icons CDN. Omit to use each brand's official color.
+     */
+    color?: string;
+    /** Icon edge length in px (default 20). */
+    size?: number;
+    className?: string;
+    linkClassName?: string;
+    iconClassName?: string;
+};
+/**
+ * Render every social profile on the company as an icon + link, in canonical
+ * order, resolving BIAB's exact keys (`meta`, `twitterX`, …) for you. Branded
+ * glyphs come from the simple-icons CDN; platforms without one fall back to a
+ * globe. Returns `null` when no socials are set.
+ */
+export declare function SocialLinks({ socials, color, size, className, linkClassName, iconClassName, }: SocialLinksProps): import("react").JSX.Element | null;
+//# sourceMappingURL=react.d.ts.map