@foir/sdk 0.9.0 → 0.11.0

package/dist/data/transport.d.ts

@@ -13,6 +13,11 @@
  *   anything else — `sk_`, a customer bearer, a mutation, the draft channel
  *     → `POST /graphql` with the `x-api-key` header and the APQ body.
  *
+ *   a call made AS an operation, with its dispatch token
+ *     → `POST /graphql` with `X-Foir-Token` and the dispatch's `X-Foir-Context`,
+ *       and no `x-api-key`. Always this lane: the shared one takes its
+ *       credential from the URL, and a dispatch token has no key to put there.
+ *
  * All five conditions the server's shared-lane gate refuses on are evaluated
  * HERE, locally: this code is constructing the URL, it can read the key prefix,
  * it knows whether a bearer resolved, the manifest told it whether the op is a
@@ -55,10 +60,11 @@
  * with more force here — this client is per-credential, so anything cached
  * across instances is cached across tenants.
  */
-import { type FoirTokenProvider } from '../transport/foir-http';
+import { FoirRequestError, type FoirTokenProvider } from '../transport/foir-http';
 import type { FoirDocumentPlan, FoirNamespaceSelections, FoirSelections, FoirSelectionUnions } from './document';
 import type { FoirSchemaDefinition } from './schema';
 import type { FoirSubjectRegistry } from './subjects';
+import type { FoirManifestSubscription } from './manifest';
 import type { FoirReconnectPolicy, FoirWebSocketFactory } from './ws-transport';
 /**
  * `foir.generated.ts`, whole — the shape a namespace import of it has.
@@ -83,18 +89,103 @@ import type { FoirReconnectPolicy, FoirWebSocketFactory } from './ws-transport';
  * Its runtime value is `undefined` by design and nothing reads it.
  */
 export interface FoirGeneratedModule<S extends FoirSchemaDefinition = FoirSchemaDefinition> {
-    /** `foirSchemaVersion` — the manifest version these types came from. Drives the drift check. */
-    readonly foirSchemaVersion: number;
+    /**
+     * `foirSurfaceVersion`: the surface these types were generated from, a hash
+     * over exactly the parts of the manifest `foir types` reads. Drives the drift
+     * check, which compares it with the one the server is serving now.
+     */
+    readonly foirSurfaceVersion: string;
+    /**
+     * `foirSurfaceHashes`: the components that version is folded from, keyed as
+     * the manifest keys them (`models.<key>`, `namespaces.<name>`, …). What lets a
+     * drift name the models that moved rather than just say something did.
+     */
+    readonly foirSurfaceHashes: Readonly<Record<string, string>>;
     /** `foirSelections` — one entry per model, in the printer's own input shape. */
     readonly foirSelections: FoirSelections;
     /** `foirNamespaceSelections` — the same, per namespace op. */
     readonly foirNamespaceSelections: FoirNamespaceSelections;
     /** `foirSelectionUnions` — each union expanded once; a tree references one by name. */
     readonly foirSelectionUnions: FoirSelectionUnions;
+    /**
+     * `foirSubscriptions` — the Subscription root fields this credential reaches,
+     * with their resolved payload selections. Lets a subscribing client print its
+     * document from the module instead of fetching `GET /v1/manifest`.
+     *
+     * OPTIONAL, and deliberately not in `GENERATED_EXPORTS`. That list is checked
+     * strictly — a module missing any of it is refused as stale or hand-assembled
+     * — so requiring this one would break every client built against a module
+     * generated before it existed, at construction, for a round trip they were
+     * already happily paying. Absent means "fetch the manifest", which is exactly
+     * what those clients do today.
+     */
+    readonly foirSubscriptions?: readonly FoirManifestSubscription[];
     /** Type carrier for `FoirSchema`. Never read: its runtime value is `undefined`. */
     readonly foirSchemaType: S;
+    /**
+     * `foirCredential`: present when the module was generated for an operation
+     * (`foir types --operation <key>`), naming it. Its types are the surface that
+     * operation's dispatch token is served, so the module is for a client built
+     * from that token and for no other: a dispatch client requires it, and a key
+     * client refuses it. Absent from a module generated for a key.
+     */
+    readonly foirCredential?: FoirOperationCredential;
+}
+/**
+ * What a module `foir types --operation <key>` generated says about itself:
+ * the operation whose dispatch token its types describe.
+ */
+export interface FoirOperationCredential {
+    readonly operation: string;
 }
