@foir/sdk 0.5.0 → 0.7.0

package/dist/client.d.ts

@@ -1,135 +0,0 @@
-import { TypedDocumentNode } from '@graphql-typed-document-node/core';
-
-/**
- * Foir GraphQL client — a single typed fetch wrapper for SSR/edge loaders.
- *
- * No GraphQL client (Apollo/urql) required: the Foir public API is a plain
- * `POST` with an `x-api-key` header, and the dominant consumers (Hydrogen on
- * Oxygen, React Router loaders, TanStack Start on CF Workers) fetch in
- * server-only loaders and render — so Apollo's `InMemoryCache`/`useQuery`
- * reactivity is dead weight, and a shared cache on a stateless multi-tenant
- * edge worker is a cross-tenant hazard. This helper carries only the
- * Foir-specific transport concerns (auth header, preview schema channel,
- * error shape). Consumers on a GraphQL client (Apollo / urql / react-query /
- * graphql-request) use the generated `TypedDocumentNode`s directly with their
- * own client and replicate the two Foir-specific headers below — the
- * `x-api-key` and, in preview, `X-Foir-Schema-Channel: draft`.
- *
- * Deduplicates the hand-copied `lib/foir/client.ts` that shipped identically
- * across the Foir storefronts.
- */
-
-interface FoirEnv {
-    PLATFORM_API_URL?: string;
-    PLATFORM_API_KEY?: string;
-    PLATFORM_PREVIEW_API_KEY?: string;
-    FOIR_PREVIEW?: string;
-}
-/**
- * Returns true when `FOIR_PREVIEW=true` is set in the environment.
- *
- * Preview is selected at the environment level, not per-request: load a
- * preview env file that sets `FOIR_PREVIEW=true` + a `sk_…`
- * `PLATFORM_PREVIEW_API_KEY` with `drafts:read` instead of the default env.
- * The site-wide mode keeps draft semantics consistent — every loader sees
- * the same preview/published view of the world. Intended for non-production
- * surfaces only.
- */
-declare function isFoirPreview(env: FoirEnv): boolean;
-/** Default Foir CDN origin used to absolutise relative media URLs. */
-declare const FOIR_CDN_BASE = "https://cdn.foir.dev/";
-/**
- * Foir returns `hlsManifestUrl` as a relative path while every other media
- * URL is absolute. Prefix relative paths with the CDN host so the browser
- * doesn't request them from the consumer's own origin. Already-absolute URLs
- * pass through untouched. `cdnBase` is overridable for non-default CDN hosts.
- */
-declare function absolutiseFoirMediaUrl(url: string | null | undefined, cdnBase?: string): string | undefined;
-interface FoirGraphQLErrorItem {
-    message: string;
-    path?: Array<string | number>;
-}
-declare class FoirRequestError extends Error {
-    /** HTTP status code, when the request failed at the HTTP layer. */
-    readonly status?: number;
-    /** GraphQL errors, when the request failed with a no-data error envelope. */
-    readonly graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
-    readonly cause?: unknown;
-    constructor(message: string, options?: {
-        cause?: unknown;
-        status?: number;
-        graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
-    });
-}
-/**
- * Execute a typed GraphQL document against the Foir platform.
- *
- * Throws `FoirRequestError` on HTTP failure or GraphQL errors so the caller
- * can decide whether to rethrow or fall back to local defaults. GraphQL can
- * return partial data alongside errors; when data is present the errors are
- * logged and the data returned (callers handle nulls), and we only throw when
- * there's no data at all.
- */
-interface FoirRequestOptions {
-    /**
-     * Customer bearer token. api-public still needs the `x-api-key` to resolve
-     * the project; the bearer adds the customer identity for self-scoped reads
-     * (e.g. `myProfile`). Used by `@foir/sdk/auth`'s post-login profile fetch.
-     */
-    bearerToken?: string;
-}
-declare function foirRequest<TData, TVariables>(env: FoirEnv, document: TypedDocumentNode<TData, TVariables>, variables?: TVariables, options?: FoirRequestOptions): Promise<TData>;
-
-/**
- * Session-bound content client — forwards the customer bearer on every read
- * when one is available, so auth/segment-targeted variants and customer-scoped
- * records resolve out of the box, with no per-query wiring to forget.
- *
- * Resolution keys off the request's principal (see the platform's two-gate
- * model): the `x-api-key` alone resolves the *anonymous baseline*
- * (`context.authStatus = ""`); adding the customer bearer resolves the request
- * as that customer (`context.authStatus = "authenticated"`, `customer_id` set).
- *
- * Caching: an api-key-only read is identical for every anonymous visitor and is
- * shared-cacheable; a bearer-bearing read resolves per-customer and is not.
- * Because the bearer only exists once a customer signs in, anonymous traffic
- * keeps hitting the shared-cacheable baseline — only signed-in reads become
- * per-customer. Bind this client wherever content is personalized (for most
- * apps, everywhere the customer may be signed in) and use plain `foirRequest`
- * for reads that must stay anonymous regardless of session.
- */
-
-/**
- * Supplies the current customer bearer. Sync or async so consumers can read a
- * cookie session (Hydrogen/Remix), a KV store, an in-memory value, etc. Returns
- * the token when signed in, or `null`/`undefined` when signed out.
- */
-type FoirTokenProvider = () => string | null | undefined | Promise<string | null | undefined>;
-interface FoirContentClientConfig {
-    env: FoirEnv;
-    /**
-     * Resolves the current customer bearer before every request. When it yields a
-     * token the token is forwarded, so `authStatus`/segment targeting and
-     * customer-scoped records resolve as that customer; when it yields
-     * null/undefined the read hits the anonymous baseline. Omit for a client that
-     * is always anonymous (equivalent to calling `foirRequest` directly).
-     */
-    getToken?: FoirTokenProvider;
-}
-interface FoirContentClient {
-    /**
-     * Run a typed document, forwarding the bound customer bearer when available.
-     * An explicit `options.bearerToken` still wins, so a single call can override
-     * the bound token (or force anonymous by passing `undefined` — the bound
-     * token only fills in when `options.bearerToken` is not supplied).
-     */
-    request<TData, TVariables>(document: TypedDocumentNode<TData, TVariables>, variables?: TVariables, options?: FoirRequestOptions): Promise<TData>;
-}
-/**
- * Create a {@link FoirContentClient} bound to an env + token source. Every
- * `request` forwards the customer bearer when `getToken` yields one, upgrading
- * that read from the anonymous baseline to the signed-in customer.
- */
-declare function createFoirContentClient(config: FoirContentClientConfig): FoirContentClient;
-
-export { FOIR_CDN_BASE, type FoirContentClient, type FoirContentClientConfig, type FoirEnv, FoirRequestError, type FoirRequestOptions, type FoirTokenProvider, absolutiseFoirMediaUrl, createFoirContentClient, foirRequest, isFoirPreview };

