@businessdash/sdk 0.9.60

package/dist/client.d.ts

@@ -0,0 +1,1681 @@
+import { z } from "zod";
+import { type AddressDetailsResponse, type AddressFormValues, type AddressSearchInput, type AddressSearchResponse, type AddressVerifyResponse, type AiVisibilityInput, type AiVisibilityResponse, type AttributionHeartbeatInput, type AttributionHeartbeatResponse, type AttributionPolicy, type AuthIntrospectResponse, type BlogCategoryListResponse, type BlogCommentListResponse, type BlogCommentPostInput, type BlogCommentPostResponse, type BlogLikeResponse, type BlogListPostsResponse, type BlogPostBySlugResponse, type BlogSessionInput, type BlogSessionResponse, type BlogTagListResponse, type CartAddItemInput, type CartCouponInput, type CartSessionResponse, type CartSnapshot, type CartUpdateItemInput, type ChatbotAppendMessageInput, type ChatbotAvailability, type ChatbotChatInput, type ChatbotChatResponse, type ChatbotConfig, type ChatbotConfigUpdateInput, type ChatbotFormDefinition, type ChatbotFormSubmitInput, type ChatbotFormSubmitResponse, type ChatbotMessagesResponse, type ChatbotPersistedSessionInput, type ChatbotPersistedSessionResponse, type ChatbotRequestHumanInput, type ChatbotRequestHumanResponse, type ChatbotSessionResponse, type CheckoutSessionInput, type CheckoutSessionResponse, type CheckoutStartInput, type CheckoutStartResponse, type CheckoutStatusResponse, type ConfirmVerificationInput, type ConfirmVerificationResponse, type CouponValidateResponse, type CreateCollectionInput, type CreateCollectionResponse, type CreateEmailTemplateInput, type CreateEmailTemplateResponse, type CreateEmailTemplateVersionInput, type CreateEmailTemplateVersionResponse, type CustomerContactCompanyInput, type CustomerContactCompanyResponse, type CustomerContractDetail, type CustomerContractSignResponse, type CustomerDownloadsResponse, type CustomerInvoiceDetail, type CustomerInvoicePayInput, type CustomerInvoicePayResponse, type CustomerInvoicePdf, type CustomerJobActivityResponse, type CustomerJobComment, type CustomerJobCommentPostInput, type CustomerJobCommentsListResponse, type CustomerJobDetail, type CustomerJobEtaResponse, type CustomerNotificationPreferencesResponse, type CustomerNotificationPreferencesUpdateInput, type CustomerNotificationPreferencesUpdateResponse, type CustomerOrderDetail, type CustomerOrderListResponse, type CustomerPortalContextResponse, type CustomerPortalOtherOrgsResponse, type CustomerPortalProfile, type CustomerPortalUpdateProfileInput, type CustomerPortalUpdateProfileResponse, type CustomerQuoteActionResponse, type CustomerQuoteDetail, type CustomerReferralHistoryResponse, type CustomerReferralPayoutsResponse, type CustomerReferralStats, type CustomerReturnRequestCreated, type CustomerReturnRequestInput, type CustomerReviewListResponse, type CustomerReviewSubmitInput, type CustomerReviewSubmitResponse, type CustomerShipmentTracking, type CustomerWorkBundle, type DashboardSessionResponse, type ExecuteActionInput, type ExecuteActionResponse, type FollowerEditInput, type FollowerEditResponse, type FollowerJoinInput, type FollowerJoinResponse, type FollowerLeaveInput, type FollowerLeaveResponse, type FollowerMeInput, type FollowerMeResponse, type GetCollectionResponse, type GetEmailTemplateResponse, type GetMarketingLocalesResponse, type GetMarketingPageBundleResponse, type GetPublishedMarketingSchemaResponse, type GetSiteMarketingPageResponse, type GoogleAddress, type JobCategoryListResponse, type JobPosting, type JobPostingListResponse, type ListCollectionsResponse, type ListDataModelRecordsInput, type ListDataModelRecordsResponse, type ListEmailTemplatesInput, type ListEmailTemplatesResponse, type ListRowsInput, type ListRowsResponse, type ListSiteMarketingPagesResponse, type NotificationPreferencesResponse, type NotificationPreferencesUpdateInput, type PageViewsInput, type PageViewsResponse, type PublishMarketingSectionsInput, type PublishMarketingSectionsResponse, type QueryRowsInput, type QueryRowsResponse, type ReviewWallListResponse, type ShippingRatesInput, type ShippingRatesResponse, type ShippingSettingsResponse, type ShippingTrackResponse, type SiteAssetInput, type SiteBranding, type StartVerificationInput, type StartVerificationResponse, type StorefrontAddonsResponse, type StorefrontCategoriesResponse, type StorefrontListProductsResponse, type StorefrontProductDetail, type StorefrontProductReviewsResponse, type StorefrontProductsWithMetaResponse, type StorefrontRelatedProductsResponse, type StorefrontSessionInput, type StorefrontSessionResponse, type StorefrontSort, type SubscriptionCheckoutInput, type SubscriptionCheckoutResponse, type SubscriptionOffering, type SubscriptionOfferingsListResponse, type TenantAuthExchangeInput, type TenantAuthExchangeResponse, type TenantAuthMeResponse, type TenantAuthPasswordResetInput, type TenantAuthPasswordResetResponse, type TenantAuthSignOutResponse, type TenantAuthStartInput, type TenantAuthStartResponse, type UploadSiteAssetResponse, type UpsertDraftMarketingSchemaInput, type UpsertDraftMarketingSchemaResponse, type UpsertRowInput, type UpsertRowResponse } from "./contracts.js";
+export type FetchLike = typeof fetch;
+/** Options for {@link BiabDevClient} / {@link createBiabDevClient}. */
+export type BiabDevClientOptions = {
+    baseUrl: string;
+    apiKey: string;
+    fetch?: FetchLike;
+    defaultHeaders?: HeadersInit;
+    /**
+     * Origin to send to the platform on every request. Required when the API
+     * key has an Allowed Host set on the host (server-to-server `fetch` does
+     * not send `Origin` automatically — without it the platform replies 403
+     * `origin_required`). Accepts a full URL (`https://my-site.com`) or a
+     * bare hostname (`my-site.com`); only the origin is sent on the wire.
+     */
+    siteOrigin?: string;
+};
+/** An array value becomes a repeated param: `?path=/a&path=/b`. */
+type QueryValue = string | number | boolean | Array<string | number> | undefined;
+type RequestOptions<T> = {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query?: Record<string, QueryValue>;
+    body?: unknown;
+    responseSchema: z.ZodType<T, z.ZodTypeDef, unknown>;
+    headers?: HeadersInit;
+};
+/**
+ * Typed client for the BIAB package HTTP API.
+ *
+ * @remarks
+ * **Alpha:** This SDK is in alpha. Surfaces and behavior may change without semver guarantees.
+ * Do not rely on it for production workloads—use development, staging, or experiments only.
+ */
+export declare class BiabDevClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private readonly defaultHeaders;
+    constructor(options: BiabDevClientOptions);
+    private readonly siteOrigin;
+    site(siteId: string): BiabDevSiteClient;
+    get emailTemplates(): BiabDevEmailTemplatesClient;
+    get dashboard(): BiabDevDashboardClient;
+    get storefront(): BiabDevStorefrontClient;
+    get cart(): BiabDevCartClient;
+    get checkout(): BiabDevCheckoutClient;
+    get coupons(): BiabDevCouponsClient;
+    get subscriptions(): BiabDevSubscriptionsClient;
+    get shipping(): BiabDevShippingClient;
+    get notifications(): BiabDevNotificationsClient;
+    get address(): BiabDevAddressClient;
+    get blog(): BiabDevBlogClient;
+    get reviews(): BiabDevReviewsClient;
+    /** Public job postings — build a careers page on your own domain. */
+    get hiring(): BiabDevHiringClient;
+    get chatbot(): BiabDevChatbotClient;
+    get auth(): BiabDevAuthClient;
+    /**
+     * Customer-portal client. Pin to a specific BIAB organization id so the
+     * caller never sees data from any other org (recommended). Omit
+     * `organizationId` to fall back to the user's currently-active session
+     * org — only use that on first-party hosts where the host already pins
+     * the org.
+     */
+    customerPortal(organizationId?: string): BiabDevCustomerPortalClient;
+    introspect(): Promise<AuthIntrospectResponse>;
+    request<T>(options: RequestOptions<T>): Promise<T>;
+}
+export declare class BiabDevSiteClient {
+    readonly client: BiabDevClient;
+    readonly siteId: string;
+    readonly collections: BiabDevCollectionsClient;
+    readonly rows: BiabDevRowsClient;
+    /**
+     * The org's custom database — the tables from `defineDataModel()`.
+     * Distinct from `collections`/`rows`, which are Site Data. See
+     * {@link BiabDevDataModelClient}.
+     */
+    readonly dataModel: BiabDevDataModelClient;
+    /**
+     * Read your site's visitor counts back (the counterpart to the
+     * `<BIABAnalytics/>` tracker, which only records). See
+     * {@link BiabDevAnalyticsClient}.
+     */
+    readonly analytics: BiabDevAnalyticsClient;
+    /**
+     * The "Powered by BusinessDash" badge's policy + heartbeat. See
+     * {@link BiabDevAttributionClient}.
+     */
+    readonly attribution: BiabDevAttributionClient;
+    readonly assets: BiabDevAssetsClient;
+    readonly actions: BiabDevActionsClient;
+    readonly followers: BiabDevFollowersClient;
+    readonly marketingPages: BiabDevMarketingPagesClient;
+    /**
+     * Schema-driven marketing flow (Phase 2). Pair with the SDK's
+     * `defineSiteMarketingSchema()` builder + the `biab-dev sync-schema`
+     * CLI for the authoring side; this client is the live-site read
+     * path (`getPageBundle`) and the upload entry point for the CLI.
+     */
+    readonly marketing: BiabDevMarketingClient;
+    readonly parallelPages: BiabDevParallelPagesClient;
+    constructor(client: BiabDevClient, siteId: string);
+    /**
+     * The org's storefront branding — logo + favicon (site static media) plus
+     * the org name + icon. Render the masthead/favicon/og without the org
+     * re-supplying assets. Available even when billing has lapsed.
+     *
+     * @example
+     * ```ts
+     * const b = await client.site(SITE_ID).branding();
+     * <img src={b.logoUrl ?? b.orgIcon ?? ""} alt={b.orgName ?? ""} />
+     * ```
+     */
+    branding(): Promise<SiteBranding>;
+}
+export declare const parallelPagesListResponseSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+        routePattern: z.ZodString;
+        variables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            source: z.ZodObject<{
+                section: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                section: string;
+                path?: string | undefined;
+            }, {
+                section: string;
+                path?: string | undefined;
+            }>;
+            slugField: z.ZodString;
+            tokenFields: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }, {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }>, "many">;
+        meta: z.ZodObject<{
+            title: z.ZodString;
+            description: z.ZodString;
+            canonical: z.ZodOptional<z.ZodString>;
+            ogImage: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        }, {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        }>;
+        templateRef: z.ZodString;
+        source: z.ZodEnum<["sdk", "site_builder"]>;
+        crawlRule: z.ZodEnum<["inherit", "index", "noindex"]>;
+        isActive: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        source: "sdk" | "site_builder";
+        isActive: boolean;
+        key: string;
+        variables: {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }[];
+        routePattern: string;
+        meta: {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        };
+        templateRef: string;
+        crawlRule: "inherit" | "index" | "noindex";
+    }, {
+        id: string;
+        source: "sdk" | "site_builder";
+        isActive: boolean;
+        key: string;
+        variables: {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }[];
+        routePattern: string;
+        meta: {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        };
+        templateRef: string;
+        crawlRule: "inherit" | "index" | "noindex";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        id: string;
+        source: "sdk" | "site_builder";
+        isActive: boolean;
+        key: string;
+        variables: {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }[];
+        routePattern: string;
+        meta: {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        };
+        templateRef: string;
+        crawlRule: "inherit" | "index" | "noindex";
+    }[];
+}, {
+    items: {
+        id: string;
+        source: "sdk" | "site_builder";
+        isActive: boolean;
+        key: string;
+        variables: {
+            name: string;
+            source: {
+                section: string;
+                path?: string | undefined;
+            };
+            slugField: string;
+            tokenFields: string[];
+        }[];
+        routePattern: string;
+        meta: {
+            description: string;
+            title: string;
+            canonical?: string | undefined;
+            ogImage?: string | undefined;
+        };
+        templateRef: string;
+        crawlRule: "inherit" | "index" | "noindex";
+    }[];
+}>;
+export declare const parallelPagesVariantsResponseSchema: z.ZodObject<{
+    variants: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodString>, "many">;
+}, "strip", z.ZodTypeAny, {
+    variants: Record<string, string>[];
+}, {
+    variants: Record<string, string>[];
+}>;
+export declare const parallelPagesRenderResponseSchema: z.ZodObject<{
+    key: z.ZodString;
+    routePattern: z.ZodString;
+    slugs: z.ZodRecord<z.ZodString, z.ZodString>;
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        canonical: z.ZodNullable<z.ZodString>;
+        ogImage: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        title: string;
+        canonical: string | null;
+        ogImage: string | null;
+    }, {
+        description: string;
+        title: string;
+        canonical: string | null;
+        ogImage: string | null;
+    }>;
+    body: z.ZodNullable<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    routePattern: string;
+    meta: {
+        description: string;
+        title: string;
+        canonical: string | null;
+        ogImage: string | null;
+    };
+    slugs: Record<string, string>;
+    body?: unknown;
+}, {
+    key: string;
+    routePattern: string;
+    meta: {
+        description: string;
+        title: string;
+        canonical: string | null;
+        ogImage: string | null;
+    };
+    slugs: Record<string, string>;
+    body?: unknown;
+}>;
+export type ParallelPagesListResponse = z.infer<typeof parallelPagesListResponseSchema>;
+export type ParallelPagesVariantsResponse = z.infer<typeof parallelPagesVariantsResponseSchema>;
+export type ParallelPagesRenderResponse = z.infer<typeof parallelPagesRenderResponseSchema>;
+/**
+ * Programmatic SEO ("parallel pages") client. Same shape across
+ * SDK-defined and site-builder-defined pages — both share the
+ * `org_parallel_pages` table on the server.
+ *
+ * Typical wiring in Next.js:
+ *
+ *   export async function generateStaticParams() {
+ *     const { variants } = await client
+ *       .site(SITE_ID)
+ *       .parallelPages
+ *       .listVariants("repair-area");
+ *     return variants;
+ *   }
+ *
+ *   export default async function Page({ params }) {
+ *     const bundle = await client
+ *       .site(SITE_ID)
+ *       .parallelPages
+ *       .render("repair-area", await params);
+ *     return <RenderTemplate bundle={bundle} />;
+ *   }
+ */
+export declare class BiabDevParallelPagesClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    list(): Promise<ParallelPagesListResponse>;
+    listVariants(key: string, opts?: {
+        locale?: string;
+    }): Promise<ParallelPagesVariantsResponse>;
+    render(key: string, slugs: Record<string, string>, opts?: {
+        locale?: string;
+    }): Promise<ParallelPagesRenderResponse>;
+    /**
+     * URL of the auto-generated sitemap. Consumer's `/sitemap.xml` route
+     * proxies straight through. Returns null when the client isn't
+     * configured with a base URL.
+     */
+    sitemapUrl(): string;
+    /**
+     * URL of the auto-generated robots.txt. Consumer's `/robots.txt` route
+     * proxies straight through.
+     */
+    robotsUrl(): string;
+}
+/**
+ * Manually invalidate marketing caches scoped to a site. Useful after a
+ * server-side mutation the SDK didn't initiate (e.g. an operator saved a
+ * section in the dashboard while the consumer's Next process is still
+ * warm).
+ */
+export declare function clearMarketingCache(siteId: string): void;
+/**
+ * Live-site read client for the schema-driven marketing flow.
+ *
+ * Surfaces:
+ *   - `getPageBundle({ pageKey, locale })` — every section for a page,
+ *     tagged ok|error per section, plus SEO + availableLocales.
+ *   - `getPublishedSchema()` — the live schema (returns `{ schema: null }`
+ *     until the consumer's CLI has published one).
+ *   - `getDraftSchema()` — what's currently staged (CLI-only path).
+ *   - `publishDraftSchema(input)` — CLI upload. Idempotent (same
+ *     checksum = `noop: true`).
+ *   - `getLocales()` — enabled locales + brand-token map.
+ */
+export declare class BiabDevMarketingClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    getPageBundle(input?: {
+        pageKey?: string;
+        locale?: string;
+        reviewsLimit?: number;
+    }, options?: {
+        skipCache?: boolean;
+    }): Promise<GetMarketingPageBundleResponse>;
+    getPageBundleCached(input?: {
+        pageKey?: string;
+        locale?: string;
+    }): GetMarketingPageBundleResponse | null;
+    prefetchPageBundle(input?: {
+        pageKey?: string;
+        locale?: string;
+    }): Promise<GetMarketingPageBundleResponse>;
+    getPublishedSchema(options?: {
+        skipCache?: boolean;
+    }): Promise<GetPublishedMarketingSchemaResponse>;
+    getDraftSchema(): Promise<GetPublishedMarketingSchemaResponse>;
+    publishDraftSchema(input: UpsertDraftMarketingSchemaInput): Promise<UpsertDraftMarketingSchemaResponse>;
+    /**
+     * Bulk-upsert section values. Used by `biab-dev sync-content` to push
+     * local JSON content to BIAB. Server caps each request at 256 items;
+     * larger imports are batched by the CLI. Per-item failures are
+     * reported in the response (`results[].ok === false`) without aborting
+     * the rest of the batch.
+     *
+     * The CLI's `--lax` flag sets `validate: false` for first-time imports
+     * of legacy content that doesn't yet match the published schema —
+     * useful so writers can pull existing content into BIAB and fix
+     * validation errors in the dashboard incrementally.
+     */
+    publishSections(input: PublishMarketingSectionsInput): Promise<PublishMarketingSectionsResponse>;
+    getLocales(options?: {
+        skipCache?: boolean;
+    }): Promise<GetMarketingLocalesResponse>;
+}
+/**
+ * Manually clear the SDK's cache for `(siteId, pageKey)` (or the whole
+ * site when `pageKey` is omitted). Useful after a server-side mutation
+ * that the SDK didn't initiate, or in tests.
+ */
+export declare function clearMarketingPageCache(siteId: string, pageKey?: string): void;
+/**
+ * Read-only access to the host's `org_site_marketing_pages` table — the JSON
+ * documents the Site Builder writes for marketing landing pages (e.g. the
+ * `home` page rendered by `custom-demo`).
+ *
+ * Requires the `collections:read` scope on the API key (the same scope used
+ * for collection reads, so existing keys created from the host's Site Builder
+ * → Developer panel work without re-issuing).
+ *
+ * The client transparently caches per-page responses across instances; pair
+ * `list()` (no payloads) with `get(pageKey)` / `prefetch(pageKey)` to load
+ * pages on demand instead of paying the full-content cost up front.
+ */
+export declare class BiabDevMarketingPagesClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    /**
+     * Payload-free directory of every marketing page for the site. Use this
+     * to render a navigation index without loading any content; call
+     * {@link get} or {@link prefetch} when the visitor selects a page.
+     */
+    list(): Promise<ListSiteMarketingPagesResponse>;
+    /**
+     * Fetches a single marketing page payload by `pageKey` (defaults to `"home"`).
+     * Returns `{ page: null }` when the host has not published one yet — callers
+     * typically render a static fallback in that case.
+     *
+     * Reads from the shared cache when present (warmed by {@link prefetch} or
+     * a previous `get`). Pass `{ skipCache: true }` to force a network round-trip
+     * (e.g. after a save the SDK didn't make itself).
+     */
+    get(pageKey?: string, options?: {
+        skipCache?: boolean;
+    }): Promise<GetSiteMarketingPageResponse>;
+    /**
+     * Read the cached value for `pageKey` without making a network call.
+     * Returns `null` when the entry hasn't been fetched yet — callers can
+     * fall back to a synchronous static default while {@link prefetch}
+     * warms the cache in the background.
+     */
+    getCached(pageKey: string): GetSiteMarketingPageResponse | null;
+    /**
+     * Warm the SDK cache for `pageKey` without rendering anything yet.
+     * Common pattern: call from a `<Link onPointerEnter>` / `onFocus` so
+     * the next page is already loaded by the time the visitor clicks.
+     * Subsequent `get(pageKey)` calls resolve from cache.
+     */
+    prefetch(pageKey?: string): Promise<GetSiteMarketingPageResponse>;
+}
+export declare class BiabDevCollectionsClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    list(): Promise<ListCollectionsResponse>;
+    create(input: CreateCollectionInput): Promise<CreateCollectionResponse>;
+    get(slug: string): Promise<GetCollectionResponse>;
+}
+export declare class BiabDevRowsClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    list(collectionSlug: string, input?: ListRowsInput): Promise<ListRowsResponse>;
+    upsert(collectionSlug: string, input: UpsertRowInput): Promise<UpsertRowResponse>;
+    query(collectionSlug: string, input: QueryRowsInput): Promise<QueryRowsResponse>;
+}
+/**
+ * Read rows out of the org's CUSTOM DATABASE — the tables you declare with
+ * `defineDataModel()` and push with `biab-dev sync-data-model`.
+ *
+ * ⚠️ Not the same thing as `.collections` / `.rows`. Those read Site Data (the
+ * site builder's tables, `site_data_rows`). Rows seeded with
+ * `biab-dev sync-records` live in `org_object_records` and are reachable only
+ * through here — no `collections:*` call will ever return one.
+ *
+ * Requires the `metadata:read_records` scope. What a key can actually read is
+ * decided per object by its `visibility`:
+ *
+ *   - `private` (default) — a SECRET key only. Call from a server component, a
+ *     route handler, or at build time; a `pk_…` key gets "not found".
+ *   - `authenticated` — a secret key, or a publishable key carrying a signed-in
+ *     tenant session.
+ *   - `public` — any key, including a publishable (`pk_…`) one in page JS.
+ *
+ * So a table you declared `public` is readable straight from the browser; a
+ * private one never is. Open a table by declaring `visibility` in your model.
+ *
+ * ```ts
+ * const result = await biab.site(siteId).dataModel.listRecords({
+ *   object: TECH_OBJECT_ID,   // the universalIdentifier from your config
+ * });
+ * if (!result.available) return <UpgradeCard feature={result.requiredFeature} />;
+ * for (const tech of result.records) {
+ *   tech.fields.name;      // scalar values, keyed by field name
+ *   tech.relations.icon;   // [{ recordId, object }] — links, not embedded rows
+ * }
+ * ```
+ */
+export declare class BiabDevDataModelClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    /**
+     * One page of an object's rows, newest first, with relations expanded.
+     *
+     * Relations come back as LINKS (`{ recordId, object }`), not embedded rows —
+     * fetch the targets with a follow-up call for the object they point at.
+     * Every declared relation field is present; `[]` means "no links yet", which
+     * is deliberately distinguishable from a field that wasn't returned.
+     *
+     * Paginate by passing the previous response's `nextCursor` back as `cursor`
+     * until it comes back `null`. The cursor is opaque — don't build one.
+     */
+    listRecords(input: ListDataModelRecordsInput): Promise<ListDataModelRecordsResponse>;
+    /**
+     * Every row of an object, walking `nextCursor` to exhaustion.
+     *
+     * For build-time rendering of a table you own and whose size you know. It is
+     * an unbounded loop over your data by definition — for anything visitor-facing
+     * or open-ended, page with {@link listRecords} instead.
+     *
+     * Returns the plan-gate shape unchanged if the org lacks the entitlement, so
+     * the same `available` branch works for both.
+     */
+    listAllRecords(input: Omit<ListDataModelRecordsInput, "cursor">): Promise<ListDataModelRecordsResponse>;
+}
+/**
+ * Read your site's visitor counts back.
+ *
+ * The `<BIABAnalytics/>` tracker (`@businessdash/sdk/react-analytics`) RECORDS
+ * pageviews; this READS the totals, so you can put a number on the page instead
+ * of only feeding the dashboard.
+ *
+ * ```ts
+ * // Site-wide, all time
+ * const all = await biab.site(siteId).analytics.pageViews();
+ * if (all.available) console.log(`${all.total.views} views`);
+ *
+ * // One page, last 30 days
+ * const home = await biab.site(siteId).analytics.pageViews({ paths: ['/'], days: 30 });
+ *
+ * // A batch of pages in one round-trip
+ * const list = await biab.site(siteId).analytics.pageViews({
+ *   paths: ['/tech/typescript', '/tech/rust'],
+ * });
+ * // list.paths → [{ path, views, visitors }, …], every requested path present
+ * ```
+ *
+ * `visitors` approximates unique visitors (distinct daily-rotating anon id).
+ * Requires the `analytics.web` entitlement — an org without it gets
+ * `{ available: false }`, so branch on `.available`.
+ */
+export declare class BiabDevAnalyticsClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    /**
+     * Pageview + visitor counts. Pass `paths` for a per-path breakdown (plus a
+     * combined `total`), or omit them for a site-wide `total`. `days` windows the
+     * count; omit for all-time.
+     */
+    pageViews(input?: PageViewsInput): Promise<PageViewsResponse>;
+    /**
+     * Which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, …) actually fetched
+     * this site's pages: fetch counts, distinct pages read, vendor, intent
+     * (training / search / live-assistant), and when each last came.
+     *
+     * First-party AEO visibility — recorded when crawlers hit the tracker (the
+     * assistant browsing agents run JS) and when your server reports the rest
+     * via `reportAiCrawlerHit` from `@businessdash/sdk/analytics-server`. Defaults
+     * to a 30-day window.
+     *
+     * ```ts
+     * const ai = await biab.site(siteId).analytics.aiVisibility({ days: 30 });
+     * if (ai.available) {
+     *   for (const c of ai.crawlers)
+     *     console.log(`${c.name}: ${c.fetches} fetches over ${c.distinctPages} pages`);
+     * }
+     * ```
+     */
+    aiVisibility(input?: AiVisibilityInput): Promise<AiVisibilityResponse>;
+}
+/**
+ * The "Powered by BusinessDash" attribution badge's one narrow function.
+ *
+ * `<BusinessDashFooter/>` uses this to (a) read whether the badge is required on
+ * this plan and (b) optionally report that it rendered. Both are scoped to your
+ * own site with a publishable key.
+ *
+ * ⚠️ The heartbeat is a courtesy signal, not proof of anything — BusinessDash
+ * verifies the badge by fetching your live domain, not by trusting this call. So
+ * don't build logic on the heartbeat; do honor `policy().required`.
+ */
+export declare class BiabDevAttributionClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    /**
+     * This site's badge policy: `{ siteId, required }`. `required` is `true` on
+     * plans that can't remove the badge (launch), `false` otherwise. Build the
+     * badge's `?ref=<siteId>` backlink from `siteId`.
+     */
+    policy(): Promise<AttributionPolicy>;
+    /**
+     * Report that the badge rendered on `url`. Best-effort and untrusted — it
+     * never throws for a bad URL (you get `{ recorded: false }`), and it's safe to
+     * fire-and-forget. Don't await it in a render path.
+     */
+    heartbeat(input: AttributionHeartbeatInput): Promise<AttributionHeartbeatResponse>;
+}
+export declare class BiabDevAssetsClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    create(input: SiteAssetInput): Promise<UploadSiteAssetResponse>;
+}
+export declare class BiabDevActionsClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    run(actionName: string, input?: ExecuteActionInput): Promise<ExecuteActionResponse>;
+}
+export declare class BiabDevEmailTemplatesClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    list(input?: ListEmailTemplatesInput): Promise<ListEmailTemplatesResponse>;
+    get(templateId: number): Promise<GetEmailTemplateResponse>;
+    create(input: CreateEmailTemplateInput): Promise<CreateEmailTemplateResponse>;
+    createVersion(templateId: number, input: CreateEmailTemplateVersionInput): Promise<CreateEmailTemplateVersionResponse>;
+}
+export declare class BiabDevFollowersClient {
+    private readonly client;
+    private readonly siteId;
+    constructor(client: BiabDevClient, siteId: string);
+    private actionPath;
+    join(input: FollowerJoinInput): Promise<FollowerJoinResponse>;
+    me(input: FollowerMeInput): Promise<FollowerMeResponse>;
+    edit(input: FollowerEditInput): Promise<FollowerEditResponse>;
+    leave(input: FollowerLeaveInput): Promise<FollowerLeaveResponse>;
+}
+export declare class BiabDevDashboardClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    createSession(): Promise<DashboardSessionResponse>;
+}
+export declare class BiabDevStorefrontClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    /**
+     * Legacy embed-session mint (kept for iframe-widget consumers).
+     * The programmatic methods below let consumer sites render their
+     * own native product catalog using BIAB as the data layer.
+     */
+    createSession(input?: StorefrontSessionInput): Promise<StorefrontSessionResponse>;
+    /**
+     * Paginated list of live products for the calling org's storefront.
+     * Cursor is an opaque integer offset — pass back the response's
+     * `nextCursor` to fetch the next page. Filter by category via the
+     * `categoryId` option.
+     */
+    listProducts(input?: {
+        limit?: number;
+        cursor?: number | null;
+        categoryId?: string;
+    }): Promise<StorefrontListProductsResponse>;
+    /**
+     * Filterable listing grid with facets — the data behind a full shop page.
+     * Returns enriched per-card price/ratings/badges plus `categoryCounts` and
+     * the catalog-wide `priceRange` for a sidebar. Supports `search`,
+     * `categoryId`, `minPriceCents`/`maxPriceCents`, `minRating` (1–5), and
+     * `sort` (featured | newest | price-asc | price-desc | rating-desc).
+     */
+    listProductsWithMeta(input?: {
+        search?: string;
+        categoryId?: string;
+        minPriceCents?: number;
+        maxPriceCents?: number;
+        minRating?: number;
+        sort?: StorefrontSort;
+        limit?: number;
+        /** Dev-only: also surface pending (non-live) products. Caller-gated. */
+        preview?: boolean;
+    }): Promise<StorefrontProductsWithMetaResponse>;
+    /** Org-scoped product categories for a storefront sidebar. */
+    listCategories(): Promise<StorefrontCategoriesResponse>;
+    /**
+     * Full product detail with variants + per-image rows. Returns 404
+     * via `BiabApiError` if the product isn't live or doesn't belong
+     * to the org bound to the API key.
+     */
+    getProduct(productId: string): Promise<StorefrontProductDetail>;
+    /** Approved reviews for a product + aggregate (`avgRating`, `totalCount`).
+     *  Cursor-paginated — pass back `nextCursor` for the next page. */
+    getProductReviews(productId: string, input?: {
+        limit?: number;
+        cursor?: number | null;
+    }): Promise<StorefrontProductReviewsResponse>;
+    /** "You may also like" — same-category / paired recommendations. */
+    getRelatedProducts(productId: string, input?: {
+        limit?: number;
+    }): Promise<StorefrontRelatedProductsResponse>;
+    /** Companion / exclusive cross-sell addons for the "complete your X" rail. */
+    getProductAddons(productId: string): Promise<StorefrontAddonsResponse>;
+}
+export declare class BiabDevCartClient {
+    private readonly client;
+    private readonly visitorToken;
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, visitorToken?: string | null, sessionToken?: string | null);
+    /**
+     * Use an anonymous visitor token (UUID stored in the consumer's
+     * own httpOnly cookie). Same shopper across page loads, no
+     * sign-in required.
+     */
+    forVisitor(visitorToken: string): BiabDevCartClient;
+    /**
+     * Use a tenantAuth session token instead of a visitor token.
+     * Carts are now keyed to the signed-in customer; persists
+     * across devices.
+     */
+    withSession(sessionToken: string): BiabDevCartClient;
+    private headers;
+    /**
+     * Legacy embed-session mint (kept for iframe-widget consumers).
+     * The programmatic methods below let the consumer site render
+     * its own native cart UI.
+     */
+    createSession(): Promise<CartSessionResponse>;
+    /**
+     * Read the current cart snapshot — item count, items with
+     * resolved product detail (name, image, variant title, unit
+     * price), subtotal, currency. Auto-creates an empty cart row
+     * the first time it's called for a new visitor/session, so
+     * the consumer always gets a valid snapshot.
+     */
+    get(): Promise<CartSnapshot>;
+    /**
+     * Add a product (optionally with a variant) to the cart. If the
+     * (productId, variantId) already exists, increments its quantity
+     * rather than creating a duplicate line.
+     */
+    addItem(input: CartAddItemInput): Promise<CartSnapshot>;
+    /**
+     * Set a line's quantity. Pass quantity=0 to delete the line.
+     */
+    updateItem(itemId: string, input: CartUpdateItemInput): Promise<CartSnapshot>;
+    removeItem(itemId: string): Promise<CartSnapshot>;
+    /**
+     * Stamp a coupon code on the cart. Validation runs at checkout —
+     * stamping here is a no-op when invalid; the consumer learns
+     * via the Stripe-checkout-session response whether the code
+     * actually applies.
+     */
+    applyCoupon(input: CartCouponInput): Promise<CartSnapshot>;
+    removeCoupon(): Promise<CartSnapshot>;
+    /** Empty all items + drop the stamped coupon. Keeps the cart row itself. */
+    clear(): Promise<CartSnapshot>;
+}
+export declare class BiabDevCheckoutClient {
+    private readonly client;
+    private readonly visitorToken;
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, visitorToken?: string | null, sessionToken?: string | null);
+    /**
+     * Authenticate the start-from-cart call as an anonymous shopper
+     * (visitor-token cart). Same UUID you used with `client.cart.forVisitor(...)`.
+     */
+    forVisitor(visitorToken: string): BiabDevCheckoutClient;
+    /**
+     * Authenticate as a signed-in customer (tenantAuth session token).
+     * The Stripe Checkout Session will be created against this
+     * customer's saved cart.
+     */
+    withSession(sessionToken: string): BiabDevCheckoutClient;
+    private headers;
+    /**
+     * Legacy iframe-embed mint — gives back a tokenized URL to render
+     * inside an iframe that redirects to Stripe. Kept for `<Checkout/>`
+     * consumers; new code should call `start()` for native handoff.
+     */
+    createSession(input: CheckoutSessionInput): Promise<CheckoutSessionResponse>;
+    /**
+     * Convert the caller's saved BIAB cart (resolved via visitor token
+     * or session token) into a Stripe Checkout Session. Returns the
+     * Stripe-hosted URL; redirect the browser there to collect payment.
+     *
+     * `successUrl` + `cancelUrl` may be full URLs on the consumer's own
+     * domain. We append `session_id={CHECKOUT_SESSION_ID}` to the
+     * success URL automatically so the success page can call
+     * `getStatus(sessionId)` to confirm payment.
+     */
+    start(input?: CheckoutStartInput): Promise<CheckoutStartResponse>;
+    /**
+     * Look up a Stripe Checkout Session by id. Returns paid / unpaid
+     * status plus the customer details Stripe collected — what the
+     * consumer's "thank you" page calls before rendering.
+     */
+    getStatus(sessionId: string): Promise<CheckoutStatusResponse>;
+}
+/**
+ * White-glove Google Places proxy. BIAB owns the API key — consumer
+ * code never sees it. Use at the checkout delivery-address input
+ * to give shoppers text-search predictions + verify deliverability
+ * before submitting the order.
+ *
+ * Mirrors the working reference in `Resources/addressParser/`:
+ *   - `search(query)` — text-search predictions (uses Google
+ *     `places:searchText`)
+ *   - `getDetails(placeId)` — placeId → `GoogleAddress` shape
+ *   - `verify(form)` — text-searches the entered address and
+ *     compares component-by-component
+ *
+ * Three pure converters are exported alongside as static methods —
+ * the same ones the reference React hooks wrap, just plain functions
+ * so they work outside React too.
+ *
+ * @example
+ * ```tsx
+ * // On each keystroke (debounced):
+ * const result = await client.address.search({ query: input });
+ * if (!result.enabled) return; // platform not configured; show plain input
+ *
+ * // When user picks a prediction:
+ * const detail = await client.address.getDetails(prediction.place_id);
+ * if (detail.enabled && detail.address) {
+ *   const form = BiabDevAddressClient.googleToFormValues(detail.address);
+ *   reactHookForm.reset(form);
+ * }
+ *
+ * // Before submitting the order:
+ * const v = await client.address.verify(form);
+ * if (!v.isVerified) showDidYouMean(v.googleAddress);
+ * ```
+ */
+export declare class BiabDevAddressClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    search(input: AddressSearchInput): Promise<AddressSearchResponse>;
+    getDetails(placeId: string): Promise<AddressDetailsResponse>;
+    verify(input: AddressFormValues): Promise<AddressVerifyResponse>;
+    /** Convert Google's `GoogleAddress` shape into a form-values object. */
+    static googleToFormValues(g: GoogleAddress): AddressFormValues;
+    /** Convert a form-values object into Stripe's billing-address shape. */
+    static formToStripeAddress(a: AddressFormValues): {
+        line1: string;
+        line2: string | null;
+        city: string;
+        state: string;
+        postal_code: string;
+        country: string;
+    };
+}
+/**
+ * Org-side recurring offerings (gym memberships, monthly service
+ * plans, software subscriptions). Lists are public read; the
+ * checkout-start endpoint hands the customer off to Stripe-hosted
+ * Checkout in `mode: 'subscription'`.
+ *
+ * Requires the org to have synced each offering to Stripe via the
+ * dashboard's "Sync to Stripe" action — otherwise `startCheckout`
+ * returns 409 `subscription_not_synced`.
+ */
+export declare class BiabDevSubscriptionsClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    list(): Promise<SubscriptionOfferingsListResponse>;
+    get(id: string): Promise<SubscriptionOffering>;
+    startCheckout(id: string, input?: SubscriptionCheckoutInput): Promise<SubscriptionCheckoutResponse>;
+}
+export declare class BiabDevCouponsClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    /**
+     * Validate a coupon code against the org's Stripe-connected
+     * account. Returns the discount shape (percent / amount /
+     * duration) when valid; `{ valid: false, reason, message }`
+     * otherwise so the consumer's UI can show "$10 off" before the
+     * shopper proceeds to checkout.
+     *
+     * Source of truth is Stripe — what this endpoint validates is
+     * exactly what Stripe-hosted Checkout will accept.
+     *
+     * @example
+     * ```ts
+     * const result = await client.coupons.validate("SAVE10");
+     * if (result.valid) showDiscount(result.percentOff ?? result.amountOffCents);
+     * else toast.error(result.message);
+     * ```
+     */
+    validate(code: string): Promise<CouponValidateResponse>;
+}
+/**
+ * Shipping: rate lookups + on-demand tracking. White-glove model —
+ * BIAB owns the carrier integration; consumer code never sees the
+ * underlying provider name. Gated on `ecommerce.shipping` so calls
+ * from orgs on the Launch plan return the standard plan-gate body
+ * via {@link BiabApiError} (status 403).
+ *
+ * @example
+ * ```ts
+ * const { options, requiresShipping } = await client.shipping
+ *   .forVisitor(visitorToken)
+ *   .getRates({ deliveryAddress });
+ * if (!requiresShipping) skipShippingStep();
+ * else {
+ *   const picked = options[0]; // cheapest
+ *   await client.checkout.forVisitor(visitorToken).start({
+ *     shipping: picked,
+ *     successUrl, cancelUrl,
+ *   });
+ * }
+ * ```
+ */
+export declare class BiabDevShippingClient {
+    private readonly client;
+    private readonly visitorToken;
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, visitorToken?: string | null, sessionToken?: string | null);
+    forVisitor(visitorToken: string): BiabDevShippingClient;
+    withSession(sessionToken: string): BiabDevShippingClient;
+    private headers;
+    /**
+     * Fetch shipping rate options for the caller's cart + a delivery
+     * address. Multi-origin + multi-parcel orders surface as a single
+     * combined cost per service tier (carrier+speed). Pass the chosen
+     * option directly to `client.checkout.start({ shipping })`.
+     */
+    getRates(input: ShippingRatesInput): Promise<ShippingRatesResponse>;
+    /**
+     * On-demand tracking lookup for a known tracking number. Returns
+     * the cached `status_history` we already received via webhook
+     * PLUS a fresh poll against the carrier (`liveStatus`). Consumer
+     * apps that don't subscribe to push notifications use this to
+     * refresh "Where's my order?" pages.
+     */
+    track(input: {
+        trackingNumber: string;
+    }): Promise<ShippingTrackResponse>;
+    /**
+     * The org's storefront shipping config — whether shipping is on, a coarse
+     * "ships from" (city/state/country), the destinations it ships to, the duty
+     * model, and preferred carriers. Sanitized (no keys/secrets, no precise
+     * origin address). Render shipping copy without the org re-declaring it.
+     *
+     * @example
+     * ```ts
+     * const s = await client.shipping.settings();
+     * if (s.enabled) show(`Ships to ${s.allowedDestinationCountries?.join(", ") ?? "anywhere"}`);
+     * ```
+     */
+    settings(): Promise<ShippingSettingsResponse>;
+}
+/**
+ * Customer notification preferences. Per-customer-per-org channel
+ * settings (in-app / email / SMS / outbound webhook). Identified by
+ * the tenantAuth session token — bind with `.withSession(token)`.
+ *
+ * Outbound-webhook events the consumer site can subscribe to are
+ * the same as the shipping fan-out keys:
+ *   - `order.shipped`
+ *   - `order.out_for_delivery`
+ *   - `order.delivered`
+ *   - `order.exception`
+ *   - `order.return_label_created`
+ *
+ * The webhook payload is JSON + signed with the customer's saved
+ * `webhookSigningSecret` via `X-BIAB-Signature: <hex hmac-sha256>`.
+ * Consumer's receiver verifies via:
+ *   crypto.createHmac('sha256', secret).update(rawBody).digest('hex')
+ */
+export declare class BiabDevNotificationsClient {
+    private readonly client;
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, sessionToken?: string | null);
+    withSession(sessionToken: string): BiabDevNotificationsClient;
+    private headers;
+    getPreferences(): Promise<CustomerNotificationPreferencesResponse>;
+    updatePreferences(input: CustomerNotificationPreferencesUpdateInput): Promise<CustomerNotificationPreferencesUpdateResponse>;
+    /**
+     * Start a verification flow for a destination the customer wants to
+     * use for shipping notifications. Email: a verification link is sent
+     * (15-min TTL). Phone: a 6-digit OTP is sent (5-min TTL).
+     *
+     * Until verified, the channel stays inert — preventing the customer
+     * from spamming arbitrary destinations.
+     */
+    startVerification(input: StartVerificationInput): Promise<StartVerificationResponse>;
+    /**
+     * Consume the verification token from the email link / SMS OTP.
+     * On success: stamps `*VerifiedAt` on the prefs row + activates the
+     * channel.
+     */
+    confirmVerification(input: ConfirmVerificationInput): Promise<ConfirmVerificationResponse>;
+}
+export declare class BiabDevBlogClient {
+    private readonly client;
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, sessionToken?: string | null);
+    /**
+     * Chainable: return a blog client whose `postComment` + future
+     * write methods authenticate via the tenantAuth session token.
+     * Reads (listPosts, getPost, listCategories, listTags, listComments)
+     * don't require a session and work the same either way.
+     *
+     * @example
+     * ```ts
+     * await client.blog().withSession(token).postComment(slug, { content });
+     * ```
+     */
+    withSession(sessionToken: string): BiabDevBlogClient;
+    private headers;
+    /**
+     * Legacy embed-session mint (kept for backwards compat with
+     * embedded-iframe consumers).
+     */
+    createSession(input?: BlogSessionInput): Promise<BlogSessionResponse>;
+    /**
+     * Paginated list of published blog posts for the calling org's
+     * site. Cursor is an opaque number — pass back the `nextCursor`
+     * from the previous response to fetch the next page.
+     */
+    listPosts(input?: {
+        limit?: number;
+        cursor?: number | null;
+        categoryId?: string;
+    }): Promise<BlogListPostsResponse>;
+    /**
+     * Get a single post by its slug. Returns `{ post, access }`
+     * where `access === 'paywall'` and `post.content === ''` for
+     * posts marked `accessLevel: 'paid' | 'followers'`. The
+     * consumer renders a paywall over the empty body when access
+     * is restricted.
+     */
+    getPost(slug: string): Promise<BlogPostBySlugResponse>;
+    listCategories(): Promise<BlogCategoryListResponse>;
+    listTags(): Promise<BlogTagListResponse>;
+    listComments(slug: string, input?: {
+        limit?: number;
+        cursor?: number | null;
+    }): Promise<BlogCommentListResponse>;
+    /**
+     * Submit a comment on a published post. Requires `withSession()` —
+     * anonymous comments aren't supported in 0.9.0 (the blog_comments
+     * row references a `user_id` text column that's NOT NULL). The
+     * server runs the same moderation screener used by the dashboard
+     * tRPC path; the response surfaces both the comment row + the
+     * moderation verdict so the consumer can show "your comment is
+     * pending review" when applicable.
+     */
+    postComment(slug: string, input: BlogCommentPostInput): Promise<BlogCommentPostResponse>;
+    /**
+     * Current like state + count for a post. With `withSession()`, `liked`
+     * reflects whether this visitor already liked it (filled heart on load);
+     * without a session the public count is returned with `liked: false`.
+     */
+    likeStatus(slug: string): Promise<BlogLikeResponse>;
+    /**
+     * Toggle the session visitor's like on a post. Requires `withSession()`
+     * (same identity as `postComment`). Returns the new like state + count.
+     */
+    toggleLike(slug: string): Promise<BlogLikeResponse>;
+}
+/**
+ * Public reviews-wall client. Reads the org's external reviews
+ * (Google + Yelp + manual + CSV) — the same store the marketing bundle's
+ * `reviews` aggregate is built from. The bundle ships the first page + the
+ * aggregate (count / average / histogram); use this to lazily fetch deeper
+ * pages on "View all" / scroll.
+ *
+ * @example
+ * ```ts
+ * const page1 = await client.reviews.list({ limit: 10 });
+ * if (page1.nextOffset != null) {
+ *   const page2 = await client.reviews.list({ limit: 10, offset: page1.nextOffset });
+ * }
+ * ```
+ */
+export declare class BiabDevReviewsClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    /**
+     * One page of the org's public reviews, newest-first. `limit` defaults to
+     * the server default (10, max 50). Pass the previous response's
+     * `nextOffset` to page forward — it's `null` once the list is exhausted.
+     * `source` narrows to a single platform (e.g. `"yelp"`).
+     */
+    list(input?: {
+        limit?: number;
+        offset?: number;
+        source?: "google" | "yelp" | "housecall_pro" | "other";
+    }): Promise<ReviewWallListResponse>;
+}
+/**
+ * Public hiring client — the org's open job postings and their categories, so
+ * a consumer can render a careers page in their own design system.
+ *
+ * Read-only by construction: everything returned is content the org published
+ * for candidates. To take applications, hand the posting's `applicationFormId`
+ * to the forms surface — this client grants no submit path of its own.
+ *
+ * @example
+ * ```ts
+ * const { items } = await client.hiring.list({ limit: 20 });
+ * const posting = await client.hiring.get("senior-installer");
+ * if (posting.applicationFormId) {
+ *   const form = await client.forms.schema(posting.applicationFormId);
+ * }
+ * ```
+ */
+export declare class BiabDevHiringClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    /**
+     * One page of open postings, newest-first. `limit` defaults to the server
+     * default (25, max 100). Pass the previous response's `nextOffset` to page
+     * forward — it's `null` once the list is exhausted. `category` narrows to a
+     * single group by its slug.
+     *
+     * Only postings that are published, active, have seats left, and are under
+     * their application cap are returned, so a careers page never advertises a
+     * role that can no longer be applied to.
+     */
+    list(input?: {
+        limit?: number;
+        offset?: number;
+        category?: string;
+    }): Promise<JobPostingListResponse>;
+    /**
+     * One open posting by slug. Rejects with a 404 error when the posting is a
+     * draft, closed, archived, fully filled, or has hit its application cap —
+     * treat that as "this role is gone" rather than as a transient failure.
+     */
+    get(slug: string): Promise<JobPosting>;
+    /**
+     * The org's job categories with a count of open postings in each — enough to
+     * render filter chips or grouped sections without fetching every posting.
+     */
+    categories(): Promise<JobCategoryListResponse>;
+}
+export declare class BiabDevChatbotClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    /** Returns the iframe URL for `<Chatbot/>`. */
+    createSession(): Promise<ChatbotSessionResponse>;
+    /** Reads the org's persisted chatbot config (system prompt, KB, model). */
+    getConfig(): Promise<ChatbotConfig>;
+    /**
+     * Persists the org's chatbot config. Requires `chatbot:write` scope on the
+     * API key — typically only used by admin tools, not embedded widgets.
+     */
+    updateConfig(input: ChatbotConfigUpdateInput): Promise<ChatbotConfig>;
+    /**
+     * Headless chat — host owns the UI. Each request is fully org-scoped: the
+     * server runs the LLM with the org's saved system prompt + KB + model.
+     *
+     * The response includes `uiActions` (e.g. `show_form`) and `availability`
+     * (front-desk presence + wait-time hint). Headless consumers should resolve
+     * any `show_form` action via {@link getChatForm}, render the fields, and POST
+     * back through {@link submitChatForm} (which carries the chat transcript).
+     */
+    chat(input: ChatbotChatInput): Promise<ChatbotChatResponse>;
+    /**
+     * Upload a file a visitor attached in the chat. Presigns a direct-to-R2 PUT
+     * (gated by the org's `chat.file_uploads` entitlement — check
+     * `getConfig().fileUploadsEnabled` before offering it), uploads the bytes, and
+     * returns a ref you can attach to the conversation. `sessionId` is any stable
+     * per-chat id (drives the 5-files/hour cap + provenance). Throws on a refused
+     * upload (entitlement, 7 MB cap, or rate limit).
+     */
+    uploadFile(args: {
+        sessionId: string;
+        file: File;
+        /** Captured visitor email — stored for provenance + checked against the
+         *  platform block-list. Optional. */
+        uploaderEmail?: string | null;
+    }): Promise<{
+        url: string;
+        name: string;
+        type: string;
+        size: number;
+    }>;
+    /**
+     * Live front-desk availability — tier flag, staff-online presence, and
+     * a wait-time hint string. Safe to poll (every 20–30s) so the SDK
+     * consumer can render or hide a "Talk to a person" CTA without sending
+     * a chat turn.
+     */
+    getAvailability(): Promise<ChatbotAvailability>;
+    /**
+     * Fetch a **Live** form definition to render inline on your own page.
+     * A form is reachable here when it is Live (`isActive`) — independent of
+     * `chatbotAccess`. Returns a 404-equivalent throw when the form is missing
+     * or not Live. For a form the AI chatbot recommended via a `show_form`
+     * action, use {@link getChatForm} instead (it carries the chat transcript on
+     * submit).
+     */
+    getForm(slug: string): Promise<ChatbotFormDefinition>;
+    /**
+     * Submit a **Live** form. Fans out to the same hiring/leads/inquiries CRM
+     * mirrors, actions, scheduling, and staff notification as every other ingest
+     * point. Gated on Live only — no `chatbotAccess` required.
+     */
+    submitForm(slug: string, input: ChatbotFormSubmitInput): Promise<ChatbotFormSubmitResponse>;
+    /**
+     * Fetch a form the AI chatbot recommended via a `show_form` UI action. This
+     * additionally requires the form to be chatbot-accessible (`chatbotAccess`),
+     * which a recommended form always is. Most embeds want {@link getForm}; reach
+     * for this only inside the chat flow.
+     */
+    getChatForm(slug: string): Promise<ChatbotFormDefinition>;
+    /**
+     * Submit a chatbot-recommended form. Same CRM fan-out as {@link submitForm},
+     * but on the chatbot path — pass `priorChat` so the resulting CRM inquiry can
+     * include the chat transcript that led to the submission.
+     */
+    submitChatForm(slug: string, input: ChatbotFormSubmitInput): Promise<ChatbotFormSubmitResponse>;
+    /**
+     * Create or resume the persisted `chatSessions` row for this
+     * visitor. Idempotent on `(orgId, visitorToken)`. The returned
+     * `sessionId` is what you pass to `postMessage`, `pollMessages`,
+     * and `requestHuman`.
+     *
+     * Distinct from {@link createSession} — that mints an iframe-embed
+     * token. This one exposes the underlying server session so the
+     * consumer can render their own UI and still reach Front Desk.
+     */
+    createPersistedSession(input: ChatbotPersistedSessionInput): Promise<ChatbotPersistedSessionResponse>;
+    /**
+     * Poll messages + session status. Pass `since` (ISO timestamp) on
+     * subsequent polls to only fetch new rows. Recommended cadence:
+     * 3–5s while the widget is open and focused.
+     */
+    pollMessages(input: {
+        sessionId: string;
+        visitorToken: string;
+        since?: string;
+    }): Promise<ChatbotMessagesResponse>;
+    /**
+     * Append a visitor message. Returns the updated message log so
+     * the consumer can replace its local list with an authoritative
+     * snapshot rather than tracking optimistic updates manually.
+     */
+    postMessage(input: ChatbotAppendMessageInput): Promise<ChatbotMessagesResponse>;
+    /**
+     * Visitor presses "Talk to a person." Plan-gated on
+     * `chat.front_desk` — orgs on Launch get back
+     * `{ available: false, reason: 'plan_required', requiredFeature, upgradeUrl }`.
+     * Orgs on Growth+ get `{ available: true, status, placeInLine, ... }`.
+     *
+     * Branch on `result.available` to render an upgrade CTA vs the
+     * "you're in line" UI.
+     *
+     * @example
+     * ```ts
+     * const result = await client.chatbot.requestHuman({ sessionId, visitorToken });
+     * if (!result.available) return <UpgradeCard feature={result.requiredFeature} />;
+     * return <Queue position={result.placeInLine} eta={result.estimateLabel} />;
+     * ```
+     */
+    requestHuman(input: ChatbotRequestHumanInput): Promise<ChatbotRequestHumanResponse>;
+}
+export declare class BiabDevCustomerPortalClient {
+    private readonly client;
+    private readonly organizationId;
+    /**
+     * Optional tenantAuth session token. When set, requests include
+     * an `X-BIAB-Session-Token` header and the BIAB customer-portal
+     * routes resolve the calling user via the session payload
+     * instead of the API key's user binding.
+     *
+     * This is the right path for consumer storefronts that don't
+     * mint per-customer API keys: sign customers in via
+     * `client.auth.signIn()`, store the resulting session token
+     * (the SDK's `createAuthHandler` does this in an httpOnly
+     * cookie automatically), then pass that token to
+     * `client.customerPortal(orgId).withSession(token)` for every
+     * customer-scoped call.
+     */
+    private readonly sessionToken;
+    constructor(client: BiabDevClient, organizationId: string | null, 
+    /**
+     * Optional tenantAuth session token. When set, requests include
+     * an `X-BIAB-Session-Token` header and the BIAB customer-portal
+     * routes resolve the calling user via the session payload
+     * instead of the API key's user binding.
+     *
+     * This is the right path for consumer storefronts that don't
+     * mint per-customer API keys: sign customers in via
+     * `client.auth.signIn()`, store the resulting session token
+     * (the SDK's `createAuthHandler` does this in an httpOnly
+     * cookie automatically), then pass that token to
+     * `client.customerPortal(orgId).withSession(token)` for every
+     * customer-scoped call.
+     */
+    sessionToken?: string | null);
+    /**
+     * Return a customer-portal client that authenticates the calling
+     * user via the tenantAuth session token instead of (or in
+     * addition to) the API key's user binding. Chainable.
+     *
+     * @example
+     * ```ts
+     * const session = await getTenantSessionFromCookie({ cookieValue });
+     * const work = await client
+     *   .customerPortal(orgId)
+     *   .withSession(session.sessionToken)
+     *   .getWork();
+     * ```
+     */
+    withSession(sessionToken: string): BiabDevCustomerPortalClient;
+    private headers;
+    context(): Promise<CustomerPortalContextResponse>;
+    getProfile(): Promise<CustomerPortalProfile>;
+    updateProfile(input: CustomerPortalUpdateProfileInput): Promise<CustomerPortalUpdateProfileResponse>;
+    myOtherCustomerOrgs(): Promise<CustomerPortalOtherOrgsResponse>;
+    /**
+     * Read the signed-in customer's notification preferences (per category,
+     * per channel) for the bound org. The response also includes the full
+     * category + channel catalog so SDK consumers can render the UI
+     * without hardcoding either — both grow over time on the server side.
+     *
+     * @example
+     * ```ts
+     * const { preferences, categories, channels } =
+     *   await client.customerPortal().getNotificationPreferences();
+     *
+     * categories.map((c) => (
+     *   <Row category={c} state={preferences[c.id]} />
+     * ));
+     * ```
+     */
+    getNotificationPreferences(): Promise<NotificationPreferencesResponse>;
+    /**
+     * Update notification preferences. Sparse: only send the toggles you
+     * want to flip — omitted keys keep their persisted (or default) value.
+     * Compliance-required channels (e.g. transactional email) silently
+     * stay true regardless of what's sent.
+     *
+     * @example
+     * ```ts
+     * await client.customerPortal().updateNotificationPreferences({
+     *   preferences: { marketing: { email: false, sms: false } },
+     * });
+     * ```
+     */
+    updateNotificationPreferences(input: NotificationPreferencesUpdateInput): Promise<NotificationPreferencesResponse>;
+    /**
+     * Read the signed-in customer's "what's on my plate" bundle: open
+     * jobs, pending quotes, unpaid invoices, contracts awaiting signature,
+     * and a recent payment history, plus a roll-up summary for the
+     * consumer header.
+     *
+     * URLs are host-less paths — resolve them against the consumer's own
+     * storefront origin to build clickable links.
+     *
+     * @example
+     * ```ts
+     * const work = await client.customerPortal().getWork();
+     * const { openJobCount, unpaidBalance } = work.summary;
+     * work.invoices.filter((i) => i.balanceDue > 0).map(...)
+     * ```
+     */
+    getWork(): Promise<CustomerWorkBundle>;
+    /** Read a single job the signed-in customer owns. */
+    getJob(jobId: string): Promise<CustomerJobDetail>;
+    /** Read a single quote the signed-in customer owns. */
+    getQuote(quoteId: string): Promise<CustomerQuoteDetail>;
+    /** Naming alias for {@link getQuote} — read a single quote the customer owns. */
+    viewQuote(quoteId: string): Promise<CustomerQuoteDetail>;
+    /**
+     * Accept a quote as the signed-in customer. Idempotent — re-accepting
+     * an already-accepted quote resolves the existing state without
+     * additional side effects.
+     */
+    acceptQuote(quoteId: string): Promise<CustomerQuoteActionResponse>;
+    /** Reject a quote as the signed-in customer. Idempotent. */
+    rejectQuote(quoteId: string): Promise<CustomerQuoteActionResponse>;
+    /** Read a single invoice the signed-in customer owns. */
+    getInvoice(invoiceId: string): Promise<CustomerInvoiceDetail>;
+    /**
+     * Start payment for an invoice the customer owns. Returns a Stripe-hosted
+     * Checkout URL to redirect to — card entry happens entirely on Stripe, so
+     * your app never touches card data (stays out of PCI scope).
+     *
+     * Pass your own `successUrl` / `cancelUrl` to return into your storefront,
+     * or omit them to land back on the org's branded hosted invoice page.
+     *
+     * @example
+     * ```ts
+     * const { checkoutUrl } = await client
+     *   .customerPortal()
+     *   .payInvoice(invoiceId, { successUrl: "https://shop.example.com/paid" });
+     * window.location.href = checkoutUrl;
+     * ```
+     */
+    payInvoice(invoiceId: string, opts?: CustomerInvoicePayInput): Promise<CustomerInvoicePayResponse>;
+    /**
+     * Download the customer's invoice as a PDF. Returns the file metadata plus
+     * the decoded `bytes` (a `Uint8Array`) — the auth headers ride along on the
+     * SDK request, so this works for a signed-in customer without exposing a
+     * public URL. Once paid, the PDF carries a PAID marker + payment history.
+     *
+     * @example Browser download
+     * ```ts
+     * const file = await client.customerPortal(orgId).withSession(token)
+     *   .downloadInvoicePdf(invoiceId);
+     * const url = URL.createObjectURL(
+     *   new Blob([file.bytes], { type: file.contentType }),
+     * );
+     * const a = document.createElement("a");
+     * a.href = url;
+     * a.download = file.filename;
+     * a.click();
+     * URL.revokeObjectURL(url);
+     * ```
+     */
+    downloadInvoicePdf(invoiceId: string): Promise<CustomerInvoicePdf & {
+        bytes: Uint8Array;
+    }>;
+    /** Read a single contract the signed-in customer owns. */
+    getContract(contractId: string): Promise<CustomerContractDetail>;
+    /**
+     * Begin signing a contract the customer owns. Returns a ready, absolute
+     * signing URL on the org's branded hostname — redirect the customer there
+     * to BIAB's hosted e-sign page, which captures the signature and generates
+     * the executed PDF. No signature payload is collected client-side, so the
+     * legal record stays consistent across consumers.
+     *
+     * Rejects with `contract_already_signed` (409) or `contract_not_signable`
+     * (409) when the contract isn't in a signable state.
+     *
+     * @example
+     * ```ts
+     * const { signingUrl } = await client
+     *   .customerPortal()
+     *   .signContract(contractId);
+     * window.location.href = signingUrl;
+     * ```
+     */
+    signContract(contractId: string): Promise<CustomerContractSignResponse>;
+    /** List reviews the signed-in customer has submitted in this org. */
+    listMyReviews(): Promise<CustomerReviewListResponse>;
+    /**
+     * Referral roll-up for the signed-in customer (as an affiliate), summed
+     * across every program they're enrolled in. `enrolled: false` with zeroed
+     * counters when the customer holds no affiliate record. Real data appears
+     * once the org's referral attribution + payout pipeline records activity.
+     *
+     * @example
+     * ```ts
+     * const stats = await client.customerPortal().myReferralStats();
+     * if (stats.enrolled) showEarnings(stats.earningsCents);
+     * ```
+     */
+    myReferralStats(): Promise<CustomerReferralStats>;
+    /**
+     * The customer's referral conversion feed (most recent first). Empty until
+     * the attribution pipeline records conversions. `limit` 1–200 (default 50).
+     */
+    myReferralHistory(opts?: {
+        limit?: number;
+    }): Promise<CustomerReferralHistoryResponse>;
+    /** The customer's referral payout history + upcoming rows (newest first). */
+    myReferralPayouts(): Promise<CustomerReferralPayoutsResponse>;
+    /**
+     * The signed-in customer's orders (newest first), each with a shipment
+     * roll-up (`overallStatus`, `anyInTransit`, `latestEstimatedDelivery`) for
+     * an orders/shipping dashboard list. `limit` 1–100 (default 30). Requires
+     * the org's `ecommerce.shipping` entitlement.
+     *
+     * @example
+     * ```ts
+     * const { items } = await client.customerPortal().listOrders();
+     * items.filter((o) => o.anyInTransit).map(renderTracker);
+     * ```
+     */
+    listOrders(opts?: {
+        limit?: number;
+    }): Promise<CustomerOrderListResponse>;
+    /**
+     * The customer's full payment history with this org — invoice payments,
+     * store-order charges, and refunds (negative amounts), newest first.
+     * Powers a "Payments" tab on the customer dashboard.
+     *
+     * ```ts
+     * const { items } = await client.customerPortal().listPayments();
+     * items.map((p) => `${p.occurredAt} ${p.kind} $${p.amount}`);
+     * ```
+     */
+    listPayments(opts?: {
+        limit?: number;
+    }): Promise<import("./contracts").CustomerPaymentHistoryResponse>;
+    /**
+     * One order the customer owns: line items + shipments, each shipment with
+     * its carrier, tracking link, status, and `statusHistory` timeline (read
+     * from stored data — webhook-fresh).
+     */
+    getOrder(orderId: string): Promise<CustomerOrderDetail>;
+    /**
+     * Open a return / refund request on an order the customer owns. Creates a
+     * `requested` record and notifies the org's review queue — the org's
+     * approval (not this call) triggers the actual Stripe refund. Omit `items`
+     * for a whole-order request. The request then shows up under
+     * `getOrder(orderId).returnRequests`.
+     *
+     * @example
+     * ```ts
+     * await portal.submitReturnRequest(orderId, {
+     *   reason: "damaged",
+     *   customerNote: "Arrived cracked.",
+     *   items: [{ orderItemId, quantity: 1 }],
+     * });
+     * ```
+     */
+    submitReturnRequest(orderId: string, input?: CustomerReturnRequestInput): Promise<CustomerReturnRequestCreated>;
+    /**
+     * List the digital downloads the customer is entitled to for a paid order
+     * (P10d). Each item is a ready-to-use URL — a short-lived presigned link for
+     * BIAB-hosted files (`expiresInSeconds` set) or the org's external link.
+     * Returns an empty list until the order's payment settles.
+     *
+     * @example
+     * ```ts
+     * const { items } = await portal.getDownloads(orderId);
+     * for (const d of items) console.log(d.productName, d.url);
+     * ```
+     */
+    getDownloads(orderId: string): Promise<CustomerDownloadsResponse>;
+    /**
+     * Track a single shipment the customer owns (resolved through their own
+     * order). Returns the stored shipment plus a best-effort live carrier status
+     * (`liveStatus`) when it's still in transit.
+     */
+    trackShipment(shipmentId: string): Promise<CustomerShipmentTracking>;
+    /**
+     * Submit a review tied to the signed-in customer's email. Land
+     * with `status: pending` so org staff can moderate before the
+     * review surfaces on the public bundle. `jobId` is optional and
+     * validated server-side against the customer's own jobs — a
+     * stranger's id is rejected with a 403.
+     */
+    submitReview(input: CustomerReviewSubmitInput): Promise<CustomerReviewSubmitResponse>;
+    /** List the comment thread on a job the customer owns. */
+    listJobComments(jobId: string): Promise<CustomerJobCommentsListResponse>;
+    /** Post a customer comment on one of the customer's own jobs. */
+    postJobComment(jobId: string, input: CustomerJobCommentPostInput): Promise<CustomerJobComment>;
+    /**
+     * Open (or reuse) a front-desk chat session bound to the signed-in
+     * customer and post their first message. Staff see the thread in
+     * the chatbot inbox with `linkedContactId` set so they know who's
+     * reaching out. Returns the `sessionId` + `visitorToken` so the
+     * consumer can poll for staff replies or render the chatbot widget
+     * over the same session via the existing chatbot embed flow.
+     */
+    contactCompany(input: CustomerContactCompanyInput): Promise<CustomerContactCompanyResponse>;
+    /**
+     * Staff-on-the-way view for a job the customer owns. First-cut:
+     * returns assigned-tech display names + dispatch status, the last
+     * known GPS ping per tech (when available), and the most recent
+     * ETA snapshot from the dispatch_offers cascade.
+     *
+     * `liveEtaAvailable: false` today — flips to true once the
+     * dispatch travel-time recompute layer ships, at which point the
+     * `eta` field switches sources without breaking this shape.
+     */
+    getJobEta(jobId: string): Promise<CustomerJobEtaResponse>;
+    /**
+     * Unified job activity feed: structured events (status changes,
+     * dispatch lifecycle, media uploads, quote/contract/invoice
+     * transitions) interleaved with chat messages linked to this
+     * customer's contact. One linear timeline so the customer can
+     * see "what happened, then what was said, then what happened
+     * next" without piecing together separate views.
+     *
+     * Each entry is `{ kind: 'event' | 'chat', id, at, ... }`. The
+     * discriminated union means TypeScript narrows correctly when
+     * you branch on `kind`.
+     */
+    getJobActivity(jobId: string): Promise<CustomerJobActivityResponse>;
+}
+/**
+ * Creates a {@link BiabDevClient} for the given host `baseUrl` and package API key.
+ *
+ * @remarks
+ * **Alpha:** This package is still in alpha release. APIs may change; it is **not** intended
+ * for production use yet. Prefer non-production environments until a stable major is published.
+ */
+export declare function createBiabDevClient(options: BiabDevClientOptions): BiabDevClient;
+/**
+ * Per-tenant auth: hosted sign-in/sign-up scoped to the org bound to
+ * the API key. Used by the SDK's `createAuthHandler` (server) and
+ * `<SignIn />` / `<SignUp />` / `<SignOut />` components (client).
+ */
+export declare class BiabDevAuthClient {
+    private readonly client;
+    constructor(client: BiabDevClient);
+    start(input: TenantAuthStartInput): Promise<TenantAuthStartResponse>;
+    /**
+     * Ergonomic shortcut for `start({ intent: "sign-in", ... })`. Returns
+     * the platform-hosted redirect URL the caller should navigate to;
+     * stateless on its own — pair with `exchange()` on your callback
+     * route to mint the session.
+     */
+    signIn(input: {
+        redirectUri: string;
+        returnTo?: string;
+        loginHint?: string;
+    }): Promise<TenantAuthStartResponse>;
+    /**
+     * Ergonomic shortcut for `start({ intent: "sign-up", ... })`. Same
+     * shape as `signIn`; only the platform-hosted page that opens differs.
+     */
+    signUp(input: {
+        redirectUri: string;
+        returnTo?: string;
+        loginHint?: string;
+    }): Promise<TenantAuthStartResponse>;
+    /**
+     * Alias for `requestPasswordReset`. Always resolves `{ ok: true }`
+     * (the server doesn't reveal whether the email matched an account).
+     */
+    forgotPassword(input: TenantAuthPasswordResetInput): Promise<TenantAuthPasswordResetResponse>;
+    exchange(input: TenantAuthExchangeInput): Promise<TenantAuthExchangeResponse>;
+    me(input: {
+        sessionToken: string;
+    }): Promise<TenantAuthMeResponse>;
+    signOut(): Promise<TenantAuthSignOutResponse>;
+    /**
+     * Trigger a password-reset email for `input.email`. Always resolves
+     * with `{ ok: true }` — the server intentionally does not reveal
+     * whether a matching account exists. The email (when sent) contains
+     * a platform-hosted reset URL; the consumer never needs to build a
+     * "set new password" page.
+     *
+     * Server-only by design (the API key may not be exposed to the
+     * browser). The matching browser-side `requestPasswordReset()` in
+     * `@businessdash/sdk/react` proxies through the auth-handler.
+     */
+    requestPasswordReset(input: TenantAuthPasswordResetInput): Promise<TenantAuthPasswordResetResponse>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map