@businessdash/sdk 0.9.60

package/dist/sdk.d.ts

@@ -0,0 +1,678 @@
+/**
+ * High-level SDK surface — what the consumer actually writes against.
+ *
+ * The principle: the consumer authors design + granular data requests,
+ * and that's it. Auth, caching, revalidation, tagging, retries — all
+ * handled inside this module so the consumer code reads as:
+ *
+ *   const items = await biab.gallery.list({
+ *     limit: 12,
+ *     fields: ["src", "title", "category", "blurDataURL"],
+ *   });
+ *
+ * Auto-applied per request:
+ *   • `Authorization: Bearer <apiKey>`
+ *   • `next: { tags: ["biab:<resource>", "biab:site:<orgId-when-known>"],
+ *              revalidate: <longBackstop> }`  — invisible on non-Next
+ *     runtimes that ignore the `next` key
+ *   • Field selection forwarded as `?fields=…` so the platform
+ *     SELECTs only what's needed.
+ *
+ * The companion `@businessdash/sdk/next/revalidate` route export closes
+ * the loop: when BIAB POSTs `content.published`, the route handler
+ * verifies the HMAC and calls `revalidateTag(...)` to bust the local
+ * Next cache. End-to-end, the consumer wrote ~5 lines.
+ */
+import { BiabDevAddressClient, BiabDevBlogClient, BiabDevCartClient, BiabDevCheckoutClient, BiabDevCouponsClient, BiabDevCustomerPortalClient, BiabDevFollowersClient, BiabDevMarketingClient, BiabDevMarketingPagesClient, BiabDevNotificationsClient, BiabDevParallelPagesClient, BiabDevReviewsClient, BiabDevShippingClient, BiabDevStorefrontClient, BiabDevSubscriptionsClient } from "./client.js";
+import type { BundleGalleryItem } from "./gallery-types.js";
+export interface CreateBiabClientOptions {
+    apiKey: string;
+    siteId: string;
+    baseUrl?: string;
+    /** Override the default 24h ISR backstop. */
+    revalidateSeconds?: number;
+    /** Custom fetch (testing, instrumentation, edge runtimes). */
+    fetch?: typeof fetch;
+    /**
+     * Optional `Origin` to forward — required when the API key has an
+     * Allowed Host configured on the platform (server-to-server fetch
+     * does not send `Origin` automatically).
+     */
+    siteOrigin?: string;
+}
+export type GalleryField = keyof BundleGalleryItem;
+export interface GalleryListParams<F extends readonly GalleryField[]> {
+    limit?: number;
+    fields?: F;
+}
+export type GalleryItemFor<F extends readonly GalleryField[]> = {
+    [K in F[number]]: BundleGalleryItem[K];
+};
+export interface GalleryResource {
+    list<const F extends readonly GalleryField[]>(params?: GalleryListParams<F>): Promise<GalleryItemFor<F>[]>;
+}
+/**
+ * Public-facing shape of an event type the consumer renders into a
+ * "book a meeting" page. Matches `/sites/{siteId}/scheduling/event-types`.
+ */
+export interface SchedulingEventType {
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    durationMinutes: number;
+    locationType: string;
+    meetingProvider: string | null;
+    color: string | null;
+    requiresApproval: boolean;
+}
+export interface SchedulingQuestion {
+    id: string;
+    label: string;
+    fieldType: string;
+    optionsJson: unknown;
+    isRequired: boolean;
+    sortOrder: number;
+}
+/**
+ * A booking as returned by `getBookingByToken`.
+ *
+ * Timestamps are ISO-8601 **strings**. The server holds them as `Date` and
+ * they cross the wire as JSON, so typing them `Date` here would compile and
+ * then fail at runtime on the first `.getTime()`.
+ */
+export interface SchedulingBookingView {
+    booking: {
+        id: string;
+        startAt: string;
+        endAt: string;
+        status: SchedulingBookingStatus;
+        title: string;
+        notes: string | null;
+        conferenceLink: string | null;
+    };
+    invitee: {
+        name: string;
+        email: string;
+        timezone: string;
+    } | null;
+    eventType: {
+        name: string;
+        slug: string;
+        durationMinutes: number;
+        locationType: string;
+    } | null;
+}
+/** What `rescheduleBooking` echoes back — the booking's new window. */
+export interface SchedulingRescheduleResult {
+    bookingId: string;
+    startAt: string;
+    endAt: string;
+}
+export interface SchedulingSlot {
+    startAt: string;
+    endAt: string;
+}
+export interface SchedulingInvitee {
+    email: string;
+    name: string;
+    phone?: string | null;
+    timezone: string;
+}
+export interface SchedulingAnswer {
+    questionId: string;
+    valueText: string;
+}
+/**
+ * Booking lifecycle states, mirroring the `booking_status` pg enum.
+ *
+ * Note the spelling: the platform stores **`canceled`** (one L). This type
+ * previously read `"pending" | "confirmed" | "cancelled" | string`, which was
+ * wrong twice over — the two-L spelling matches nothing the server ever
+ * sends, and the trailing `| string` widened the union back to `string` so
+ * neither the typo nor the missing `no_show` could ever surface. Keep this
+ * closed; a new state should land here as a deliberate edit.
+ */
+export type SchedulingBookingStatus = "confirmed" | "pending" | "canceled" | "no_show";
+export interface SchedulingBookingResult {
+    bookingId: string;
+    status: SchedulingBookingStatus;
+    manageToken: string;
+    rescheduleToken: string;
+    cancelToken: string;
+    payment: {
+        clientSecret: string;
+        amountCents: number;
+        currency: string;
+    } | null;
+}
+export interface SchedulingResource {
+    listEventTypes(): Promise<SchedulingEventType[]>;
+    getEventType(slug: string): Promise<{
+        eventType: SchedulingEventType;
+        questions: SchedulingQuestion[];
+    }>;
+    getAvailableSlots(slug: string, params: {
+        from: Date;
+        to: Date;
+    }): Promise<SchedulingSlot[]>;
+    confirmBooking(input: {
+        eventTypeSlug: string;
+        startAt: Date;
+        invitee: SchedulingInvitee;
+        answers?: SchedulingAnswer[];
+        notes?: string | null;
+        schedulingLinkId?: string;
+        holderKey?: string | null;
+    }): Promise<SchedulingBookingResult>;
+    getBookingByToken(token: string, type?: "manage" | "cancel" | "reschedule"): Promise<SchedulingBookingView>;
+    rescheduleBooking(input: {
+        token: string;
+        newStartAt: Date;
+        reason?: string | null;
+    }): Promise<SchedulingRescheduleResult>;
+    cancelBooking(input: {
+        token: string;
+        reason?: string | null;
+    }): Promise<{
+        ok: true;
+    }>;
+}
+/**
+ * Public-facing description of one form field. Mirrors BIAB's
+ * `FormField` type so the consumer can type their submission payload
+ * against the schema fetched at runtime.
+ */
+export interface FormFieldDef {
+    id: string;
+    /**
+     * Stable, human-readable output key for this field's value (camelCase or
+     * snake_case, per the form's configuration). Prefer this when building the
+     * submission payload. The server also accepts the UUID `id` for back-compat,
+     * so older integrations keep working.
+     */
+    key?: string;
+    label: string;
+    type: string;
+    required: boolean;
+    /**
+     * Consent semantic for `type === "boolean"`: the value must be `true` to
+     * submit (e.g. "I agree"). Independent of `display`. When false/unset, an
+     * optional/required boolean accepts true OR false.
+     */
+    mustBeTrue?: boolean;
+    /** Boolean UI variant: "toggle" (default switch) or "checkbox". */
+    display?: "toggle" | "checkbox";
+    /**
+     * select / radio / checkbox: an "Other…" free-text value outside `options`
+     * is allowed. When true, the value may be any string (single) or include a
+     * non-option string (checkbox array); the options whitelist isn't enforced.
+     */
+    allowCustom?: boolean;
+    placeholder?: string;
+    helpText?: string;
+    options?: string[];
+    regexPattern?: string;
+    validation?: {
+        min?: number;
+        max?: number;
+    };
+    /**
+     * Set on file-type fields (`type === "file_upload"`). The SDK
+     * uploader enforces these client-side as a UX nicety; the
+     * server is the source of truth and re-enforces them when
+     * minting the upload URL.
+     */
+    fileConfig?: {
+        allowedTypes?: string[];
+        maxFiles?: number;
+        maxSize?: number;
+    };
+    /** Phone-field config — `international` switches the digit-count rule. */
+    phoneConfig?: {
+        international?: boolean;
+    };
+    /**
+     * choice_cards config: a set of selectable cards. `single` = radio semantics
+     * (value is the chosen option `label`); `multi` = checkbox semantics (value is
+     * a `string[]` of chosen labels). Options may carry richer card content
+     * (image/price/description/etc.) for showcasing a product or service — that
+     * content is display + metadata only; the submitted value is always the
+     * `label`, so validation is unaffected by the extra fields.
+     */
+    choiceConfig?: {
+        mode?: "single" | "multi";
+        options?: Array<{
+            label: string;
+            /** Lucide icon name (kebab-case, e.g. "phone"). */
+            icon?: string;
+            /** Image to show on the card (URL). */
+            imageUrl?: string;
+            /** Display price string (e.g. "$49/mo"). */
+            price?: string;
+            /** Short supporting description shown under the label. */
+            description?: string;
+            /** Your catalog id for this option (product/service) — metadata only. */
+            productId?: string;
+            /** Optional link for the card (e.g. a product detail page). */
+            href?: string;
+        }>;
+    };
+    /**
+     * Display content for static elements. For `richtext` this is
+     * server-sanitized HTML; for `body_text` it is plain text. Carries no
+     * submitted value.
+     */
+    content?: string;
+    /**
+     * `bullet_list` display element. `variant: "bullets"` → optional `title` +
+     * plain bullet `items[].text`; `variant: "details"` → one row per point with
+     * an optional Lucide `icon`, a `text` heading, and a `description`. Display
+     * only — carries no submitted value.
+     */
+    listConfig?: {
+        variant?: "bullets" | "details";
+        title?: string;
+        items?: Array<{
+            text: string;
+            description?: string;
+            icon?: string;
+        }>;
+    };
+    /**
+     * `table` display element. `columns` (header / `type` "text"|"check" / align)
+     * + `rows[].cells` aligned to columns by index; a "check" column renders ✓/–
+     * from a truthy/falsy cell. `highlightColumn` emphasizes one column. Display
+     * only — carries no submitted value.
+     */
+    tableConfig?: {
+        columns?: Array<{
+            header: string;
+            type?: "text" | "check";
+            align?: "left" | "center" | "right";
+        }>;
+        rows?: Array<{
+            cells: string[];
+        }>;
+        highlightColumn?: number;
+    };
+    /**
+     * `multi_populator` repeater: the submitted value is an ARRAY of instance
+     * records, each keyed by the child field ids/keys (same shape as a scoped
+     * submission). `maxInstances` caps the count. The template fields live on
+     * `children` in the rendered schema tree.
+     */
+    populatorConfig?: {
+        maxInstances?: number;
+        minInstances?: number;
+        addButtonLabel?: string;
+        itemLabel?: string;
+    };
+    /**
+     * `measurement` field: a number + unit. The submitted value is
+     * `{ value, unit, base, baseUnit }` — `base` is `value` in the category's base
+     * unit (server-computed, for downstream sorting). `outputUnit` is the org's
+     * preferred unit (convert `base` → `outputUnit` to resolve internally).
+     */
+    unitConfig?: {
+        category?: string;
+        units?: string[];
+        mode?: "select" | "fixed";
+        defaultUnit?: string;
+        outputUnit?: string;
+        allowDecimal?: boolean;
+    };
+    /** `number` field: when false, only whole numbers are accepted. */
+    allowDecimal?: boolean;
+    /** `number` field: when false, negatives are rejected (enforce >= 0). */
+    allowNegative?: boolean;
+    /** `currency` field: ISO code / symbol + whether negatives are allowed. */
+    currencyConfig?: {
+        currency?: string;
+        symbol?: string;
+        allowNegative?: boolean;
+        allowDecimal?: boolean;
+    };
+    /**
+     * `calculation` (Math) element: a value computed from other fields via an
+     * inline `formula` or a referenced business `functionId` (pick `outputKey`).
+     * `inputMap` binds variable / function-input names to source field ids.
+     * Non-sensitive calcs compute live client-side (using `schema.businessFunctions`
+     * for function refs); `sensitive` ones compute server-side on submit and are
+     * published WITHOUT their formula/def — the field shows a placeholder until
+     * the submitted value comes back.
+     */
+    calculationConfig?: {
+        mode?: "formula" | "function";
+        formula?: string;
+        functionId?: string;
+        outputKey?: string;
+        inputMap?: Array<{
+            variable: string;
+            fieldId: string;
+        }>;
+        display?: {
+            show?: boolean;
+            prefix?: string;
+            suffix?: string;
+            decimals?: number;
+        };
+        sensitive?: boolean;
+    };
+    /**
+     * `credit_card` element — collect a card via Stripe Elements (`<BiabForm/>`
+     * only). `card_on_file` saves the card (SetupIntent); `deposit` charges
+     * `amountCents` now (PaymentIntent). The card is created on the org's Stripe
+     * connected account via `forms.paymentIntent(slug, fieldId)`; the submission
+     * stores only the opaque intent id + brand/last4 (PCI-safe). Added in 0.9.9.
+     */
+    paymentConfig?: {
+        mode?: "card_on_file" | "deposit";
+        amountCents?: number;
+        currency?: string;
+        buttonLabel?: string;
+        description?: string;
+    };
+    /**
+     * `schedule` element (availability v1). The visitor states when they're free;
+     * the submitted value is `{ asap?, days?: string[], times?: string[], notes? }`.
+     * `<BiabForm/>` renders day + time-window chips, an ASAP toggle, and notes.
+     * Added in 0.9.9.
+     */
+    scheduleConfig?: {
+        mode?: "availability";
+        allowAsap?: boolean;
+        days?: string[];
+        timeWindows?: string[];
+        allowNotes?: boolean;
+    };
+}
+/**
+ * Value shape stored in `data` for a file field after the upload
+ * completes. The hiring mirror at `src/server/forms/hiring-mirror.ts`
+ * reads these exact fields to populate `job_application_files` — the
+ * SDK keeps the contract honest.
+ */
+export interface FormFileValue {
+    storageId: string;
+    url: string;
+    name: string;
+    mimeType: string;
+    size: number;
+}
+/** How the org configured the form to render — apply these for a 1:1 match. */
+export interface FormRenderSettings {
+    animation?: "none" | "fade" | "slide" | "scale" | "scroll";
+    isConsecutive?: boolean;
+    showProgress?: boolean;
+    progressStyle?: "bar" | "steps";
+    /**
+     * Warn before the visitor abandons a dirty, unsubmitted form. `<BiabForm/>`
+     * attaches a `beforeunload` guard when `enabled` (the browser shows a generic
+     * prompt); `message` is provided so you can show it in your own modal too.
+     */
+    exitConfirm?: {
+        enabled?: boolean;
+        message?: string;
+    };
+    /**
+     * Present (true) only when the org's subscription (or platform-admin access)
+     * grants link-safety checking AND the form has url fields. When absent, the
+     * org hasn't paid for it — do no extra URL verification. The reputation scan
+     * runs server-side on submit (it needs the platform's API key); this flag just
+     * tells the form the feature is active so you can surface it.
+     */
+    urlSafety?: boolean;
+}
+/** Action types a form can run on submit (see {@link FormActionPreview}). */
+export type FormActionType = "add_follower" | "unsubscribe" | "send_webhook" | "autoresponder_email" | "grant_coupon";
+/**
+ * Sanitized preview of an on-submit action — `type` + the optional condition
+ * that gates it. The action's wiring (URLs, secrets, email bodies, field
+ * mapping) stays server-side; execution happens automatically on submit. Use
+ * this to preview to the user what submitting will do (e.g. "you'll be added
+ * to the list"). Added in 0.9.7.
+ */
+export interface FormActionPreview {
+    type: FormActionType;
+    condition?: {
+        fieldId: string;
+        operator: string;
+        value?: string;
+    } | null;
+    /**
+     * `grant_coupon` only: the display-safe coupon notice to show before submit
+     * (e.g. "{code} will be applied to this inquiry"). `<BiabForm/>` renders it
+     * above the submit button. The coupon id / field mapping never leave the
+     * server. Added in 0.9.9.
+     */
+    coupon?: {
+        code?: string;
+        notice?: string;
+        finePrint?: string;
+    };
+}
+export interface FormSchema {
+    id: string;
+    slug: string;
+    title?: string;
+    description?: string | null;
+    fields: FormFieldDef[];
+    /** Render settings (animation, multi-step, progress). Added in 0.9.7. */
+    settings?: FormRenderSettings;
+    /** Org icon URL when the form opts into `showOrgIcon`. Added in 0.9.7. */
+    orgIcon?: string;
+    /** On-submit actions this form will run (sanitized). Added in 0.9.7. */
+    actions?: FormActionPreview[];
+    /**
+     * NON-sensitive business functions referenced by this form's `calculation`
+     * fields, so the SDK can compute them live in the browser. Sensitive
+     * functions are NEVER included — they run server-side on submit. Added in
+     * 0.9.9.
+     */
+    businessFunctions?: Array<{
+        id: string;
+        slug: string;
+        inputs: Array<{
+            key: string;
+            label?: string;
+            type: string;
+            required?: boolean;
+            default?: unknown;
+        }>;
+        outputs: Array<{
+            key: string;
+            label?: string;
+            type: string;
+            formula: string;
+            fallback?: unknown;
+        }>;
+    }>;
+}
+export type FormSubmissionData = Record<string, unknown>;
+export interface FormValidationIssue {
+    fieldId: string;
+    label: string;
+    reason: "required" | "type" | "min" | "max" | "regex" | "options" | "format" | "unknown_field" | "invalid_payload" | "too_many_fields" | (string & {});
+    message: string;
+}
+export interface FormValidationResult {
+    ok: boolean;
+    issues: FormValidationIssue[];
+}
+/**
+ * Runtime validate a submission against the fetched form schema.
+ * Returns `ok: true` only when every required field is present and
+ * every supplied value passes its type / min / max / regex /
+ * options check. Designed to mirror what BIAB's server enforces so
+ * the consumer can show inline errors before round-tripping.
+ *
+ * For build-time type safety, the future `biab-dev codegen forms`
+ * CLI emits a `.d.ts` per form so TypeScript can also enforce
+ * shape at compile time. Until that ships, this runtime check is
+ * the safety net.
+ */
+/**
+ * Narrow check for the shape `biab.forms.uploadFile` returns —
+ * mirrors what the BIAB hiring mirror reads (storageId, url, name,
+ * mimeType, size). Used by both `validateFormSubmission` and any
+ * caller that wants to assert "this value is a successful upload."
+ */
+export declare function isFormFileValue(value: unknown): value is FormFileValue;
+export declare function validateFormSubmission(schema: FormSchema, data: FormSubmissionData): FormValidationResult;
+/**
+ * Why a `forms.submit` call didn't succeed. Lets the consumer branch the UI
+ * without parsing error strings.
+ *
+ * - `client_validation_failed` — the local `validateFormSubmission` caught it
+ *   before any network call (see `issues`).
+ * - `validation_failed` — the server rejected the payload against the live form
+ *   schema (unknown field, wrong type/format, failed required, oversized, …).
+ *   This is also what a value the validator considers unsafe surfaces as. See
+ *   `issues`.
+ * - `unauthorized` — missing / invalid / expired package API key (401).
+ * - `forbidden` — the key lacks the scope/permission, or the request origin
+ *   isn't on the key's allowed-host list (403).
+ * - `plan_required` — the org's plan doesn't include forms (entitlement gate).
+ * - `payment_required` — the org's BIAB billing is past due.
+ * - `service_suspended` — the org's BIAB billing has lapsed 60+ days.
+ * - `rate_limited` — too many submissions too fast (429).
+ * - `not_found` — the form doesn't exist, is inactive, or isn't accepting
+ *   external submissions (404).
+ * - `invalid_request` — the request body was malformed (400).
+ * - `server_error` — BIAB failed to process the submission (5xx).
+ * - `network_error` — the request never reached BIAB (offline, DNS, CORS, …).
+ */
+export type FormSubmitFailureReason = "client_validation_failed" | "validation_failed" | "unauthorized" | "forbidden" | "plan_required" | "payment_required" | "service_suspended" | "rate_limited" | "not_found" | "invalid_request" | "server_error" | "network_error";
+/**
+ * Result of `forms.submit`. Always resolves (never throws for an expected
+ * failure) so the consumer can render success or the exact problem inline.
+ * Discriminate on `ok`.
+ */
+export type FormSubmitResult = {
+    ok: true;
+    /** HTTP status of the accepted submission (200). */
+    status: number;
+    /** Present on a real submit; null/absent on a `dryRun`. */
+    submissionId?: string | null;
+    slug?: string;
+    /** True when this was a `dryRun` — validated but not stored. */
+    dryRun?: boolean;
+    /** Any additional fields BIAB returned (forward-compat). */
+    [key: string]: unknown;
+} | {
+    ok: false;
+    /** HTTP status, or 0 when the request never reached BIAB. */
+    status: number;
+    reason: FormSubmitFailureReason;
+    /** Human-readable summary, safe to surface to the consumer. */
+    message: string;
+    /** Field-level detail when `reason` is a validation failure. */
+    issues?: FormValidationIssue[];
+};
+export interface FormsResource {
+    /**
+     * Fetch the form's field definitions. Cached via `biab:forms`
+     * + `biab:forms:<slug>` tags so admin edits invalidate via the
+     * webhook layer.
+     */
+    schema(slug: string): Promise<FormSchema>;
+    /**
+     * Submit a form. Validates against the schema client-side (via
+     * `validateFormSubmission`) before round-tripping, then posts to BIAB.
+     *
+     * Always resolves to a {@link FormSubmitResult} — it does NOT throw for an
+     * expected failure. Check `result.ok`; on failure, `result.reason` says what
+     * went wrong (bad API key, plan gate, schema mismatch, rate limit, network,
+     * …) and `result.issues` carries field-level detail for validation failures.
+     */
+    submit(slug: string, data: FormSubmissionData, opts?: {
+        submitterEmail?: string;
+        submitterName?: string;
+        /** Skip client-side validation. Use sparingly. */
+        skipValidate?: boolean;
+        /** Test mode: validate against the live schema on the server but store
+         *  nothing and skip all CRM/notification side effects. The result has
+         *  `dryRun: true` and no `submissionId`. Ideal for Postman/CI checks. */
+        dryRun?: boolean;
+        /** Provenance — how/where the form was filled (e.g. "facebook",
+         *  "google-ads:summer"), an optional referrer, and free-form metadata.
+         *  Drives lead-source reporting. Added in 0.9.7. */
+        source?: string;
+        referrer?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<FormSubmitResult>;
+    /**
+     * Upload a single file for a file-type field on the form.
+     *
+     *   1. Calls the BIAB upload-url endpoint to get a presigned PUT
+     *      URL + storageId (the server validates the form, field,
+     *      MIME type, and size cap against the org's plan).
+     *   2. PUTs the file bytes directly to R2 — BIAB never sees the
+     *      bytes, only the metadata.
+     *   3. Returns a `FormFileValue` to drop into the form's `data`
+     *      payload when calling `submit`.
+     *
+     * Throws on plan-gate (`forms.file_uploads` entitlement
+     * missing), field/file mismatch, or transfer failure.
+     */
+    uploadFile(slug: string, fieldId: string, file: File | Blob, opts?: {
+        filename?: string;
+    }): Promise<FormFileValue>;
+    /**
+     * Mint a Stripe intent for a `credit_card` field so `<BiabForm/>` can mount
+     * Stripe Elements. `card_on_file` → a SetupIntent; `deposit` → a PaymentIntent
+     * for the configured amount. The intent is created on the org's connected
+     * account; initialize Stripe with `{ stripeAccount: connectedAccountId }` and
+     * the returned `publishableKey`, then confirm with `clientSecret`. The card
+     * never touches BIAB — only the opaque intent id flows back in the submission.
+     */
+    paymentIntent(slug: string, fieldId: string): Promise<FormPaymentIntent>;
+    /**
+     * Open booking slots for an auto-mode `schedule` field — the form's assigned
+     * staff's combined real availability over [from, to]. `<BiabForm/>` renders
+     * the instant-booking picker from these; the visitor picks one and the
+     * meeting books on submit. Returns absolute UTC instants (`startAt`); host
+     * identities stay server-side. Empty when the org lacks the scheduling
+     * add-on or the field has no assignees.
+     */
+    scheduleSlots(slug: string, input: {
+        fieldId: string;
+        from: Date;
+        to: Date;
+    }): Promise<{
+        slots: Array<{
+            startAt: string;
+        }>;
+    }>;
+}
+/** Stripe intent details for mounting Elements on a `credit_card` field. */
+export interface FormPaymentIntent {
+    mode: "card_on_file" | "deposit";
+    clientSecret: string;
+    intentId: string;
+    publishableKey: string;
+    connectedAccountId: string;
+}
+export interface BiabClient {
+    gallery: GalleryResource;
+    scheduling: SchedulingResource;
+    forms: FormsResource;
+    blog: BiabDevBlogClient;
+    reviews: BiabDevReviewsClient;
+    storefront: BiabDevStorefrontClient;
+    cart: BiabDevCartClient;
+    checkout: BiabDevCheckoutClient;
+    coupons: BiabDevCouponsClient;
+    subscriptions: BiabDevSubscriptionsClient;
+    shipping: BiabDevShippingClient;
+    address: BiabDevAddressClient;
+    customerPortal: BiabDevCustomerPortalClient;
+    notifications: BiabDevNotificationsClient;
+    followers: BiabDevFollowersClient;
+    marketing: BiabDevMarketingClient;
+    marketingPages: BiabDevMarketingPagesClient;
+    parallelPages: BiabDevParallelPagesClient;
+}
+export declare function createBiabClient(opts: CreateBiabClientOptions): BiabClient;
+//# sourceMappingURL=sdk.d.ts.map