@businessdash/sdk 0.9.60

package/dist/sdk.js

@@ -0,0 +1,801 @@
+/**
+ * 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, BiabDevClient, BiabDevCouponsClient, BiabDevCustomerPortalClient, BiabDevFollowersClient, BiabDevMarketingClient, BiabDevMarketingPagesClient, BiabDevNotificationsClient, BiabDevParallelPagesClient, BiabDevReviewsClient, BiabDevShippingClient, BiabDevStorefrontClient, BiabDevSubscriptionsClient, } from "./client.js";
+import { getEmailDomain, isConsumerEmailDomain, } from "./forms-core/email-domains.js";
+// Apex host on purpose: www.biab.app 307-redirects to the apex and CORS
+// preflight doesn't follow redirects, which breaks browser publishable-token
+// clients. Server-side callers are unaffected, but one default keeps them aligned.
+const DEFAULT_BASE_URL = "https://biab.app/api/package/v1";
+const DEFAULT_REVALIDATE_SECONDS = 60 * 60 * 24; // 24h backstop
+function buildHeaders(state) {
+    const headers = {
+        Authorization: `Bearer ${state.apiKey}`,
+        Accept: "application/json",
+    };
+    if (state.siteOrigin)
+        headers["Origin"] = state.siteOrigin;
+    return headers;
+}
+function buildNextHint(tags, seconds) {
+    // `next` is a Next.js-only field on RequestInit. Non-Next runtimes
+    // (Cloudflare Workers, Deno, raw Node fetch) ignore it cleanly.
+    return { tags, revalidate: seconds };
+}
+async function jsonGet(state, pathWithQuery, tags) {
+    const url = `${state.baseUrl.replace(/\/$/, "")}/${pathWithQuery.replace(/^\//, "")}`;
+    const init = {
+        method: "GET",
+        headers: buildHeaders(state),
+        next: buildNextHint(tags, state.revalidateSeconds),
+    };
+    const res = await state.fetch(url, init);
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`BIAB SDK ${res.status} ${res.statusText} on ${pathWithQuery}: ${text.slice(0, 200)}`);
+    }
+    return (await res.json());
+}
+function createGalleryResource(state) {
+    return {
+        async list(params) {
+            const query = new URLSearchParams();
+            if (params?.limit)
+                query.set("limit", String(params.limit));
+            if (params?.fields && params.fields.length > 0) {
+                query.set("fields", params.fields.join(","));
+            }
+            const qs = query.toString();
+            const path = `sites/${encodeURIComponent(state.siteId)}/gallery${qs ? `?${qs}` : ""}`;
+            const tags = ["biab:gallery", `biab:site:${state.siteId}`];
+            // The server projects to exactly the requested `fields`, so the row
+            // shape is `GalleryItemFor<F>` — a fact only the wire can vouch for.
+            // Stating it as the fetch's type argument confines the assumption to
+            // this one boundary. The previous `as never` was strictly worse: it
+            // asserted the items were assignable to *anything*, so a genuine
+            // mismatch between projection and type would never have shown up.
+            const result = await jsonGet(state, path, tags);
+            return result.items ?? [];
+        },
+    };
+}
+function createSchedulingResource(state) {
+    const sitePath = `sites/${encodeURIComponent(state.siteId)}/scheduling`;
+    async function postJson(path, body, tags) {
+        const url = `${state.baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+        const init = {
+            method: "POST",
+            headers: { ...buildHeaders(state), "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+            next: { tags, revalidate: 0 },
+        };
+        const res = await state.fetch(url, init);
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`BIAB SDK ${res.status} ${res.statusText} on ${path}: ${text.slice(0, 200)}`);
+        }
+        return (await res.json());
+    }
+    return {
+        async listEventTypes() {
+            const tags = ["biab:scheduling", `biab:site:${state.siteId}`];
+            const result = await jsonGet(state, `${sitePath}/event-types`, tags);
+            return result.items ?? [];
+        },
+        async getEventType(slug) {
+            const tags = [
+                "biab:scheduling",
+                `biab:scheduling:event:${slug}`,
+                `biab:site:${state.siteId}`,
+            ];
+            return await jsonGet(state, `${sitePath}/event-types/${encodeURIComponent(slug)}`, tags);
+        },
+        async getAvailableSlots(slug, params) {
+            const query = new URLSearchParams({
+                from: params.from.toISOString(),
+                to: params.to.toISOString(),
+            });
+            const path = `${sitePath}/event-types/${encodeURIComponent(slug)}/slots?${query.toString()}`;
+            // Slots are dynamic — no caching, no tags. revalidate: 0 keeps
+            // Next from applying the default backstop.
+            const url = `${state.baseUrl.replace(/\/$/, "")}/${path}`;
+            const init = {
+                method: "GET",
+                headers: buildHeaders(state),
+                next: { revalidate: 0 },
+                cache: "no-store",
+            };
+            const res = await state.fetch(url, init);
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`BIAB SDK ${res.status} ${res.statusText} on ${path}: ${text.slice(0, 200)}`);
+            }
+            const data = (await res.json());
+            return data.slots ?? [];
+        },
+        async confirmBooking(input) {
+            return await postJson(`${sitePath}/bookings`, {
+                eventTypeSlug: input.eventTypeSlug,
+                startAt: input.startAt.toISOString(),
+                invitee: input.invitee,
+                answers: input.answers,
+                notes: input.notes ?? null,
+                schedulingLinkId: input.schedulingLinkId,
+                holderKey: input.holderKey ?? null,
+            }, []);
+        },
+        async getBookingByToken(token, type = "manage") {
+            const path = `${sitePath}/bookings/${encodeURIComponent(token)}?type=${type}`;
+            const url = `${state.baseUrl.replace(/\/$/, "")}/${path}`;
+            const res = await state.fetch(url, {
+                method: "GET",
+                headers: buildHeaders(state),
+                cache: "no-store",
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`BIAB SDK ${res.status} ${res.statusText}: ${text.slice(0, 200)}`);
+            }
+            return (await res.json());
+        },
+        async rescheduleBooking(input) {
+            return await postJson(`${sitePath}/bookings/${encodeURIComponent(input.token)}`, {
+                action: "reschedule",
+                newStartAt: input.newStartAt.toISOString(),
+                reason: input.reason ?? null,
+            }, []);
+        },
+        async cancelBooking(input) {
+            return await postJson(`${sitePath}/bookings/${encodeURIComponent(input.token)}`, {
+                action: "cancel",
+                reason: input.reason ?? null,
+            }, []);
+        },
+    };
+}
+/**
+ * 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 function isFormFileValue(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return (typeof v.storageId === "string" &&
+        typeof v.url === "string" &&
+        typeof v.name === "string" &&
+        typeof v.mimeType === "string" &&
+        typeof v.size === "number");
+}
+export function validateFormSubmission(schema, data) {
+    const issues = [];
+    // A submission may key values by the field's output `key` (preferred) or its
+    // legacy UUID `id`. Accept both everywhere.
+    const knownFieldIds = new Set();
+    for (const f of schema.fields) {
+        knownFieldIds.add(f.id);
+        if (f.key)
+            knownFieldIds.add(f.key);
+    }
+    for (const field of schema.fields) {
+        // `calculation` fields are computed server-side on submit — never user-validated.
+        if (field.type === "calculation")
+            continue;
+        const value = field.key != null && field.key in data ? data[field.key] : data[field.id];
+        const scheduleEmpty = field.type === "schedule" &&
+            (() => {
+                const s = (value ?? {});
+                return !((typeof s.slotStartAt === "string" && s.slotStartAt.length > 0) ||
+                    s.asap === true ||
+                    (Array.isArray(s.days) && s.days.length > 0) ||
+                    (Array.isArray(s.times) && s.times.length > 0));
+            })();
+        const urlEmpty = field.type === "url" &&
+            !(typeof value?.url === "string"
+                ? value.url
+                : "");
+        const isEmpty = value == null ||
+            value === "" ||
+            (Array.isArray(value) && value.length === 0) ||
+            scheduleEmpty ||
+            urlEmpty;
+        // Consent boolean: must be exactly `true` (independent of `required`).
+        // `false` is otherwise a valid answer for an optional/required toggle.
+        const consentUnmet = field.mustBeTrue === true && value !== true;
+        if ((field.required && isEmpty) || consentUnmet) {
+            issues.push({
+                fieldId: field.id,
+                label: field.label,
+                reason: "required",
+                message: consentUnmet
+                    ? `${field.label} must be checked.`
+                    : `${field.label} is required.`,
+            });
+            continue;
+        }
+        if (isEmpty)
+            continue;
+        switch (field.type) {
+            case "email": {
+                if (typeof value !== "string" ||
+                    !/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(value)) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a valid email.`,
+                    });
+                    break;
+                }
+                if (field.emailConfig
+                    ?.businessOnly &&
+                    isConsumerEmailDomain(getEmailDomain(value) ?? "")) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a business email address.`,
+                    });
+                }
+                break;
+            }
+            case "url": {
+                // Value object: { url, verified }. Validate the `url` member.
+                const u = value?.url;
+                if (typeof u !== "string" ||
+                    !/^(https?:\/\/)?([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}(?::\d{1,5})?(?:[/?#]\S*)?$/i.test(u.trim())) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a valid URL.`,
+                    });
+                }
+                break;
+            }
+            case "phone": {
+                // Digit-count pre-check mirroring the server: international fields
+                // allow E.164 (7-15), otherwise a 10-digit US number (optionally
+                // with a leading "1"). The server is the authoritative check.
+                const digits = typeof value === "string" ? value.replace(/\D/g, "") : "";
+                const intl = field.phoneConfig?.international === true;
+                const national = digits.length === 11 && digits.startsWith("1")
+                    ? digits.slice(1)
+                    : digits;
+                const ok = intl
+                    ? digits.length >= 7 && digits.length <= 15
+                    : national.length === 10;
+                if (!ok) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a valid phone number.`,
+                    });
+                }
+                break;
+            }
+            case "number":
+            case "slider":
+                if (typeof value !== "number") {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a number.`,
+                    });
+                    break;
+                }
+                if (field.type === "number" &&
+                    field.allowNegative === false &&
+                    value < 0) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "min",
+                        message: `${field.label} must be 0 or greater.`,
+                    });
+                }
+                if (field.validation?.min != null && value < field.validation.min) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "min",
+                        message: `${field.label} must be at least ${field.validation.min}.`,
+                    });
+                }
+                if (field.validation?.max != null && value > field.validation.max) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "max",
+                        message: `${field.label} must be at most ${field.validation.max}.`,
+                    });
+                }
+                break;
+            case "select":
+            case "radio":
+                if (field.options &&
+                    !field.allowCustom &&
+                    !field.options.includes(String(value))) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "options",
+                        message: `${field.label} must be one of: ${field.options.join(", ")}.`,
+                    });
+                }
+                break;
+            case "checkbox":
+                if (typeof value !== "boolean" && !Array.isArray(value)) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be a boolean or list.`,
+                    });
+                }
+                break;
+            case "choice_cards": {
+                const ccLabels = (field.choiceConfig?.options ?? []).map((o) => o.label);
+                const ccMulti = field.choiceConfig?.mode === "multi";
+                const ccVals = ccMulti
+                    ? Array.isArray(value)
+                        ? value
+                        : null
+                    : typeof value === "string"
+                        ? [value]
+                        : null;
+                if (ccVals === null) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: ccMulti
+                            ? `${field.label} must be a list.`
+                            : `${field.label} must be a string.`,
+                    });
+                    break;
+                }
+                if (ccLabels.length) {
+                    for (const v of ccVals) {
+                        if (typeof v !== "string" || !ccLabels.includes(v)) {
+                            issues.push({
+                                fieldId: field.id,
+                                label: field.label,
+                                reason: "options",
+                                message: `${field.label} must be one of: ${ccLabels.join(", ")}.`,
+                            });
+                            break;
+                        }
+                    }
+                }
+                break;
+            }
+            case "file_upload":
+            case "file": {
+                const items = Array.isArray(value) ? value : [value];
+                let badShape = false;
+                for (const item of items) {
+                    if (!isFormFileValue(item)) {
+                        badShape = true;
+                        break;
+                    }
+                    if (field.fileConfig?.maxSize != null &&
+                        // `fileConfig.maxSize` is MB (builder slider unit); `item.size`
+                        // is bytes — convert before comparing.
+                        item.size > field.fileConfig.maxSize * 1024 * 1024) {
+                        issues.push({
+                            fieldId: field.id,
+                            label: field.label,
+                            reason: "max",
+                            message: `${field.label} exceeds the ${field.fileConfig.maxSize} MB limit.`,
+                        });
+                    }
+                }
+                if (badShape) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} must be uploaded via biab.forms.uploadFile().`,
+                    });
+                }
+                if (field.fileConfig?.maxFiles != null &&
+                    Array.isArray(value) &&
+                    value.length > field.fileConfig.maxFiles) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "max",
+                        message: `${field.label} accepts at most ${field.fileConfig.maxFiles} files.`,
+                    });
+                }
+                break;
+            }
+            case "schedule": {
+                // { asap?, days?: string[], times?: string[], notes? } — structural
+                // parity with the server (which also enforces length caps). Client
+                // pre-check only; the server gate is authoritative.
+                if (typeof value !== "object" ||
+                    value === null ||
+                    Array.isArray(value)) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} has an unexpected value.`,
+                    });
+                    break;
+                }
+                const s = value;
+                const badType = (s.asap !== undefined && typeof s.asap !== "boolean") ||
+                    (s.notes !== undefined && typeof s.notes !== "string") ||
+                    ["days", "times"].some((k) => s[k] !== undefined &&
+                        (!Array.isArray(s[k]) ||
+                            s[k].some((x) => typeof x !== "string")));
+                if (badType) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "type",
+                        message: `${field.label} has an unexpected value.`,
+                    });
+                }
+                break;
+            }
+            default:
+                if (field.regexPattern &&
+                    typeof value === "string" &&
+                    !new RegExp(field.regexPattern).test(value)) {
+                    issues.push({
+                        fieldId: field.id,
+                        label: field.label,
+                        reason: "regex",
+                        message: `${field.label} format is invalid.`,
+                    });
+                }
+        }
+    }
+    for (const key of Object.keys(data)) {
+        if (!knownFieldIds.has(key)) {
+            issues.push({
+                fieldId: key,
+                label: key,
+                reason: "unknown_field",
+                message: `Unknown field "${key}" — not in the form schema.`,
+            });
+        }
+    }
+    return { ok: issues.length === 0, issues };
+}
+/** Normalize the server's `issues` array into typed `FormValidationIssue`s. */
+function mapSubmitIssues(body) {
+    const raw = body?.["issues"];
+    if (!Array.isArray(raw))
+        return undefined;
+    return raw.map((it) => {
+        const o = (it ?? {});
+        const id = typeof o["id"] === "string"
+            ? o["id"]
+            : typeof o["fieldId"] === "string"
+                ? o["fieldId"]
+                : "";
+        const label = typeof o["label"] === "string" ? o["label"] : id || "field";
+        const reason = typeof o["reason"] === "string" ? o["reason"] : "type";
+        return {
+            fieldId: id,
+            label,
+            reason,
+            message: typeof o["message"] === "string" ? o["message"] : `${label}: ${reason}`,
+        };
+    });
+}
+/** Map a non-2xx submit response (status + parsed body) to a failure result. */
+function mapSubmitResponse(status, body) {
+    const message = (typeof body?.["message"] === "string" && body["message"]) ||
+        `Submission failed (${status}).`;
+    const code = typeof body?.["error"] === "string" ? body["error"] : undefined;
+    const gateReason = typeof body?.["reason"] === "string" ? body["reason"] : undefined;
+    const issues = mapSubmitIssues(body);
+    let reason;
+    if (status === 401)
+        reason = "unauthorized";
+    else if (status === 403)
+        reason = "forbidden";
+    else if (status === 402)
+        reason =
+            gateReason === "payment_required"
+                ? "payment_required"
+                : gateReason === "service_suspended"
+                    ? "service_suspended"
+                    : "plan_required";
+    else if (status === 429)
+        reason = "rate_limited";
+    else if (status === 404)
+        reason = "not_found";
+    else if (status === 400 || status === 422)
+        reason =
+            code === "validation_failed" || issues
+                ? "validation_failed"
+                : "invalid_request";
+    else
+        reason = "server_error";
+    return {
+        ok: false,
+        status,
+        reason,
+        message,
+        ...(issues ? { issues } : {}),
+    };
+}
+/** Map a thrown error during the pre-submit schema fetch to a failure result. */
+function mapSubmitThrow(err) {
+    if (err instanceof Error) {
+        // `jsonGet` embeds the HTTP status in its message — recover it if present.
+        const m = err.message.match(/BIAB SDK (\d{3})/);
+        if (m)
+            return mapSubmitResponse(Number(m[1]), null);
+        return {
+            ok: false,
+            status: 0,
+            reason: "network_error",
+            message: `Could not load the form schema: ${err.message}`,
+        };
+    }
+    return {
+        ok: false,
+        status: 0,
+        reason: "network_error",
+        message: "Could not load the form schema.",
+    };
+}
+function createFormsResource(state) {
+    return {
+        async schema(slug) {
+            // Non-chatbot form read: a form is reachable here when it is **Live**
+            // (`isActive`) — independent of `chatbotAccess`. Embedding a form on
+            // your own page no longer requires opting it into the AI chatbot.
+            const tags = [
+                "biab:forms",
+                `biab:forms:${slug}`,
+                `biab:site:${state.siteId}`,
+            ];
+            const path = `forms/${encodeURIComponent(slug)}`;
+            const result = await jsonGet(state, path, tags);
+            return result;
+        },
+        async submit(slug, data, opts) {
+            // 1. Client-side schema check (unless skipped) — return, don't throw,
+            //    so the consumer handles it the same way as a server rejection.
+            if (!opts?.skipValidate) {
+                let schema;
+                try {
+                    schema = await this.schema(slug);
+                }
+                catch (err) {
+                    return mapSubmitThrow(err);
+                }
+                const v = validateFormSubmission(schema, data);
+                if (!v.ok) {
+                    return {
+                        ok: false,
+                        status: 0,
+                        reason: "client_validation_failed",
+                        message: `Form validation failed — ${v.issues
+                            .map((i) => `${i.label}: ${i.message}`)
+                            .join("; ")}`,
+                        issues: v.issues,
+                    };
+                }
+            }
+            // 2. Round-trip. Map every transport / HTTP outcome to a result.
+            //    Live (non-chatbot) submit path — gated on `isActive` only.
+            const url = `${state.baseUrl.replace(/\/$/, "")}/forms/${encodeURIComponent(slug)}`;
+            const init = {
+                method: "POST",
+                headers: {
+                    ...buildHeaders(state),
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    data,
+                    submitterEmail: opts?.submitterEmail,
+                    submitterName: opts?.submitterName,
+                    ...(opts?.dryRun ? { dryRun: true } : {}),
+                    ...(opts?.source ? { source: opts.source } : {}),
+                    ...(opts?.referrer ? { referrer: opts.referrer } : {}),
+                    ...(opts?.metadata ? { metadata: opts.metadata } : {}),
+                }),
+                next: { revalidate: 0 },
+            };
+            let res;
+            try {
+                res = await state.fetch(url, init);
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    status: 0,
+                    reason: "network_error",
+                    message: err instanceof Error
+                        ? `Could not reach BIAB: ${err.message}`
+                        : "Could not reach BIAB.",
+                };
+            }
+            const body = (await res.json().catch(() => null));
+            if (res.ok) {
+                return {
+                    ok: true,
+                    status: res.status,
+                    ...(body ?? {}),
+                };
+            }
+            return mapSubmitResponse(res.status, body);
+        },
+        async uploadFile(slug, fieldId, file, opts) {
+            const filename = opts?.filename ?? (file instanceof File ? file.name : "upload.bin");
+            const contentType = file.type || "application/octet-stream";
+            const sizeBytes = file.size;
+            // Step 1 — presign. The server validates entitlement
+            // (`forms.file_uploads`), Live form access, field type, MIME
+            // allow-list, and the per-plan / per-field max-size cap.
+            const presignUrl = `${state.baseUrl.replace(/\/$/, "")}/forms/${encodeURIComponent(slug)}/upload-url`;
+            const presignRes = await state.fetch(presignUrl, {
+                method: "POST",
+                headers: {
+                    ...buildHeaders(state),
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    fieldId,
+                    filename,
+                    contentType,
+                    sizeBytes,
+                }),
+            });
+            if (!presignRes.ok) {
+                const text = await presignRes.text().catch(() => "");
+                if (presignRes.status === 403 || presignRes.status === 402) {
+                    throw new Error(`BIAB SDK: file upload requires the "forms.file_uploads" entitlement on this org. ${text.slice(0, 200)}`);
+                }
+                throw new Error(`BIAB SDK ${presignRes.status} ${presignRes.statusText} on upload-url: ${text.slice(0, 200)}`);
+            }
+            const presign = (await presignRes.json());
+            // Step 2 — PUT bytes directly to R2 (signed URL).
+            const putRes = await state.fetch(presign.uploadUrl, {
+                method: "PUT",
+                headers: { "Content-Type": contentType },
+                body: file,
+            });
+            if (!putRes.ok) {
+                const text = await putRes.text().catch(() => "");
+                throw new Error(`BIAB SDK upload to R2 failed: ${putRes.status} ${putRes.statusText}: ${text.slice(0, 200)}`);
+            }
+            // Step 3 — return the value to drop into form data.
+            return {
+                storageId: presign.storageId,
+                url: presign.publicUrl,
+                name: filename,
+                mimeType: contentType,
+                size: sizeBytes,
+            };
+        },
+        async paymentIntent(slug, fieldId) {
+            const url = `${state.baseUrl.replace(/\/$/, "")}/forms/${encodeURIComponent(slug)}/payment-intent`;
+            const res = await state.fetch(url, {
+                method: "POST",
+                headers: {
+                    ...buildHeaders(state),
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ fieldId }),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`BIAB SDK ${res.status} ${res.statusText} on payment-intent: ${text.slice(0, 200)}`);
+            }
+            return (await res.json());
+        },
+        async scheduleSlots(slug, input) {
+            const base = state.baseUrl.replace(/\/$/, "");
+            const qs = new URLSearchParams({
+                fieldId: input.fieldId,
+                from: input.from.toISOString(),
+                to: input.to.toISOString(),
+            });
+            const url = `${base}/forms/${encodeURIComponent(slug)}/schedule-slots?${qs.toString()}`;
+            const res = await state.fetch(url, {
+                method: "GET",
+                headers: buildHeaders(state),
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`BIAB SDK ${res.status} ${res.statusText} on schedule-slots: ${text.slice(0, 200)}`);
+            }
+            return (await res.json());
+        },
+    };
+}
+export function createBiabClient(opts) {
+    if (!opts.apiKey) {
+        throw new Error("createBiabClient: apiKey is required.");
+    }
+    if (!opts.siteId) {
+        throw new Error("createBiabClient: siteId is required.");
+    }
+    const state = {
+        apiKey: opts.apiKey,
+        siteId: opts.siteId,
+        baseUrl: opts.baseUrl ?? DEFAULT_BASE_URL,
+        revalidateSeconds: opts.revalidateSeconds ?? DEFAULT_REVALIDATE_SECONDS,
+        fetch: opts.fetch ?? globalThis.fetch.bind(globalThis),
+        siteOrigin: opts.siteOrigin,
+    };
+    const transport = new BiabDevClient({
+        baseUrl: state.baseUrl,
+        apiKey: state.apiKey,
+        ...(opts.fetch ? { fetch: opts.fetch } : {}),
+        ...(opts.siteOrigin ? { siteOrigin: opts.siteOrigin } : {}),
+    });
+    return {
+        gallery: createGalleryResource(state),
+        scheduling: createSchedulingResource(state),
+        forms: createFormsResource(state),
+        blog: new BiabDevBlogClient(transport),
+        reviews: new BiabDevReviewsClient(transport),
+        storefront: new BiabDevStorefrontClient(transport),
+        cart: new BiabDevCartClient(transport, state.siteId),
+        checkout: new BiabDevCheckoutClient(transport, state.siteId),
+        coupons: new BiabDevCouponsClient(transport),
+        subscriptions: new BiabDevSubscriptionsClient(transport),
+        shipping: new BiabDevShippingClient(transport, state.siteId),
+        address: new BiabDevAddressClient(transport),
+        // CustomerPortal needs an org id binding; when the consumer's API
+        // key already binds an org, pass `null` here (server resolves via
+        // the key). For multi-tenant proxies, override after construction.
+        customerPortal: new BiabDevCustomerPortalClient(transport, null),
+        notifications: new BiabDevNotificationsClient(transport, state.siteId),
+        followers: new BiabDevFollowersClient(transport, state.siteId),
+        marketing: new BiabDevMarketingClient(transport, state.siteId),
+        marketingPages: new BiabDevMarketingPagesClient(transport, state.siteId),
+        parallelPages: new BiabDevParallelPagesClient(transport, state.siteId),
+    };
+}
+//# sourceMappingURL=sdk.js.map