-export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDefinition> {
+/** A module generated for an api key: the kind a key client takes. */
+export type FoirKeyGeneratedModule<S extends FoirSchemaDefinition = FoirSchemaDefinition> = FoirGeneratedModule<S> & {
+    readonly foirCredential?: undefined;
+};
+/** A module generated for an operation: the kind a dispatch client takes. */
+export type FoirOperationGeneratedModule<S extends FoirSchemaDefinition = FoirSchemaDefinition> = FoirGeneratedModule<S> & {
+    readonly foirCredential: FoirOperationCredential;
+};
+/**
+ * The credential of a client built inside an operation endpoint: the dispatch
+ * token the platform handed it.
+ *
+ * ```ts
+ * const { dispatch } = await requireScopedToken(request, { expectedProjectId });
+ * const foir = createFoirClient({ apiUrl, dispatch, generated });
+ * ```
+ *
+ * The endpoint calls Foir AS the operation, with the capabilities the operation
+ * declared, and holds no key of its own. api-public accepts the token as a
+ * caller in its own right: it builds the schema overlay from the token's
+ * capabilities, and it reads the organization and the customer from the
+ * token's claims. So nothing a key client configures beside its key
+ * (`bearerToken`, `orgId`, `channel`) means anything here, and none of it is
+ * accepted.
+ *
+ * `requireScopedToken` returns one of these, built from the token it verified.
+ * Build one by hand only when the token reaches you some other way.
+ */
+export interface FoirDispatchCredential {
+    /**
+     * The dispatch token, sent as `X-Foir-Token`. Resolved before every request,
+     * so a caller holding a refreshed token hands the client the current one
+     * rather than the one it was built with. A provider that yields nothing fails
+     * the request: there is no other credential to fall back to.
+     */
+    token: FoirTokenProvider;
+    /**
+     * The dispatch's `X-Foir-Context` header, forwarded as it arrived so the
+     * requests the operation makes carry the run's correlation metadata. Pass
+     * `request.headers.get('X-Foir-Context')` as it is; absent is fine.
+     */
+    context?: string | null;
+}
+/**
+ * A client that calls Foir with an api key: a storefront's `pk_`, a server's
+ * `sk_`, optionally for a signed-in customer.
+ */
+export interface FoirKeyClientConfig<S extends FoirSchemaDefinition = FoirSchemaDefinition> {
     /**
      * Foir public API origin, e.g. `https://api.foir.dev`.
      *
@@ -105,10 +196,13 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
     apiUrl: string;
     /** `pk_…` or `sk_…`. The manifest, and therefore the generated types, are shaped by it. */
     apiKey: string;
+    /** A key client has no dispatch token; see {@link FoirDispatchClientConfig}. */
+    dispatch?: never;
     /**
-     * Read the draft schema channel (`X-Foir-Schema-Channel: draft`). Needs a
-     * `sk_` key with `drafts:read`; the header is ignored under public keys.
-     * Defaults to `'published'`.
+     * Read the draft schema channel (`X-Foir-Schema-Channel: draft`). Needs a key
+     * holding `drafts:read`: a preview environment's own `pk_`, or an `sk_`. A
+     * public key without it is served the published copy; a secret key without
+     * it is refused. Defaults to `'published'`.
      */
     channel?: 'published' | 'draft';
     /**
@@ -117,6 +211,68 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      * per-request; a bare string is used as-is.
      */
     bearerToken?: string | FoirTokenProvider;
+    /**
+     * The organization every request from this client acts in, sent as
+     * `X-Org-Id`.
+     *
+     * For the PROJECT credential of a product built on organizations: the
+     * back-office, or the multi-tenant app that has just resolved
+     * `<sub>.theapp.com` to an organization and now acts inside it. The server
+     * resolves the id against the credential's OWN project — an unknown,
+     * suspended or another project's organization all answer `NOT_FOUND`, so
+     * nothing enumerates — and binds the request to it: reads are confined to
+     * that organization plus the project-shared tier, writes are stamped into
+     * it, and an organization-owned record created without an explicit owner
+     * belongs to it.
+     *
+     * ⚠️ IT NAMES A SUBTREE, NOT A NODE. Organizations nest, and reach runs
+     * downward: name a reseller and the reads include every client beneath it as
+     * well as the reseller's own rows. Name the client and you get the client
+     * and nothing above or beside it. So the id to send is the NARROWEST one
+     * that covers what this request is about — sending the group when you meant
+     * one branch is not an error anywhere, it is a wider answer that looks
+     * right.
+     *
+     * A credential already confined to an organization may only name its own
+     * (`PERMISSION_DENIED` otherwise), so this cannot steer an organization key
+     * elsewhere. And a request that also carries a customer bearer is refused
+     * unless that customer stands in the named organization. The storefront
+     * pattern is still the confined credential, one per organization; this is
+     * for the side of the product that holds the project key and has to choose.
+     *
+     * Routing: a request naming an organization always goes to the origin
+     * endpoint, never the shared one. The answer is one organization's, and a
+     * cache in front of the caller keys by URL, where this header does not
+     * appear.
+     */
+    orgId?: string;
+    /**
+     * The organization every request from this client acts in, named by the
+     * address of the page it is for, sent as `X-Org-Url`.
+     *
+     * For an app that serves many organizations from its own addresses: a path
+     * per organization (`saasapp.com/soho`), a subdomain each, or a domain an
+     * organization brought. Pass the page URL and the server finds the
+     * organization whose registered address (its app base URL, or a verified
+     * custom domain bound to it) is the longest prefix of that URL at a
+     * path-segment boundary, so `saasapp.com/soho` answers for `/soho/menu` and
+     * never for `/sohonews`. It works with the publishable key the page already
+     * ships.
+     *
+     * ```ts
+     * const foir = createFoirClient({ apiUrl, apiKey, generated, orgUrl: window.location.href });
+     * ```
+     *
+     * It is `orgId` by another spelling and bounded the same way: a URL no
+     * organization's address covers answers `NOT_FOUND` exactly as an unknown id
+     * does, a credential confined to an organization is answered about that
+     * organization alone, and the organization is a selection rather than
+     * authority. Sent with `orgId`, the two must name the same organization.
+     * `resolveOrganizationAddress(url)` answers the same id up front.
+     *
+     * Routing: always the origin endpoint, for the reason `orgId` is.
+     */
+    orgUrl?: string;
     /**
      * The generated module, whole — **the documented way to wire a client**.
      *
@@ -125,8 +281,8 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      * const foir = createFoirClient({ apiUrl, apiKey, generated });
      * ```
      *
-     * It supplies `schemaVersion`, `selections`, `namespaceSelections` and
-     * `selectionUnions` in one member, and carries `FoirSchema` with it so the
+     * It supplies `surfaceVersion`, `surfaceHashes`, `selections`,
+     * `namespaceSelections` and `selectionUnions` in one member, and carries `FoirSchema` with it so the
      * type parameter is inferred rather than restated. An artifact added to
      * `foir types` later then costs a call site nothing.
      *
@@ -139,8 +295,12 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      * Omitting `generated` AND `selections` asks for the manifest fallback, which
      * is supported, announced (see `announceManifestFallback`) and never reached
      * by accident.
+     *
+     * A module generated for an operation (`foir types --operation`) is refused
+     * here: its types are what that operation's dispatch token is served, not
+     * what this key is.
      */
-    generated?: FoirGeneratedModule<S>;
+    generated?: FoirKeyGeneratedModule<S>;
     /**
      * The runtime half of `foir.generated.ts` — `foirSelections`, the resolved
      * complete-by-default selection per model.
@@ -187,7 +347,11 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      * `subjects.add(...)`.
      */
     subjects?: FoirSubjectRegistry;
-    /** Extra headers, applied last so they can override the ones above. */
+    /**
+     * Extra headers, applied last so they can override the ones above. A client
+     * built from a dispatch token refuses a credential header here (`x-api-key`,
+     * `Authorization`, `X-Foir-Token`, `X-Foir-Context`).
+     */
     headers?: Readonly<Record<string, string>>;
     /**
      * `fetch` implementation. Defaults to `globalThis.fetch`. Injectable for
@@ -201,15 +365,69 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      */
     requestInit?: Omit<RequestInit, 'method' | 'headers' | 'body'>;
     /**
-     * `foirSchemaVersion` from the generated module. When set, the client
-     * compares it against the server's manifest once and warns on mismatch.
-     * Carried by `generated`; set it here only to override that.
+     * `foirSurfaceVersion` from the generated module. When set, the client
+     * compares it against the surface the server is serving, once, and reports
+     * drift when they differ. Carried by `generated`; set it here only to
+     * override that.
      */
-    schemaVersion?: number;
-    /** Set `false` to suppress the drift check even when `schemaVersion` is set. */
+    surfaceVersion?: string;
+    /**
+     * `foirSurfaceHashes` from the generated module, so a drift can name what
+     * moved. Carried by `generated`; set it here only to override that.
+     */
+    surfaceHashes?: Readonly<Record<string, string>>;
+    /**
+     * Subscription descriptors, from the generated module's `foirSubscriptions`.
+     *
+     * Carried by `generated`; set it here only to override that. When present a
+     * subscribing client prints from these and never fetches `GET /v1/manifest`;
+     * when absent it fetches once, as it always has.
+     */
+    subscriptions?: readonly FoirManifestSubscription[];
+    /** Set `false` to suppress the drift check even when `surfaceVersion` is set. */
     checkSchemaDrift?: boolean;
     /** Called instead of `console.warn` when drift is detected. */
     onSchemaDrift?: (drift: FoirSchemaDrift) => void;
+    /**
+     * Refuse typed calls once drift is detected, instead of serving the stale
+     * shape. **On by default**; pass `false` to opt out.
+     *
+     * The asymmetry this closes: an unknown ARGUMENT is refused client-side
+     * before the server sees it, while a field the server has and the generated
+     * selection does not is simply not requested. The second is the common case
+     * when a schema evolves, and it surfaces as absent data rather than as a
+     * tooling problem — so it is the one that needs to be loud.
+     *
+     * It is the default rather than an opt-in because the thing it prevents is
+     * SILENT. An opt-in guard against a silent failure only protects the people
+     * who already suspected the failure existed, and the warning it replaces is
+     * one more line to scroll past.
+     *
+     * Two things it deliberately does not do.
+     *
+     * It does not fail the FIRST call. Drift is only known once the manifest
+     * comes back, and that request is made off the response path after a call has
+     * already been served. A client that refused retroactively would have to
+     * block every first call on a second round trip, which is the cost the
+     * warning was designed to avoid.
+     *
+     * It does not touch `raw`. A hand-written document asks for exactly the
+     * fields it names, so it cannot silently omit one — raw is immune to this
+     * class of bug by construction, and refusing it would punish the escape
+     * hatch people reach for precisely because it is immune.
+     *
+     * Turning it off is never the remedy for a drift. The version it compares
+     * is the SURFACE the types were generated from, which moves only when
+     * regenerating would write a different file, so every drift it reports is a
+     * real one and the fix is `foir types`. The opt-out exists for an app that
+     * knowingly ships a stale module for a while, and it says so at the call
+     * site, where a reader can see it:
+     *
+     * ```ts
+     * createFoirClient({ strictSchemaDrift: false })  // serve stale, warn only
+     * ```
+     */
+    strictSchemaDrift?: boolean;
     /**
      * Set `false` to silence the one-line notice a client prints when it is built
      * with neither `generated` nor `selections` and will therefore read its
@@ -260,12 +478,86 @@ export interface FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDef
      */
     connectionParams?: () => Record<string, string> | Promise<Record<string, string>>;
 }
+/**
+ * The options that belong to a key: the key itself, what it is presented with
+ * (a customer bearer, an organization, a channel), and the subscription socket,
+ * which only a key can open.
+ */
+type FoirKeySideOption = 'apiKey' | 'dispatch' | 'channel' | 'bearerToken' | 'orgId' | 'orgUrl' | 'wsUrl' | 'webSocketImpl' | 'reconnect' | 'connectionParams';
+/**
+ * A client that calls Foir AS an operation, from inside the endpoint the
+ * operation dispatched to. See {@link FoirDispatchCredential}.
+ *
+ * Everything a key client takes except the key-side options, which are typed
+ * `never` rather than left out, so passing one is a compile error that names
+ * it. No `apiKey` above all: the dispatch token is the credential, and an
+ * endpoint that holds a key as well has become the server in the middle the
+ * operation exists to replace.
+ */
+export interface FoirDispatchClientConfig<S extends FoirSchemaDefinition = FoirSchemaDefinition> extends Omit<FoirKeyClientConfig<S>, FoirKeySideOption | 'generated'> {
+    /** The dispatch token this endpoint was handed, and the dispatch's context header. */
+    dispatch: FoirDispatchCredential;
+    /**
+     * The module `foir types --operation <key>` generated for this operation.
+     * Required: its types are the surface this operation's token is served, and
+     * a module generated for a key would type calls the token is refused. A
+     * dispatch whose context names a different operation is refused too.
+     *
+     * ```ts
+     * // foir types --operation checkout --out src/checkout.generated.ts
+     * import * as generated from './checkout.generated';
+     * const foir = createFoirClient({ apiUrl, dispatch, generated });
+     * ```
+     */
+    generated: FoirOperationGeneratedModule<S>;
+    apiKey?: never;
+    channel?: never;
+    bearerToken?: never;
+    orgId?: never;
+    orgUrl?: never;
+    wsUrl?: never;
+    webSocketImpl?: never;
+    reconnect?: never;
+    connectionParams?: never;
+}
+/**
+ * How a data client is configured: with an api key, or with an operation's
+ * dispatch token. Exactly one of the two. They are different actors, and there
+ * is no configuration that accepts either.
+ */
+export type FoirClientConfig<S extends FoirSchemaDefinition = FoirSchemaDefinition> = FoirKeyClientConfig<S> | FoirDispatchClientConfig<S>;
+/**
+ * The credential and transport half of a client config, which is everything a
+ * request reads. A manifest fetch takes this rather than a whole client config:
+ * what it asks for does not depend on a generated module, and a dispatch token
+ * asks for its own surface before any module exists.
+ */
+export type FoirRequestConfig = Omit<FoirKeyClientConfig, 'generated'> | Omit<FoirDispatchClientConfig, 'generated'>;
 export interface FoirSchemaDrift {
-    /** Manifest version the local types were generated from. */
-    generated: number;
-    /** Manifest version the server is serving now. */
-    server: number;
+    /** The surface version the local types were generated from. */
+    generated: string;
+    /** The surface version the server is serving now. */
+    server: string;
     channel: string;
+    /**
+     * What moved, as the manifest keys its components: `models.<key>`,
+     * `namespaces.<name>`, `selectionUnions.<name>`, `subscriptions`,
+     * `composedFor`. A component added or removed since generation is listed
+     * too. Empty only when the module was wired without `surfaceHashes`.
+     */
+    changed: readonly string[];
+}
+/**
+ * Thrown by a typed call under `strictSchemaDrift` once drift is detected.
+ *
+ * A subclass rather than a plain `FoirRequestError` so an app can tell "your
+ * generated module is stale" from "this request failed", which want different
+ * handling: the first is fixed by a command on the developer's machine and
+ * will fail identically until they run it, the second is worth a retry.
+ */
+export declare class FoirSchemaDriftError extends FoirRequestError {
+    readonly drift: FoirSchemaDrift;
+    constructor(message: string, drift: FoirSchemaDrift);
 }
 /**
  * Build a `/v1/...` URL from whatever the caller put in `apiUrl`.
@@ -276,15 +568,46 @@ export interface FoirSchemaDrift {
  * than a re-export so `@foir/sdk/data`'s public surface is unchanged.
  */
 export declare function foirDataEndpoint(apiUrl: string, path: `/${string}`): string;
-/** Resolve `config.bearerToken`, whether it is a string, a function, or absent. */
-export declare function resolveBearerToken(config: Pick<FoirClientConfig, 'bearerToken'>): Promise<string | undefined>;
+/** One request's credential, resolved now. */
+export interface FoirResolvedAuth {
+    /** The headers the request carries, `extra` included. */
+    headers: Record<string, string>;
+    /**
+     * The key and the resolved bearer, when the credential is a key. Absent for a
+     * dispatch token, which has no key to put in a URL and so never takes the
+     * shared lane.
+     */
+    key?: {
+        apiKey: string;
+        bearerToken?: string;
+    };
+}
+/**
+ * The credential a request carries, resolved at the moment it is sent.
+ *
+ * The one place every transport (`/graphql`, `GET /v1/manifest`, the socket's
+ * `connection_init`) asks, so the three cannot drift into authenticating a
+ * client differently. Providers are called here, once per request, and not at
+ * construction.
+ */
+export declare function resolveFoirAuth(config: FoirRequestConfig): Promise<FoirResolvedAuth>;
+/**
+ * Refuse a config that names no credential, or two.
+ *
+ * The types already say this. It is checked again at runtime for a caller in
+ * plain JavaScript, or one who spread two configs together, because the
+ * failure it prevents is quiet: a client handed both a key and a dispatch token
+ * would send one and discard the other, and which actor made each request
+ * would depend on a precedence rule nobody chose.
+ */
+export declare function assertFoirCredential(config: FoirClientConfig): void;
 /** Which GraphQL endpoint a call is sent to. */
 export type FoirLane = 'shared' | 'origin';
 /**
  * Why a call did not take the shared lane. One name per condition the server's
  * gate refuses on, so a decision can be asserted rather than inferred.
  */
-export type FoirLaneReason = 'key' | 'bearer' | 'operation' | 'channel';
+export type FoirLaneReason = 'key' | 'bearer' | 'org' | 'operation' | 'channel' | 'floor';
 export interface FoirRouteDecision {
     lane: FoirLane;
     /** Set only on the origin lane: the first condition that ruled the shared one out. */
@@ -294,8 +617,21 @@ export interface FoirRouteInput {
     apiKey: string;
     /** The RESOLVED bearer, not the provider — a provider that yields null is not a bearer. */
     bearerToken?: string;
+    /** The organization the call acts in (`X-Org-Id`), when it names one. */
+    orgId?: string;
+    /** The page URL the call names its organization by (`X-Org-Url`), when it does. */
+    orgUrl?: string;
     mutation: boolean;
     channel?: 'published' | 'draft';
+    /**
+     * A write token from an earlier mutation, making this read a FLOORED one:
+     * serve a cached entry only if it resolved at or above the write's position.
+     *
+     * The token itself is opaque here — resolving it to a seq is the server's job
+     * and needs the event log. All this needs to know is that one is present,
+     * because that alone decides the lane.
+     */
+    writeToken?: string;
 }
 /**
  * Where this call goes.
@@ -322,4 +658,7 @@ export declare function executeFoirDocument<T>(config: FoirClientConfig, plan: F
  * what it gives up is the single-root-field unwrapping, because a document
  * written by hand may legitimately have several.
  */
-export declare function executeFoirRawDocument<T>(config: FoirClientConfig, document: string, mutation: boolean, variables?: Record<string, unknown>): Promise<T>;
+export declare function executeFoirRawDocument<T>(config: FoirClientConfig, document: string, mutation: boolean, variables?: Record<string, unknown>, options?: {
+    strict?: boolean;
+}): Promise<T>;
+export {};

package/dist/data/ws-transport.d.ts

@@ -41,9 +41,15 @@
  * `config.connectionParams`, which is a FUNCTION and is called on every
  * connect — so a short-lived credential is re-resolved on reconnect instead of
  * being replayed after it expired.
+ *
+ * An operation's dispatch token is not one of them. The server's
+ * `connection_init` authenticates a key, an admin token or a customer bearer
+ * and has no path for a dispatch token, so a client built from one is refused
+ * here, by name, rather than opening a socket the server will close as "Not
+ * authenticated".
  */
 import { FoirRequestError } from '../transport/foir-http';
-import { type FoirClientConfig } from './transport';
+import { type FoirRequestConfig } from './transport';
 /**
  * The slice of `WebSocket` this transport uses.
  *
@@ -143,7 +149,7 @@ export declare class FoirSocketTransport {
     private disposed;
     private keepAlive;
     private retryTimer;
-    constructor(config: FoirClientConfig);
+    constructor(config: FoirRequestConfig);
     /**
      * Start a subscription.
      *