package/dist/content.d.ts

@@ -1,96 +0,0 @@
-import { ReactNode, JSX } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-/**
- * createContentRenderer — the generic content-dispatch primitive.
- *
- * It does NOT know any concrete block types. Given a registry that maps each
- * block `__typename` to a component, it renders a `flexible` field's block
- * array: looks each block up by `__typename`, renders unknown types as null,
- * keys by the block `_id`, assigns LCP `priority` to the first block that
- * actually renders, and threads a consumer-defined `Ctx` to every component.
- *
- * The "switch" is a typed object lookup. Exhaustiveness is enforced where the
- * registry is BUILT — against the exhaustive `BlockRegistry` type the codegen
- * plugin (EID-92) generates per project, so omitting a block type is a compile
- * error there, not a runtime surprise here. The consumer can supply different
- * registries per surface (e.g. web vs email).
- */
-
-/** Minimal shape every block in a `flexible` field carries. */
-interface BlockLike {
-    __typename: string;
-    _id?: string | null;
-}
-/** Props a block component receives from the content renderer. */
-interface BlockComponentProps<TBlock, TCtx = unknown> {
-    block: TBlock;
-    /** Consumer-defined render context (host product, locale, etc.). */
-    ctx: TCtx;
-    /** True only for the first block that renders — the LCP candidate. */
-    priority: boolean;
-}
-/** A component that renders one block type. */
-type BlockComponent<TBlock, TCtx = unknown> = (props: BlockComponentProps<TBlock, TCtx>) => ReactNode;
-/**
- * A registry mapping `__typename` → block component. In practice this is the
- * exhaustive `BlockRegistry` type the codegen plugin emits for the project;
- * here it's the structural lower bound the renderer needs.
- */
-type BlockRegistry<TCtx = unknown> = Record<string, BlockComponent<any, TCtx>>;
-interface ContentRendererProps<TCtx> {
-    blocks: readonly BlockLike[] | null | undefined;
-    /** Consumer-defined context passed to every block component. */
-    ctx: TCtx;
-}
-/**
- * Build a `<ContentRenderer>` bound to a block registry. Returns a component
- * that takes the `flexible` field's `blocks` array plus a `ctx`.
- */
-declare function createContentRenderer<TCtx = unknown>(registry: BlockRegistry<TCtx>): (props: ContentRendererProps<TCtx>) => ReactNode;
-
-/** A resolved typography token from the project's design tokens. */
-interface TypographyToken {
-    /** Token key referenced by a Lexical node's `style`. */
-    name: string;
-    /** Rendered HTML element (paragraph / h1–h6 / blockquote). */
-    tag?: string;
-    value: {
-        fontFamily: string[];
-        fontSize: string | number;
-        fontWeight: string | number;
-        lineHeight: string | number;
-        letterSpacing: string | number;
-        textTransform?: string;
-    };
-}
-/**
- * Provide the project's resolved typography tokens to every nested
- * `<RichTextRenderer>` so callers don't thread them through each usage. A
- * `tokens` prop on the renderer still takes precedence.
- */
-declare function RichTextTypographyProvider({ tokens, children, }: {
-    tokens: TypographyToken[];
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-/** Read the injected typography tokens (null when no provider is mounted). */
-declare function useRichTextTypography(): TypographyToken[] | null;
-interface RichtextValueLike {
-    html?: string | null;
-    json?: unknown;
-}
-interface RichTextRendererProps {
-    value: RichtextValueLike | null | undefined;
-    className?: string;
-    /**
-     * Resolved typography tokens. Overrides any provided via
-     * `<RichTextTypographyProvider>`. When neither is set, paragraphs render
-     * with `fallbackTag` and no inline typography.
-     */
-    tokens?: TypographyToken[];
-    /** Tag used for any paragraph with no token style and no Lexical tag. */
-    fallbackTag?: keyof JSX.IntrinsicElements;
-}
-declare function RichTextRenderer({ value, className, tokens, fallbackTag, }: RichTextRendererProps): react_jsx_runtime.JSX.Element | null;
-
-export { type BlockComponent, type BlockComponentProps, type BlockLike, type BlockRegistry, type ContentRendererProps, RichTextRenderer, type RichTextRendererProps, RichTextTypographyProvider, type TypographyToken, createContentRenderer, useRichTextTypography };

package/dist/media.d.ts

@@ -1,234 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-
-/**
- * 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). */
-interface VariantTier {
-    url: string;
-    width?: number | null;
-    height?: number | null;
-}
-/** Curated tier set in one format (Foir `ImageVariantSet`). */
-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. */
-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.
- */
-declare const DEFAULT_VARIANT_TIERS: readonly VariantTierKey[];
-/** Image source with progressive loading data. */
-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. */
-interface ProgressiveVideoSource {
-    url: string;
-    width?: number;
-    height?: number;
-    blurhash?: string;
-    dominantColor?: string;
-    thumbnailUrl?: string;
-    previewUrl?: string;
-    hlsUrl?: string;
-    duration?: number;
-}
-/**
- * Foir GraphQL `ImageValue`-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.
- */
-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 `VideoValue`-like input. */
-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`.
- */
-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.
- */
-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.
- */
-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`.
- */
-declare function cropAspectRatio(image: {
-    width?: number | null;
-    height?: number | null;
-    crop?: unknown;
-} | null | undefined): string | null;
-
-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[];
-}
-declare function ProgressiveMedia({ image, video, alt, className, fill, fit, placeholder, autoplay, muted, loop, active, sizes, priority, variantTiers, }: ProgressiveMediaProps): react_jsx_runtime.JSX.Element | null;
-
-interface BlurhashCanvasProps {
-    hash: string;
-    className?: string;
-}
-/**
- * Decodes a BlurHash string to a 32×32 canvas. `blurhash` is an optional peer
- * dependency loaded via dynamic import — if it isn't installed the canvas
- * stays blank rather than throwing.
- */
-declare function BlurhashCanvas({ hash, className }: BlurhashCanvasProps): react_jsx_runtime.JSX.Element;
-
-type LoadStage = 'color' | 'blurhash' | 'thumbnail' | 'full';
-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.
- */
-declare function useProgressiveLoad({ blurhash, thumbnailUrl, fullUrl, fullSrcSet, fullSizes, isVideo, }: UseProgressiveLoadOptions): {
-    stage: LoadStage;
-    onFullReady: () => void;
-};
-
-export { BlurhashCanvas, type BlurhashCanvasProps, DEFAULT_VARIANT_TIERS, type FoirImageInput, type FoirVideoInput, type LoadStage, type ProgressiveImageSource, ProgressiveMedia, type ProgressiveMediaProps, type ProgressiveVideoSource, type UseProgressiveLoadOptions, type VariantSet, type VariantTier, type VariantTierKey, cropAspectRatio, effectiveImageDimensions, toProgressiveImage, toProgressiveVideo, useProgressiveLoad };

package/dist/next.d.ts

@@ -1,178 +0,0 @@
-/**
- * Foir GraphQL client — a single typed fetch wrapper for SSR/edge loaders.
- *
- * No GraphQL client (Apollo/urql) required: the Foir public API is a plain
- * `POST` with an `x-api-key` header, and the dominant consumers (Hydrogen on
- * Oxygen, React Router loaders, TanStack Start on CF Workers) fetch in
- * server-only loaders and render — so Apollo's `InMemoryCache`/`useQuery`
- * reactivity is dead weight, and a shared cache on a stateless multi-tenant
- * edge worker is a cross-tenant hazard. This helper carries only the
- * Foir-specific transport concerns (auth header, preview schema channel,
- * error shape). Consumers on a GraphQL client (Apollo / urql / react-query /
- * graphql-request) use the generated `TypedDocumentNode`s directly with their
- * own client and replicate the two Foir-specific headers below — the
- * `x-api-key` and, in preview, `X-Foir-Schema-Channel: draft`.
- *
- * Deduplicates the hand-copied `lib/foir/client.ts` that shipped identically
- * across the Foir storefronts.
- */
-
-interface FoirEnv {
-    PLATFORM_API_URL?: string;
-    PLATFORM_API_KEY?: string;
-    PLATFORM_PREVIEW_API_KEY?: string;
-    FOIR_PREVIEW?: string;
-}
-
-/**
- * Foir customer auth — framework-agnostic flows, token lifecycle, and guards.
- *
- * Session I/O is injected via {@link SessionAdapter} (no Hydrogen/React-Router
- * coupling). Pre-login flows authenticate with the project `x-api-key`;
- * post-login reads add the customer bearer. The project-specific profile (e.g.
- * `isAdmin`) is resolved by a consumer-supplied `resolveUser` — the SDK never
- * hardcodes the per-project customer profile shape.
- */
-
-/** The customer identity carried by an auth result. */
-interface FoirCustomer {
-    id: string;
-    email: string;
-}
-/**
- * Injected session store. Methods may be sync or async so consumers can plug
- * in a cookie session (Hydrogen/Remix), a KV store, etc.
- */
-interface SessionAdapter {
-    get(key: string): string | null | undefined | Promise<string | null | undefined>;
-    set(key: string, value: string): void | Promise<void>;
-    unset(key: string): void | Promise<void>;
-}
-
-/**
- * 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`.
- */
-interface FoirCookieStore {
-    get(name: string): {
-        value: string;
-    } | undefined;
-    set(name: string, value: string, options?: Record<string, unknown>): void;
-    delete(name: string): void;
-}
-interface CookieAdapterOptions {
-    /** Cookie attributes for writes, merged over the secure defaults. */
-    cookieOptions?: Record<string, unknown>;
-}
-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.
- */
-declare function createFoirCookieAdapter(store: FoirCookieStore, opts?: CookieAdapterOptions): SessionAdapter;
-
-/**
- * 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. */
-declare function getFoirSession(store: FoirCookieStore): Promise<FoirCustomer | null>;
-/** The current access token from the session cookies, or null. */
-declare function getFoirToken(store: FoirCookieStore): Promise<string | null>;
-/** Clear the session cookies (sign out). */
-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. */
-declare function foirSignInWithPassword({ env, store, email, password, cookieOptions, }: PasswordArgs): Promise<FoirCustomer>;
-/** Register a customer in a route handler; persists the session to cookies. */
-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. */
-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.
- */
-declare function completeFoirProviderLogin(opts: {
-    env: FoirEnv;
-    store: FoirCookieStore;
-    providerKey: string;
-    code?: string;
-    state?: string;
-    cookieOptions?: CookieAdapterOptions['cookieOptions'];
-}): Promise<FoirCustomer>;
-
-/**
- * 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`.
- */
-interface FoirMiddlewareRequest {
-    cookies: {
-        get(name: string): {
-            value: string;
-        } | undefined;
-    };
-    nextUrl: {
-        pathname: string;
-        search: string;
-    };
-    url: string;
-}
-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*'] };
- * ```
- */
-declare function createFoirMiddleware(config: FoirMiddlewareConfig): (request: FoirMiddlewareRequest) => Response | undefined;
-
-export { type CookieAdapterOptions, type FoirCookieStore, type FoirCustomer, type FoirEnv, type FoirMiddlewareConfig, type FoirMiddlewareRequest, type SessionAdapter, completeFoirProviderLogin, createFoirCookieAdapter, createFoirMiddleware, foirCookieName, foirRegisterWithPassword, foirSignInWithOtp, foirSignInWithPassword, foirSignOut, getFoirSession, getFoirToken };