@foir/sdk 0.5.0 → 0.8.0

package/dist/auth.d.ts

@@ -1,382 +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;
-}
-
-/**
- * Foir customer-auth GraphQL operations + result types.
- *
- * These are PLATFORM-STABLE primitives — `customerLogin`/`customerRegister`/
- * `customerRefreshToken`/OTP/provider login are fixed-shape operations served
- * by api-public for every project (gated per-project by the password/OTP/
- * provider flags, but identical in shape when present). Unlike per-project
- * model types, they don't vary by configured models, so the SDK owns the
- * documents directly rather than relying on the consumer's codegen.
- *
- * The project-specific customer PROFILE (e.g. `myProfile.isAdmin`) is NOT here
- * — that shape varies per project, so it stays consumer-injected (see
- * `requireAuth`'s `resolveUser`).
- */
-
-/** The common auth result every login/register/refresh mutation returns. */
-interface CustomerAuthResult {
-    token: string;
-    refreshToken: string;
-    customerId: string;
-    email: string;
-}
-/** Result of initiating a provider login — a redirect URL or an inline token. */
-interface ProviderLoginResult {
-    /** OAuth/OIDC authorization URL to redirect the user to (redirect flows). */
-    redirectUrl: string | null;
-    /** Inline access token (non-redirect provider flows). */
-    token: string | null;
-}
-/** A configured auth provider, as exposed to unauthenticated callers. */
-interface AuthProviderPublic {
-    key: string;
-    name: string;
-    /** OAUTH2 | TOKEN_SSO | SAML | OIDC | EXTERNAL */
-    type: string;
-    isDefault: boolean | null;
-}
-interface ProviderLoginInput {
-    providerKey: string;
-    email?: string;
-    returnTo?: string;
-    /** Override the provider's default redirect_uri (must be allow-listed). */
-    redirectUri?: string;
-}
-interface ProviderCallbackInput {
-    providerKey: string;
-    code?: string;
-    state?: string;
-    email?: string;
-    idToken?: string;
-}
-interface ProviderOTPVerifyInput {
-    providerKey: string;
-    email: string;
-    otp: string;
-}
-declare const CustomerLoginDocument: TypedDocumentNode<{
-    customerLogin: CustomerAuthResult;
-}, {
-    email: string;
-    password: string;
-}>;
-declare const CustomerRegisterDocument: TypedDocumentNode<{
-    customerRegister: CustomerAuthResult;
-}, {
-    email: string;
-    password: string;
-}>;
-declare const CustomerRefreshTokenDocument: TypedDocumentNode<{
-    customerRefreshToken: CustomerAuthResult;
-}, {
-    refreshToken: string;
-}>;
-declare const CustomerRequestOTPDocument: TypedDocumentNode<{
-    customerRequestOTP: boolean;
-}, {
-    email: string;
-}>;
-declare const CustomerLoginOTPDocument: TypedDocumentNode<{
-    customerLoginOTP: CustomerAuthResult;
-}, {
-    email: string;
-    otp: string;
-}>;
-declare const CustomerLoginWithProviderDocument: TypedDocumentNode<{
-    customerLoginWithProvider: ProviderLoginResult;
-}, {
-    input: ProviderLoginInput;
-}>;
-declare const CustomerProviderCallbackDocument: TypedDocumentNode<{
-    customerProviderCallback: CustomerAuthResult;
-}, {
-    input: ProviderCallbackInput;
-}>;
-declare const CustomerProviderVerifyOTPDocument: TypedDocumentNode<{
-    customerProviderVerifyOTP: CustomerAuthResult;
-}, {
-    input: ProviderOTPVerifyInput;
-}>;
-declare const AuthProvidersDocument: TypedDocumentNode<{
-    authProviders: AuthProviderPublic[];
-}, Record<string, never>>;
-
-/**
- * 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.
- */
-
-/** An access token + its rotating refresh token. */
-interface FoirAuthTokens {
-    token: string;
-    refreshToken: string;
-}
-/** The customer identity carried by an auth result. */
-interface FoirCustomer {
-    id: string;
-    email: string;
-}
-/** The resolved customer for a guarded surface. */
-interface FoirUser {
-    id: string;
-    email: string;
-    isAdmin: boolean;
-}
-/**
- * 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>;
-}
-/** Login with email + password. Requires the project to have passwords enabled. */
-declare function customerLogin(env: FoirEnv, vars: {
-    email: string;
-    password: string;
-}): Promise<CustomerAuthResult>;
-/** Register a new customer with email + password. */
-declare function customerRegister(env: FoirEnv, vars: {
-    email: string;
-    password: string;
-}): Promise<CustomerAuthResult>;
-/** Request a one-time password be emailed to the customer. */
-declare function customerRequestOTP(env: FoirEnv, email: string): Promise<boolean>;
-/** Complete an OTP login. */
-declare function customerLoginOTP(env: FoirEnv, vars: {
-    email: string;
-    otp: string;
-}): Promise<CustomerAuthResult>;
-/** Rotate an access token using a refresh token. */
-declare function customerRefreshToken(env: FoirEnv, refreshToken: string): Promise<CustomerAuthResult>;
-/**
- * Initiate provider (OAuth/OIDC) login — returns a `redirectUrl` to send the
- * user to, or an inline `token` for non-redirect providers.
- */
-declare function customerLoginWithProvider(env: FoirEnv, input: ProviderLoginInput): Promise<ProviderLoginResult>;
-/** Complete a provider login from the OAuth callback (`code`/`state`). */
-declare function customerProviderCallback(env: FoirEnv, input: ProviderCallbackInput): Promise<CustomerAuthResult>;
-/** Verify an OTP issued by an external provider. */
-declare function customerProviderVerifyOTP(env: FoirEnv, input: ProviderOTPVerifyInput): Promise<CustomerAuthResult>;
-/** List the project's configured auth providers (for a login UI). */
-declare function getAuthProviders(env: FoirEnv): Promise<AuthProviderPublic[]>;
-/** Persist an auth result to the session; returns the customer identity. */
-declare function saveSession(adapter: SessionAdapter, result: CustomerAuthResult): Promise<FoirCustomer>;
-/** Clear all Foir auth keys from the session. */
-declare function clearSession(adapter: SessionAdapter): Promise<void>;
-/** Read the stored access token (null when signed out). */
-declare function getSessionToken(adapter: SessionAdapter): Promise<string | null>;
-/** Read the stored customer identity (null when signed out). */
-declare function getSessionCustomer(adapter: SessionAdapter): Promise<FoirCustomer | null>;
-/** Login with email + password and persist the session. */
-declare function loginWithPassword(adapter: SessionAdapter, env: FoirEnv, vars: {
-    email: string;
-    password: string;
-}): Promise<FoirCustomer>;
-/** Register with email + password and persist the session. */
-declare function registerWithPassword(adapter: SessionAdapter, env: FoirEnv, vars: {
-    email: string;
-    password: string;
-}): Promise<FoirCustomer>;
-/** Complete an OTP login and persist the session. */
-declare function loginWithOTP(adapter: SessionAdapter, env: FoirEnv, vars: {
-    email: string;
-    otp: string;
-}): Promise<FoirCustomer>;
-/**
- * Refresh the access token from the stored refresh token, persisting the
- * rotated pair. Returns the new tokens, or null when there's no refresh token
- * or the refresh fails (the session is cleared in that case).
- */
-declare function refreshSession(adapter: SessionAdapter, env: FoirEnv): Promise<FoirAuthTokens | null>;
-/**
- * Run a bearer-authed GraphQL operation with refresh-with-retry: uses the
- * stored access token, and on a 401-shaped failure (rejected/expired bearer)
- * attempts a single token refresh and retries once. Any other error — network
- * blips, server errors, validation — propagates without a retry so transient
- * mutation failures can't be duplicated. Throws the original error if there's
- * no refresh path.
- */
-declare function authedRequest<TData, TVariables>(adapter: SessionAdapter, env: FoirEnv, document: TypedDocumentNode<TData, TVariables>, variables?: TVariables): Promise<TData>;
-interface RequireAuthOptions {
-    /**
-     * Resolve the full {@link FoirUser} (including the project-specific
-     * `isAdmin`) from the session identity. Typically runs the project's
-     * `myProfile` query via {@link authedRequest}. Defaults to `isAdmin: false`.
-     */
-    resolveUser?: (ctx: {
-        token: string;
-        customer: FoirCustomer;
-    }) => FoirUser | Promise<FoirUser>;
-    /**
-     * Called when there's no valid session — throw your framework's redirect
-     * (e.g. `throw redirect(loginUrl)`). Must not return.
-     */
-    onUnauthenticated: () => never | Promise<never>;
-}
-/**
- * Require a signed-in customer. Resolves the {@link FoirUser} via
- * `resolveUser` (or a minimal identity), or invokes `onUnauthenticated` when
- * there's no session.
- */
-declare function requireAuth(adapter: SessionAdapter, options: RequireAuthOptions): Promise<FoirUser>;
-interface RequireAdminOptions extends RequireAuthOptions {
-    /** Called when the user is authenticated but not an admin. Must not return. */
-    onForbidden: () => never | Promise<never>;
-}
-/** Require a signed-in customer who is also an admin. */
-declare function requireAdmin(adapter: SessionAdapter, options: RequireAdminOptions): Promise<FoirUser>;
-
-/**
- * Hosted-login bridge — for storefronts that delegate sign-in to a Foir
- * white-label front door (the `customerLoginWithFoir` flow) instead of
- * rendering their own login UI.
- *
- * The front door sets a first-party session cookie on the registrable domain;
- * because that domain is shared, the cookie reaches the storefront, which
- * exchanges it server-side for a short-lived customer bearer + identity. The
- * cookie is the durable credential (re-exchanged on bearer expiry) — there's
- * no separate refresh token in this flow.
- *
- * Every URL/cookie/path is CONFIG, not a constant, so a domain restructure
- * is a config change, not a code change.
- */
-interface HostedLoginConfig {
-    /** White-label front-door origin, e.g. `https://login.example.com`. */
-    loginOrigin: string;
-    /** Session cookie name set on the registrable domain. Default `foir_customer_session`. */
-    cookieName?: string;
-    /** Session-exchange path on the front door. Default `/session/token`. */
-    sessionPath?: string;
-}
-/**
- * Build the redirect URL to the hosted front door, forwarding a best-effort
- * absolute `returnTo` (honoured if the front door supports it).
- */
-declare function hostedLoginUrl(config: HostedLoginConfig, returnTo?: string): string;
-/** The identity + bearer returned by a successful hosted-session exchange. */
-interface HostedSession {
-    token: string;
-    customerId: string;
-    email: string;
-}
-/**
- * Exchange the hosted-login cookie on an incoming request for a customer
- * bearer + identity (server-to-server: forwards the cookie to the front
- * door's session endpoint with the CSRF header). Returns null when there's no
- * cookie or it's expired/revoked.
- */
-declare function fetchHostedSession(request: Request, config: HostedLoginConfig): Promise<HostedSession | null>;
-
-/**
- * Foir-hosted first-party sessions, from the browser — the model for a
- * backend-less SPA (Vite, CRA, a static site) that wants no tokens in JS.
- *
- * The sibling `fetchHostedSession` in ./hosted does the same exchange from a
- * SERVER: it reads the cookie off an incoming request and forwards it by hand.
- * A browser cannot set a `Cookie` header, so that function is unusable from an
- * SPA by construction. This one lets the browser send the cookie the only way it
- * can — `credentials: 'include'` — and keeps the resulting bearer in memory.
- *
- * How the pieces divide:
- *
- *   cookie  — long-lived (30d), HttpOnly, first-party on your registrable
- *             domain, set by Foir when hosted login finalizes. JS cannot read
- *             it, so XSS cannot exfiltrate it.
- *   bearer  — 15 minutes, held in a closure here. Never written to
- *             localStorage/sessionStorage/IndexedDB, never in a cookie of ours.
- *
- * There is no refresh token in this flow. Re-exchanging the cookie IS the
- * refresh, which is why nothing here needs rotation or reuse-detection: the
- * durable credential is an opaque server-side session handle, revocable at any
- * time from the admin panel or `signOut()`.
- *
- * REQUIRES a verified custom login domain that shares a registrable domain with
- * your app (app.acme.com + login.acme.com). That is what makes the cookie
- * first-party and lets `SameSite=Lax` send it. The same endpoints exist on
- * api.foir.dev but a browser cannot reach them there — the cookie would be
- * cross-site, and that CORS surface deliberately refuses credentials.
- */
-interface FoirSessionConfig {
-    /**
-     * Your verified custom login domain, e.g. `https://login.acme.com`. Must share
-     * a registrable domain with the app calling it.
-     */
-    loginOrigin: string;
-    /** Session-exchange path. Default `/session/token`. */
-    sessionPath?: string;
-    /** Logout path. Default `/session/logout`. */
-    logoutPath?: string;
-    /** Seconds before expiry to re-exchange. Default 60. */
-    refreshSkewSeconds?: number;
-    /**
-     * Called when the session goes away — the cookie expired, was revoked, or
-     * `signOut()` ran. Use it to redirect to `signInUrl()`.
-     */
-    onSignOut?: () => void;
-}
-/** The identity behind the current session. */
-interface FoirSessionUser {
-    customerId: string;
-    email: string;
-}
-interface FoirSessionClient {
-    /**
-     * The current access token, exchanging or re-exchanging the cookie as needed.
-     * Null when there is no session. Concurrent callers share one in-flight
-     * exchange. Call this before each API request — do not cache the result.
-     */
-    getToken(): Promise<string | null>;
-    /** The signed-in customer, or null. Exchanges if the session isn't loaded yet. */
-    getUser(): Promise<FoirSessionUser | null>;
-    /** Revoke the session server-side and clear the cookie. Idempotent. */
-    signOut(): Promise<void>;
-    /** Where to send the browser to sign in. */
-    signInUrl(returnTo?: string): string;
-    /** Observe session changes. Returns an unsubscribe function. */
-    subscribe(listener: (user: FoirSessionUser | null) => void): () => void;
-    /** Cancel the refresh timer. Call on unmount. */
-    destroy(): void;
-}
-/**
- * Create a session client. Safe to call during SSR — it does nothing until a
- * method is invoked, and `getToken()` on the server returns null rather than
- * throwing (there is no cookie jar to draw on).
- */
-declare function createFoirSessionClient(config: FoirSessionConfig): FoirSessionClient;
-
-export { type AuthProviderPublic, AuthProvidersDocument, type CustomerAuthResult, CustomerLoginDocument, CustomerLoginOTPDocument, CustomerLoginWithProviderDocument, CustomerProviderCallbackDocument, CustomerProviderVerifyOTPDocument, CustomerRefreshTokenDocument, CustomerRegisterDocument, CustomerRequestOTPDocument, type FoirAuthTokens, type FoirCustomer, type FoirSessionClient, type FoirSessionConfig, type FoirSessionUser, type FoirUser, type HostedLoginConfig, type HostedSession, type ProviderCallbackInput, type ProviderLoginInput, type ProviderLoginResult, type ProviderOTPVerifyInput, type RequireAdminOptions, type RequireAuthOptions, type SessionAdapter, authedRequest, clearSession, createFoirSessionClient, customerLogin, customerLoginOTP, customerLoginWithProvider, customerProviderCallback, customerProviderVerifyOTP, customerRefreshToken, customerRegister, customerRequestOTP, fetchHostedSession, getAuthProviders, getSessionCustomer, getSessionToken, hostedLoginUrl, loginWithOTP, loginWithPassword, refreshSession, registerWithPassword, requireAdmin, requireAuth, saveSession };

