@foir/sdk 0.5.0 → 0.8.0

package/dist/media/ProgressiveMedia.d.ts

@@ -0,0 +1,56 @@
+import type { ProgressiveImageSource, ProgressiveVideoSource, VariantTierKey } from './media';
+export interface ProgressiveMediaProps {
+    image?: ProgressiveImageSource;
+    video?: ProgressiveVideoSource;
+    alt?: string;
+    className?: string;
+    /** Fill the parent container instead of using intrinsic aspect ratio. */
+    fill?: boolean;
+    /**
+     * Object-fit for fill mode. Defaults to 'cover'. Has no effect when `fill`
+     * is false (the image renders at its intrinsic aspect ratio).
+     */
+    fit?: 'cover' | 'contain';
+    /**
+     * Solid-colour placeholder mode. When neither image nor video is provided,
+     * render a flat coloured div. `aspectRatio` defaults to 16/10.
+     */
+    placeholder?: {
+        color: string;
+        aspectRatio?: number;
+    };
+    /** Video playback — autoplay on mount. Default true. */
+    autoplay?: boolean;
+    /** Video playback — muted. Default true (required for autoplay). */
+    muted?: boolean;
+    /** Video playback — loop on end. Default true. */
+    loop?: boolean;
+    /**
+     * When false, skip loading the full media layer (no `<video>`/full `<img>`
+     * mount, no HLS attach, no full-image preload). The lower layers — colour,
+     * blurhash, thumbnail — still render. Used by responsive dual-render so the
+     * CSS-hidden branch doesn't download its full asset. Default true.
+     */
+    active?: boolean;
+    /**
+     * `sizes` attribute applied to the full `<img>` — tells the browser how
+     * wide the image renders so it can pick the right `srcset` entry. Default
+     * `"100vw"`. Has no effect on video sources.
+     */
+    sizes?: string;
+    /**
+     * When true, treat this media as the page's LCP candidate: thumbnail and
+     * full `<img>` get `fetchpriority="high"` + `loading="eager"`, and any
+     * `<video>` mounts immediately. When false (default) below-fold behaviour:
+     * `loading="lazy"` on `<img>`, and `<video>` is gated by an
+     * IntersectionObserver so its `src`/HLS only attaches near the viewport.
+     */
+    priority?: boolean;
+    /**
+     * Tier order, smallest→largest, used to build the `srcset` from a
+     * `VariantSet`. Defaults to {@link DEFAULT_VARIANT_TIERS}; override when a
+     * project curates a different tier set.
+     */
+    variantTiers?: readonly VariantTierKey[];
+}
+export declare function ProgressiveMedia({ image, video, alt, className, fill, fit, placeholder, autoplay, muted, loop, active, sizes, priority, variantTiers, }: ProgressiveMediaProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/media/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@foir/sdk/media` — progressive media components, Foir media adapters, and
+ * screen capture.
+ *
+ * `react` is a peer dependency; `hls.js` and `blurhash` are optional peers
+ * loaded lazily (video/blurhash gracefully no-op when absent). The capture
+ * helpers are browser-only and pull in neither.
+ */
+export { ProgressiveMedia } from './ProgressiveMedia';
+export type { ProgressiveMediaProps } from './ProgressiveMedia';
+export { BlurhashCanvas } from './BlurhashCanvas';
+export type { BlurhashCanvasProps } from './BlurhashCanvas';
+export { useProgressiveLoad } from './useProgressiveLoad';
+export type { LoadStage, UseProgressiveLoadOptions } from './useProgressiveLoad';
+export { toProgressiveImage, toProgressiveVideo, effectiveImageDimensions, cropAspectRatio, DEFAULT_VARIANT_TIERS, } from './media';
+export type { VariantTier, VariantSet, VariantTierKey, ProgressiveImageSource, ProgressiveVideoSource, FoirImageInput, FoirVideoInput, } from './media';
+export { captureFoirScreen, isFoirScreenCaptureSupported } from './screen-capture';
+export type { FoirScreenCapture, FoirScreenCaptureOptions } from './screen-capture';

package/dist/media/media.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Foir media types + adapters.
+ *
+ * Framework-agnostic plumbing for rendering Foir image/video fields with
+ * `<ProgressiveMedia>`: the canonical source shapes, GraphQL-value → source
+ * adapters (crop normalization, per-format variant sets, HLS URL
+ * absolutising), and crop-aware dimension maths for CLS-free layout.
+ *
+ * HLS manifest URLs are absolutised via the shared `absolutiseFoirMediaUrl`
+ * from the client transport — not re-implemented here.
+ */
+/** One rendered tier: a URL + its TRUE (crop-aware) dims (for srcset `w` + CLS). */
+export interface VariantTier {
+    url: string;
+    width?: number | null;
+    height?: number | null;
+}
+/** Curated tier set in one format (Foir `ImageVariantSet`). */
+export interface VariantSet {
+    thumbnail?: VariantTier | null;
+    small?: VariantTier | null;
+    medium?: VariantTier | null;
+    large?: VariantTier | null;
+    xlarge?: VariantTier | null;
+    _2xl?: VariantTier | null;
+    _3xl?: VariantTier | null;
+    _4xl?: VariantTier | null;
+}
+/** A `VariantSet` tier name. */
+export type VariantTierKey = keyof VariantSet;
+/**
+ * Default tier order, smallest→largest, for walking a `VariantSet`
+ * deterministically when building a `srcset`. Override per `<ProgressiveMedia>`
+ * via the `variantTiers` prop when a project curates a different tier set.
+ */
+export declare const DEFAULT_VARIANT_TIERS: readonly VariantTierKey[];
+/** Image source with progressive loading data. */
+export interface ProgressiveImageSource {
+    url: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    blurhash?: string;
+    dominantColor?: string;
+    thumbnailUrl?: string;
+    /** Per-format tier sets (WebP universal; AVIF preferred via `<picture>`). */
+    webp?: VariantSet | null;
+    avif?: VariantSet | null;
+    /**
+     * Optional crop rectangle expressed as percentages of the source image
+     * (`{x, y, width, height}` in 0–100). Foir's image pipeline serves the
+     * cropped file at the cropped dimensions, so consumers need this to compute
+     * correct `width`/`height` attrs for CLS-free rendering.
+     */
+    crop?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+}
+/** Video source with progressive loading data + optional HLS. */
+export interface ProgressiveVideoSource {
+    url: string;
+    width?: number;
+    height?: number;
+    blurhash?: string;
+    dominantColor?: string;
+    thumbnailUrl?: string;
+    previewUrl?: string;
+    hlsUrl?: string;
+    duration?: number;
+}
+/**
+ * Foir GraphQL `Image`-like input — the shape a consumer's codegen
+ * produces for an image field (intrinsic dims + per-format variant sets +
+ * crop as opaque JSON). Structurally compatible with the generated type.
+ */
+export interface FoirImageInput {
+    url?: string | null;
+    alt?: string | null;
+    width?: number | null;
+    height?: number | null;
+    blurhash?: string | null;
+    dominantColor?: string | null;
+    webp?: VariantSet | null;
+    avif?: VariantSet | null;
+    crop?: {
+        [key: string]: unknown;
+    } | null;
+}
+/** Foir GraphQL `Video`-like input. */
+export interface FoirVideoInput {
+    url?: string | null;
+    width?: number | null;
+    height?: number | null;
+    hlsManifestUrl?: string | null;
+    thumbnailUrl?: string | null;
+    previewUrl?: string | null;
+    blurhash?: string | null;
+    dominantColor?: string | null;
+}
+/**
+ * Adapt a Foir image field to the `ProgressiveImageSource` consumed by
+ * `<ProgressiveMedia>`. Returns `undefined` when the field is empty (the
+ * caller falls back to a placeholder). Narrows the JSON-typed `crop` to the
+ * numeric keys; out-of-range values are filtered in `effectiveImageDimensions`.
+ */
+export declare function toProgressiveImage(img: FoirImageInput | null | undefined): ProgressiveImageSource | undefined;
+/**
+ * Adapt a Foir video field to the `ProgressiveVideoSource` consumed by
+ * `<ProgressiveMedia>`. Absolutises the HLS manifest URL (Foir returns it
+ * relative to its media proxy). Returns `undefined` when the field is empty.
+ */
+export declare function toProgressiveVideo(v: FoirVideoInput | null | undefined): ProgressiveVideoSource | undefined;
+/**
+ * Resolve the dimensions of the file Foir's pipeline will actually serve,
+ * applying any crop percentages to the source's intrinsic size. Returns null
+ * when the source has no width/height. Drives both the wrapper aspect-ratio
+ * and the `<img>` `width`/`height` attrs.
+ */
+export declare function effectiveImageDimensions(image: {
+    width?: number | null;
+    height?: number | null;
+    crop?: unknown;
+} | null | undefined): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * Compute a CSS `aspect-ratio` string from a Foir image's natural dimensions
+ * and optional crop. When a usable crop is set the cropped rectangle's aspect
+ * wins; otherwise the intrinsic width/height; otherwise `null`.
+ */
+export declare function cropAspectRatio(image: {
+    width?: number | null;
+    height?: number | null;
+    crop?: unknown;
+} | null | undefined): string | null;

package/dist/media/screen-capture.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Screen capture — a picture of what the reader was looking at.
+ *
+ * ---------------------------------------------------------------------------
+ * Why it lives in the SDK
+ * ---------------------------------------------------------------------------
+ *
+ * Two surfaces need the same picture: the console's own bug report, and the
+ * feedback widget a customer's visitors use (`@foir/sdk/react`). One of those
+ * ships to npm and the other does not, so the shared half has to sit in the
+ * published package — a copy in each would be two answers to "how big is a
+ * screenshot", free to drift, and the drift would only show up as an upload the
+ * storage quota measures differently from the preview.
+ *
+ * ---------------------------------------------------------------------------
+ * The browser's picker IS the consent gate
+ * ---------------------------------------------------------------------------
+ *
+ * `getDisplayMedia` cannot be called without a user gesture and cannot resolve
+ * without the person choosing a surface in the browser's own dialog. So there is
+ * nothing here that asks for permission separately, and nothing that could
+ * capture without the reader having picked what to hand over. Call this from a
+ * click handler and from nowhere else.
+ *
+ * The stream is stopped before this function returns, on every path — a capture
+ * that left the tracks live would leave the browser's "sharing your screen"
+ * indicator on after a single still frame.
+ */
+/** How the still is encoded. Both have defaults; neither is read from anywhere else. */
+export interface FoirScreenCaptureOptions {
+    /**
+     * Longest horizontal edge of the still, in pixels. Wider captures are scaled
+     * down proportionally; narrower ones are left alone rather than upscaled.
+     *
+     * Default 1600, which is a readable full-page shot of a 4K display and lands
+     * around 200-400kB as JPEG. It is a bound on the bytes a reader uploads over
+     * their own connection, not a quality target.
+     */
+    maxWidth?: number;
+    /** JPEG quality, 0 to 1. Default 0.7. */
+    quality?: number;
+}
+/** One captured still. */
+export interface FoirScreenCapture {
+    /** The bytes, for upload. `size` on it is what the storage quota measures. */
+    blob: Blob;
+    /**
+     * The same bytes as a `data:` URL, for an `<img src>` preview.
+     *
+     * Both, rather than one plus a converter, because the two callers need
+     * different halves and neither should re-encode: an object URL has a lifetime
+     * to manage and a second `toDataURL` would be a second encode of one frame.
+     */
+    dataUrl: string;
+    /** The still's own dimensions, after any downscale. */
+    width: number;
+    height: number;
+    mimeType: string;
+}
+/**
+ * Whether this browser can capture at all.
+ *
+ * Ask before rendering a capture button. `getDisplayMedia` is absent on every
+ * iOS browser and on any page served over plain HTTP, and a button that can only
+ * produce an error message is worse than no button.
+ */
+export declare function isFoirScreenCaptureSupported(): boolean;
+/**
+ * Capture one still of a surface the reader picks.
+ *
+ * Returns `null` when they dismissed the picker — that is a decision, not a
+ * failure, and a caller that treated it as one would put an error in front of
+ * somebody who just changed their mind. Everything else throws.
+ *
+ * The one ambiguity worth stating: a page embedded in an iframe without
+ * `allow="display-capture"` is refused with the SAME `NotAllowedError` the
+ * dismissal produces, so it lands here as `null` too. The browser gives no way
+ * to tell the two apart, and guessing wrong in the other direction would mean an
+ * error toast on every cancel.
+ */
+export declare function captureFoirScreen(options?: FoirScreenCaptureOptions): Promise<FoirScreenCapture | null>;

package/dist/media/useProgressiveLoad.d.ts

@@ -0,0 +1,23 @@
+export type LoadStage = 'color' | 'blurhash' | 'thumbnail' | 'full';
+export interface UseProgressiveLoadOptions {
+    blurhash?: string;
+    thumbnailUrl?: string;
+    fullUrl?: string;
+    /**
+     * Optional srcset + sizes — when provided to image sources, the preloader
+     * matches the variant the visible `<img>` will pick, so the browser dedupes
+     * the fetch instead of downloading two sizes.
+     */
+    fullSrcSet?: string;
+    fullSizes?: string;
+    isVideo?: boolean;
+}
+/**
+ * State machine for progressive media loading.
+ * Stages advance forward only: color → blurhash → thumbnail → full.
+ * Skips stages when data is missing. Never regresses.
+ */
+export declare function useProgressiveLoad({ blurhash, thumbnailUrl, fullUrl, fullSrcSet, fullSizes, isVideo, }: UseProgressiveLoadOptions): {
+    stage: LoadStage;
+    onFullReady: () => void;
+};

package/dist/media.js

@@ -2,7 +2,12 @@
 import { useRef as useRef2, useState as useState2, useCallback as useCallback2, useEffect as useEffect3 } from "react";
 
 // src/graphql/foir-request.ts
+import { print as print2 } from "graphql";
+
+// src/graphql/cdn-route.ts
 import { print } from "graphql";
+
+// src/graphql/foir-request.ts
 var FOIR_CDN_BASE = "https://cdn.foir.dev/";
 function absolutiseFoirMediaUrl(url, cdnBase = FOIR_CDN_BASE) {
   if (!url) return void 0;
@@ -387,12 +392,109 @@ function ProgressiveMedia({
     }
   );
 }
+
+// src/media/screen-capture.ts
+var DEFAULT_MAX_WIDTH = 1600;
+var DEFAULT_QUALITY = 0.7;
+var CAPTURE_MIME_TYPE = "image/jpeg";
+function isFoirScreenCaptureSupported() {
+  return typeof navigator !== "undefined" && typeof navigator.mediaDevices?.getDisplayMedia === "function";
+}
+async function captureFoirScreen(options = {}) {
+  if (!isFoirScreenCaptureSupported()) {
+    throw new Error(
+      "[foir] this browser cannot capture the screen: navigator.mediaDevices.getDisplayMedia is unavailable. It needs a secure context (https, or localhost) and is absent on iOS. Call isFoirScreenCaptureSupported() before offering capture."
+    );
+  }
+  const maxWidth = options.maxWidth ?? DEFAULT_MAX_WIDTH;
+  const quality = options.quality ?? DEFAULT_QUALITY;
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getDisplayMedia({
+      video: { displaySurface: "browser" }
+    });
+  } catch (err) {
+    if (isDismissal(err)) return null;
+    throw err;
+  }
+  try {
+    const video = document.createElement("video");
+    video.muted = true;
+    video.playsInline = true;
+    video.srcObject = stream;
+    await waitForMetadata(video);
+    await video.play();
+    const { videoWidth, videoHeight } = video;
+    if (!videoWidth || !videoHeight) {
+      throw new Error(
+        "[foir] the captured stream reported no dimensions, so there is no frame to draw. This is the browser ending the capture before the first frame arrived \u2014 retry it."
+      );
+    }
+    const scale = videoWidth > maxWidth ? maxWidth / videoWidth : 1;
+    const width = Math.round(videoWidth * scale);
+    const height = Math.round(videoHeight * scale);
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error(
+        "[foir] this browser gave no 2d canvas context, so the captured frame cannot be encoded. Nothing was uploaded."
+      );
+    }
+    ctx.drawImage(video, 0, 0, width, height);
+    video.srcObject = null;
+    const dataUrl = canvas.toDataURL(CAPTURE_MIME_TYPE, quality);
+    return {
+      blob: dataUrlToBlob(dataUrl),
+      dataUrl,
+      width,
+      height,
+      mimeType: CAPTURE_MIME_TYPE
+    };
+  } finally {
+    for (const track of stream.getTracks()) track.stop();
+  }
+}
+function isDismissal(err) {
+  const name = err?.name;
+  return name === "NotAllowedError" || name === "AbortError";
+}
+function waitForMetadata(video) {
+  if (video.readyState >= 1) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    video.addEventListener("loadedmetadata", () => resolve(), { once: true });
+    video.addEventListener(
+      "error",
+      () => reject(
+        new Error("[foir] the captured stream failed to load before a frame could be read")
+      ),
+      { once: true }
+    );
+  });
+}
+function dataUrlToBlob(dataUrl) {
+  const comma = dataUrl.indexOf(",");
+  const header = comma === -1 ? "" : dataUrl.slice(0, comma);
+  if (comma === -1 || !header.includes(";base64")) {
+    throw new Error(
+      `[foir] the canvas produced a data URL this build cannot decode (${header || "no header"}). Expected a base64 data URL.`
+    );
+  }
+  const binary = atob(dataUrl.slice(comma + 1));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  const mimeType = header.slice("data:".length, header.indexOf(";"));
+  return new Blob([bytes], { type: mimeType || CAPTURE_MIME_TYPE });
+}
 export {
   BlurhashCanvas,
   DEFAULT_VARIANT_TIERS,
   ProgressiveMedia,
+  captureFoirScreen,
   cropAspectRatio,
   effectiveImageDimensions,
+  isFoirScreenCaptureSupported,
   toProgressiveImage,
   toProgressiveVideo,
   useProgressiveLoad

package/dist/next/cookieAdapter.d.ts

@@ -0,0 +1,26 @@
+import type { SessionAdapter } from '../auth';
+/**
+ * The minimal cookie-store shape this adapter needs. It's satisfied by Next's
+ * `cookies()` (route handlers / server actions — `await cookies()` on Next 15),
+ * and by `NextResponse.cookies` in middleware. Kept structural on purpose so the
+ * SDK doesn't import (or pin a version of) `next/headers`.
+ */
+export interface FoirCookieStore {
+    get(name: string): {
+        value: string;
+    } | undefined;
+    set(name: string, value: string, options?: Record<string, unknown>): void;
+    delete(name: string): void;
+}
+export interface CookieAdapterOptions {
+    /** Cookie attributes for writes, merged over the secure defaults. */
+    cookieOptions?: Record<string, unknown>;
+}
+export declare function foirCookieName(key: string): string;
+/**
+ * A {@link SessionAdapter} backed by an HttpOnly cookie store — the seam for
+ * server-side (BFF) Foir sessions in Next.js. Pass the cookie store from a route
+ * handler / server action (`await cookies()`) for reads and writes; a Server
+ * Component's `cookies()` is read-only, so use it only for reads there.
+ */
+export declare function createFoirCookieAdapter(store: FoirCookieStore, opts?: CookieAdapterOptions): SessionAdapter;

package/dist/next/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@foir/sdk/next` — server-side Foir customer auth for the Next.js App Router
+ * (the BFF pattern): an HttpOnly-cookie session adapter, server-side session
+ * helpers, a provider-callback exchange, and a route-protection middleware.
+ *
+ * This is the server counterpart to `@foir/sdk/react`. `next` is a peer
+ * dependency (for the middleware helper).
+ */
+export { createFoirCookieAdapter, foirCookieName, } from './cookieAdapter';
+export type { FoirCookieStore, CookieAdapterOptions } from './cookieAdapter';
+export { getFoirSession, getFoirToken, foirSignOut, foirSignInWithPassword, foirRegisterWithPassword, foirSignInWithOtp, completeFoirProviderLogin, } from './session';
+export { createFoirMiddleware } from './middleware';
+export type { FoirMiddlewareConfig, FoirMiddlewareRequest } from './middleware';
+export type { FoirCustomer, SessionAdapter } from '../auth';
+export type { FoirEnv } from '../graphql/foir-request';

package/dist/next/middleware.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The slice of `NextRequest` the middleware reads. Typed structurally so the SDK
+ * doesn't need `next` installed to build — a real `NextRequest` satisfies it, so
+ * the returned function drops straight into `export const middleware`.
+ */
+export interface FoirMiddlewareRequest {
+    cookies: {
+        get(name: string): {
+            value: string;
+        } | undefined;
+    };
+    nextUrl: {
+        pathname: string;
+        search: string;
+    };
+    url: string;
+}
+export interface FoirMiddlewareConfig {
+    /** Where to send unauthenticated requests (path or absolute URL). */
+    signInUrl: string;
+    /**
+     * The session cookie whose presence means "signed in". Defaults to the
+     * access-token cookie the cookie adapter writes (`foir_token`).
+     */
+    cookieName?: string;
+    /**
+     * Return true for requests that require auth. Omit to protect every request
+     * the middleware `matcher` passes through.
+     */
+    isProtected?(request: FoirMiddlewareRequest): boolean;
+    /** Query param carrying the original path on the sign-in URL. Default `returnTo`. */
+    returnParam?: string;
+}
+/**
+ * Build a Next.js middleware that redirects unauthenticated requests to your
+ * sign-in URL. Edge-safe: it checks for the presence of the session cookie only
+ * — the bearer itself is validated server-side when you call the Foir API — so
+ * pair it with a real `getFoirSession` check in protected route handlers /
+ * server components. Returns a standard `Response` (redirect) or `undefined`
+ * (continue), both of which Next.js middleware accepts.
+ *
+ * ```ts
+ * // middleware.ts
+ * import { createFoirMiddleware } from '@foir/sdk/next';
+ * export const middleware = createFoirMiddleware({ signInUrl: '/sign-in' });
+ * export const config = { matcher: ['/dashboard/:path*'] };
+ * ```
+ */
+export declare function createFoirMiddleware(config: FoirMiddlewareConfig): (request: FoirMiddlewareRequest) => Response | undefined;

package/dist/next/session.d.ts

@@ -0,0 +1,53 @@
+import type { FoirCustomer } from '../auth';
+import type { FoirEnv } from '../graphql/foir-request';
+import type { CookieAdapterOptions, FoirCookieStore } from './cookieAdapter';
+/**
+ * Server-side session helpers for the Next.js BFF pattern. Each takes the Next
+ * cookie store (`await cookies()` in a route handler / server action, or the
+ * read-only `cookies()` in a Server Component for reads).
+ *
+ * Note on "verification": the customer access token is opaque to your app and
+ * validated by the Foir API on use, so `getFoirSession` returns the identity
+ * stored in the cookies rather than locally verifying a JWT. A rejected/expired
+ * bearer surfaces when you call the API (and `@foir/sdk/auth`'s `authedRequest`
+ * transparently refreshes it).
+ */
+/** The signed-in customer from the session cookies, or null. */
+export declare function getFoirSession(store: FoirCookieStore): Promise<FoirCustomer | null>;
+/** The current access token from the session cookies, or null. */
+export declare function getFoirToken(store: FoirCookieStore): Promise<string | null>;
+/** Clear the session cookies (sign out). */
+export declare function foirSignOut(store: FoirCookieStore, opts?: CookieAdapterOptions): Promise<void>;
+interface PasswordArgs {
+    env: FoirEnv;
+    store: FoirCookieStore;
+    email: string;
+    password: string;
+    cookieOptions?: CookieAdapterOptions['cookieOptions'];
+}
+/** Password sign-in in a route handler; persists the session to cookies. */
+export declare function foirSignInWithPassword({ env, store, email, password, cookieOptions, }: PasswordArgs): Promise<FoirCustomer>;
+/** Register a customer in a route handler; persists the session to cookies. */
+export declare function foirRegisterWithPassword({ env, store, email, password, cookieOptions, }: PasswordArgs): Promise<FoirCustomer>;
+/** Complete an OTP sign-in in a route handler; persists the session to cookies. */
+export declare function foirSignInWithOtp({ env, store, email, otp, cookieOptions, }: {
+    env: FoirEnv;
+    store: FoirCookieStore;
+    email: string;
+    otp: string;
+    cookieOptions?: CookieAdapterOptions['cookieOptions'];
+}): Promise<FoirCustomer>;
+/**
+ * Complete a provider (OAuth/OIDC) login in your callback route handler:
+ * exchange the `code` + `state` for tokens and persist them to the session
+ * cookies. Returns the customer.
+ */
+export declare function completeFoirProviderLogin(opts: {
+    env: FoirEnv;
+    store: FoirCookieStore;
+    providerKey: string;
+    code?: string;
+    state?: string;
+    cookieOptions?: CookieAdapterOptions['cookieOptions'];
+}): Promise<FoirCustomer>;
+export {};