package/dist/chunk-ADO5FJNM.js

@@ -1,30 +0,0 @@
-// src/codegen/shared.ts
-import { isUnionType } from "graphql";
-var DEFAULT_UNIONS = ["Block"];
-var DEFAULT_GRAPHQL_IMPORT = "./graphql";
-var DEFAULT_SDK_IMPORT = "@foir/sdk/content";
-function collectBlockMembers(schema, unionNames) {
-  const members = /* @__PURE__ */ new Set();
-  const missing = [];
-  for (const name of unionNames) {
-    const type = schema.getType(name);
-    if (!type || !isUnionType(type)) {
-      missing.push(name);
-      continue;
-    }
-    for (const member of type.getTypes()) members.add(member.name);
-  }
-  if (members.size === 0) {
-    throw new Error(
-      `[foir codegen] no union members found. Looked for union(s): ${unionNames.join(", ")}` + (missing.length ? ` (not found or not a union: ${missing.join(", ")})` : "") + `. Run \`foir push\` and confirm the block union name.`
-    );
-  }
-  return [...members].sort();
-}
-
-export {
-  DEFAULT_UNIONS,
-  DEFAULT_GRAPHQL_IMPORT,
-  DEFAULT_SDK_IMPORT,
-  collectBlockMembers
-};

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 };