@usequeek/app-sdk 0.6.2 → 0.7.0

package/dist/merchant-schema.js

@@ -8,4 +8,3 @@
  * Do not make direct changes to the file.
  */
 export {};
-//# sourceMappingURL=merchant-schema.js.map

package/dist/proxy.d.ts

@@ -10,7 +10,7 @@ import { type InstallationRecord, type InstallationStore } from "./store.js";
  *   sig = hex HMAC-SHA256 over
  *     path + "\n" + shop + "\n" + ts + "\n" + sorted(k=v&...) (sig excluded),
  *
- * where each pair is `rawurlencode(key)=rawurlencode(value)` and keys sort
+ * where each pair is `encode(key)=encode(value)` (RFC 3986 percent-encoding) and keys sort
  * byte-wise. The HMAC key is the FULL `whsec_…` string — no base64 decode
  * step (the single most common integration bug cannot happen here).
  *
@@ -38,7 +38,7 @@ export type ProxyQuery = Record<string, string | string[] | null | undefined>;
 export type ProxyFailure = "missing_params" | "stale_timestamp" | "missing_secret" | "signature_mismatch" | "unknown_installation" | "replayed";
 /**
  * The canonical string the MAC covers, exactly as Queek builds it (sig
- * excluded, keys byte-sorted, rawurlencoded pairs).
+ * excluded, keys byte-sorted, percent-encoded pairs).
  */
 export declare function buildProxyCanonicalString(path: string, params: Record<string, string>): string;
 /**
@@ -117,4 +117,3 @@ export type ProxyResponder = (verified: {
  * anything else answers 405.
  */
 export declare function handleProxyRequest(request: Request, options: ProxyRequestOptions, onVerified: ProxyResponder): Promise<Response>;
-//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.js

@@ -12,7 +12,7 @@ import { normalisePid } from "./store.js";
  *   sig = hex HMAC-SHA256 over
  *     path + "\n" + shop + "\n" + ts + "\n" + sorted(k=v&...) (sig excluded),
  *
- * where each pair is `rawurlencode(key)=rawurlencode(value)` and keys sort
+ * where each pair is `encode(key)=encode(value)` (RFC 3986 percent-encoding) and keys sort
  * byte-wise. The HMAC key is the FULL `whsec_…` string — no base64 decode
  * step (the single most common integration bug cannot happen here).
  *
@@ -34,13 +34,13 @@ export const PROXY_CUSTOMER_PARAM = "logged_in_customer_id";
 export const PROXY_KID_PARAM = "kid";
 /** Default allowed clock skew in seconds; the floor (60s) below applies regardless. */
 export const PROXY_MAX_SKEW_SECONDS = 300;
-/** RFC 3986 percent-encoding (PHP's `rawurlencode`): everything except `[A-Za-z0-9-_.~]` is `%XX` (upper-case hex). */
+/** RFC 3986 percent-encoding: everything except `[A-Za-z0-9-_.~]` is `%XX` (upper-case hex), the encoding Queek signs with. */
 function proxyEncode(value) {
     return encodeURIComponent(value).replace(/[!'()*]/g, (ch) => {
         return `%${ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
     });
 }
-/** Scalar query values as strings (PHP `strval` semantics): null/undefined become `""`, everything else stringifies. */
+/** Scalar query values as strings, as Queek's signer reads them: null becomes `""`, an array contributes its first value, everything else stringifies. `undefined` means absent. */
 function proxyString(value) {
     if (value === undefined)
         return undefined;
@@ -60,7 +60,7 @@ function normalizeQuery(query) {
 }
 /**
  * The canonical string the MAC covers, exactly as Queek builds it (sig
- * excluded, keys byte-sorted, rawurlencoded pairs).
+ * excluded, keys byte-sorted, percent-encoded pairs).
  */
 export function buildProxyCanonicalString(path, params) {
     const sorted = { ...params };
@@ -200,4 +200,3 @@ export async function handleProxyRequest(request, options, onVerified) {
     }
     return onVerified({ installation: verified.installation, params: verified.params });
 }
-//# sourceMappingURL=proxy.js.map

package/dist/react.d.ts

@@ -72,7 +72,15 @@ export interface QueekProviderProps {
      */
     expectSource?: unknown;
 }
+/**
+ * Owns the one bridge subscription for the embedded merchant page. Wrap the
+ * app root in it, then call `useQueek()` anywhere below.
+ *
+ * @example
+ * <QueekProvider dashboardOrigin="https://dashboard.usequeek.com" capabilities={["toast"]}>
+ *   <App />
+ * </QueekProvider>
+ */
 export declare function QueekProvider(props: QueekProviderProps): ReactNode;
 /** Bridge actions + live theme over the framework-free core. */
 export declare function useQueek(): QueekApi;
-//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -33,6 +33,15 @@ function resolveConfig(props, win) {
         expectSource: props.expectSource !== undefined ? props.expectSource : (win?.parent ?? undefined),
     };
 }
+/**
+ * Owns the one bridge subscription for the embedded merchant page. Wrap the
+ * app root in it, then call `useQueek()` anywhere below.
+ *
+ * @example
+ * <QueekProvider dashboardOrigin="https://dashboard.usequeek.com" capabilities={["toast"]}>
+ *   <App />
+ * </QueekProvider>
+ */
 export function QueekProvider(props) {
     const { dashboardOrigin, children, sdkVersion } = props;
     const win = useMemo(() => globalWindow(), []);
@@ -224,7 +233,7 @@ export function QueekProvider(props) {
 function useBridge() {
     const bridge = useContext(QueekBridgeContext);
     if (bridge === null) {
-        throw new Error("useQueek must be used inside <QueekProvider>");
+        throw new Error("useQueek must be called inside <QueekProvider>. Wrap the app root in <QueekProvider>.");
     }
     return bridge;
 }
@@ -259,4 +268,3 @@ export function useQueek() {
     const pickResource = useCallback((request) => bridge.requestPick(request), [bridge]);
     return useMemo(() => ({ toast, saveBar, title, navigate, pickResource, theme: { mode } }), [toast, saveBar, title, navigate, pickResource, mode]);
 }
-//# sourceMappingURL=react.js.map

package/dist/resync.d.ts

@@ -76,5 +76,15 @@ export interface ResyncListItem {
     scopes: string[];
     status: string;
 }
+/**
+ * Recover connectivity after a database loss or a long outage: list the
+ * app's active installations and ask Queek to redeliver each one's secrets
+ * and settings over the signed install channel. A refusal for one
+ * installation never aborts the run; read `cooldownSkipped`,
+ * `pendingSkipped` and `purged` on the result.
+ *
+ * @example
+ * const result = await resyncFromQueek({ apiBase: "https://api.usequeek.com", tokens, store });
+ * console.log(result.resyncRequested.length, "installations asked to redeliver");
+ */
 export declare function resyncFromQueek(options: ResyncOptions): Promise<ResyncResult>;
-//# sourceMappingURL=resync.d.ts.map

package/dist/resync.js

@@ -1,5 +1,5 @@
 import { isInstallationGone, isInstallationPending, isResyncCooldown, RETRY_JITTER_MAX_MS, } from "./app-auth.js";
-import { QueekApiError, queekApiErrorFromResponse } from "./client.js";
+import { DEFAULT_REQUEST_TIMEOUT_MS, QueekApiError, queekApiErrorFromResponse, requestSignal, transportError, tryParseJson, } from "./client.js";
 import { createLogger } from "./logger.js";
 import { resolveAppApiBase } from "./tokens.js";
 const MAX_LIST_ATTEMPTS = 3;
@@ -12,6 +12,17 @@ const RESYNC_BACKOFF_MAX_MS = 5_000;
 function defaultSleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+ * Recover connectivity after a database loss or a long outage: list the
+ * app's active installations and ask Queek to redeliver each one's secrets
+ * and settings over the signed install channel. A refusal for one
+ * installation never aborts the run; read `cooldownSkipped`,
+ * `pendingSkipped` and `purged` on the result.
+ *
+ * @example
+ * const result = await resyncFromQueek({ apiBase: "https://api.usequeek.com", tokens, store });
+ * console.log(result.resyncRequested.length, "installations asked to redeliver");
+ */
 export async function resyncFromQueek(options) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const userAgent = options.userAgent ?? "queek-app/1.0";
@@ -29,14 +40,14 @@ export async function resyncFromQueek(options) {
         headers.set("User-Agent", userAgent);
         let response;
         try {
-            response = await fetchImpl(`${appBase}${path}`, { method: init.method, headers });
+            response = await fetchImpl(`${appBase}${path}`, {
+                method: init.method,
+                headers,
+                signal: requestSignal(undefined, DEFAULT_REQUEST_TIMEOUT_MS),
+            });
         }
         catch (cause) {
-            throw new QueekApiError({
-                status: 0,
-                code: "network_error",
-                message: cause instanceof Error ? `Could not reach Queek: ${cause.message}` : "Could not reach Queek.",
-            });
+            throw transportError(cause);
         }
         return response;
     }
@@ -192,12 +203,3 @@ export async function resyncFromQueek(options) {
     }
     return result;
 }
-function tryParseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return { message: text.slice(0, 500) };
-    }
-}
-//# sourceMappingURL=resync.js.map

package/dist/scopes.d.ts

@@ -166,5 +166,18 @@ export interface InstallationScopesClient {
     requestScopes(scopes: string[], options?: RequestScopesLinkOptions): string;
     revokeScopes(scopes: string[], options?: RevokeScopesOptions): Promise<string[]>;
 }
+/**
+ * Build the optional-scopes session for one installation: read the cached
+ * grant, build the dashboard consent link, and revoke optional scopes.
+ *
+ * @example
+ * const scopes = createInstallationScopesClient({
+ *   installationId,
+ *   store,
+ *   signJwt: () => tokens.signJwt(),
+ *   appSlug: "my-app",
+ *   optionalScopes: ["merchant-orders-read"],
+ * });
+ * const { granted } = await scopes.queryScopes();
+ */
 export declare function createInstallationScopesClient(options: InstallationScopesClientOptions): InstallationScopesClient;
-//# sourceMappingURL=scopes.d.ts.map

package/dist/scopes.js

@@ -1,5 +1,5 @@
 import { isInstallationGone, UnknownInstallationError } from "./app-auth.js";
-import { newIdempotencyKey, QueekApiError, queekApiErrorFromResponse } from "./client.js";
+import { DEFAULT_REQUEST_TIMEOUT_MS, newIdempotencyKey, QueekApiError, queekApiErrorFromResponse, requestSignal, transportError, tryParseJson, } from "./client.js";
 import { isAllowedOpenTarget } from "./frame.js";
 import { installationScopesEqual } from "./install-handlers.js";
 import { resolveAppApiBase } from "./tokens.js";
@@ -161,6 +161,20 @@ export function buildScopeRequestLink(options) {
     }
     return link;
 }
+/**
+ * Build the optional-scopes session for one installation: read the cached
+ * grant, build the dashboard consent link, and revoke optional scopes.
+ *
+ * @example
+ * const scopes = createInstallationScopesClient({
+ *   installationId,
+ *   store,
+ *   signJwt: () => tokens.signJwt(),
+ *   appSlug: "my-app",
+ *   optionalScopes: ["merchant-orders-read"],
+ * });
+ * const { granted } = await scopes.queryScopes();
+ */
 export function createInstallationScopesClient(options) {
     if (!options.installationId || options.installationId.trim() === "") {
         throw new InvalidScopesError("An installation id is required.");
@@ -239,15 +253,11 @@ export function createInstallationScopesClient(options) {
                 method: "POST",
                 headers,
                 body: JSON.stringify({ scopes: requested }),
-                signal: revokeOptions.signal,
+                signal: requestSignal(revokeOptions.signal, DEFAULT_REQUEST_TIMEOUT_MS),
             });
         }
         catch (cause) {
-            throw new QueekApiError({
-                status: 0,
-                code: "network_error",
-                message: cause instanceof Error ? `Could not reach Queek: ${cause.message}` : "Could not reach Queek.",
-            });
+            throw transportError(cause, revokeOptions.signal);
         }
         const text = await response.text();
         const parsed = text === "" ? null : tryParseJson(text);
@@ -278,16 +288,7 @@ function parseRevokeBody(body) {
     const record = (typeof body === "object" && body !== null ? body : {});
     const scopes = record.scopes;
     if (!Array.isArray(scopes) || !scopes.every((scope) => typeof scope === "string")) {
-        throw new Error("Malformed revoke response: expected {scopes: string[]}.");
+        throw new Error("Malformed revoke response: expected {scopes: string[]}. The grant was not refreshed; call queryScopes() after Queek delivers the scopes update, or retry.");
     }
     return [...scopes];
 }
-function tryParseJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return { message: text.slice(0, 500) };
-    }
-}
-//# sourceMappingURL=scopes.js.map

package/dist/server.d.ts

@@ -6,4 +6,3 @@
  */
 export type { SessionTokenBinding, SessionTokenClaims, SessionTokenFailure, VerifySessionTokenOptions, } from "./session.js";
 export { EMBED_SECRET_PREFIX, SESSION_CLOCK_TOLERANCE_SECONDS, sessionTokenInstallationId, verifySessionToken, verifySessionTokenDetailed, } from "./session.js";
-//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -5,4 +5,3 @@
  * the main entry.
  */
 export { EMBED_SECRET_PREFIX, SESSION_CLOCK_TOLERANCE_SECONDS, sessionTokenInstallationId, verifySessionToken, verifySessionTokenDetailed, } from "./session.js";
-//# sourceMappingURL=server.js.map

package/dist/session.d.ts

@@ -58,7 +58,27 @@ export interface VerifySessionTokenOptions {
     expected: SessionTokenBinding;
     clockToleranceSeconds?: number;
 }
+/**
+ * True when `token` is a valid dashboard session token for the installation
+ * in `options.expected`. See {@link verifySessionTokenDetailed} for the
+ * reason a token was refused.
+ */
 export declare function verifySessionToken(token: string, options: VerifySessionTokenOptions): Promise<boolean>;
+/**
+ * Verify a dashboard session token: algorithm pin, signature, audience,
+ * issuer, expiry (20 s clock tolerance), then the installation binding.
+ * Returns the claims on success and a stable `reason` on failure. Answer 401
+ * for every failure.
+ *
+ * @example
+ * const checked = await verifySessionTokenDetailed(token, {
+ *   secret: installation.embedSecret ?? "",
+ *   audience: "my-app",
+ *   issuer: installation.apiBase,
+ *   expected: { installationId, vendorId, appSlug: "my-app", appId },
+ * });
+ * if (!checked.ok) return new Response(checked.reason, { status: 401 });
+ */
 export declare function verifySessionTokenDetailed(token: string, options: VerifySessionTokenOptions): Promise<{
     ok: true;
     claims: SessionTokenClaims;
@@ -74,4 +94,3 @@ export declare function verifySessionTokenDetailed(token: string, options: Verif
  * Null for anything that is not a decodable JWT carrying the claim.
  */
 export declare function sessionTokenInstallationId(token: string): string | null;
-//# sourceMappingURL=session.d.ts.map

package/dist/session.js

@@ -22,10 +22,30 @@ export const EMBED_SECRET_PREFIX = "embsec_";
 export const SESSION_TOKEN_ALG = "HS256";
 /** Clock skew the verifier tolerates, in seconds (matches the mint side). */
 export const SESSION_CLOCK_TOLERANCE_SECONDS = 20;
+/**
+ * True when `token` is a valid dashboard session token for the installation
+ * in `options.expected`. See {@link verifySessionTokenDetailed} for the
+ * reason a token was refused.
+ */
 export async function verifySessionToken(token, options) {
     const result = await verifySessionTokenDetailed(token, options);
     return result.ok;
 }
+/**
+ * Verify a dashboard session token: algorithm pin, signature, audience,
+ * issuer, expiry (20 s clock tolerance), then the installation binding.
+ * Returns the claims on success and a stable `reason` on failure. Answer 401
+ * for every failure.
+ *
+ * @example
+ * const checked = await verifySessionTokenDetailed(token, {
+ *   secret: installation.embedSecret ?? "",
+ *   audience: "my-app",
+ *   issuer: installation.apiBase,
+ *   expected: { installationId, vendorId, appSlug: "my-app", appId },
+ * });
+ * if (!checked.ok) return new Response(checked.reason, { status: 401 });
+ */
 export async function verifySessionTokenDetailed(token, options) {
     const envelope = await verifyTokenEnvelope(token, options);
     if (!envelope.ok)
@@ -169,4 +189,3 @@ function classifyJoseError(error) {
     }
     return "invalid_signature";
 }
-//# sourceMappingURL=session.js.map

package/dist/signatures.d.ts

@@ -41,16 +41,41 @@ export interface VerifyOptions {
     /** Skip the freshness check (NOT recommended; exposed for replaying stored fixtures). */
     skipFreshnessCheck?: boolean;
 }
+/**
+ * True when `timestamp` is a plain unix-seconds integer within `maxSkewSeconds`
+ * of `nowSeconds`, in either direction. Anything else (`""`, `"1e3"`,
+ * `"0x10"`, `"12.5"`) is stale: the signed header must be what Queek sent.
+ */
+export declare function isFreshTimestamp(timestamp: string, nowSeconds: number, maxSkewSeconds: number): boolean;
+/** The decoded MAC key for a `whsec_` secret (a secret that is not valid base64 is used as raw text). */
 export declare function secretKeyBytes(secret: string): Buffer;
 /** One `v1,<base64>` signature for one secret, in the format Queek sends. */
 export declare function signQueekPayload(eventId: string, timestamp: number | string, body: string, secret: string): string;
 /** Failure reason when verification rejects a delivery. */
 export type SignatureFailure = "missing_headers" | "stale_timestamp" | "signature_mismatch";
+/**
+ * True when one of the signatures in the header matches the body, and the
+ * timestamp is within the skew window. The compare is constant-time and
+ * covers every signature in the header (a secret rotation sends two).
+ *
+ * @example
+ * const ok = verifyQueekSignature({
+ *   id: request.headers.get("webhook-id") ?? "",
+ *   timestamp: request.headers.get("webhook-timestamp") ?? "",
+ *   signatureHeader: request.headers.get("webhook-signature") ?? "",
+ *   body: await request.text(), // the raw text, before any JSON.parse
+ *   secret: installation.webhookSecret,
+ * });
+ */
 export declare function verifyQueekSignature(input: SignatureInput, options?: VerifyOptions): boolean;
+/**
+ * Like {@link verifyQueekSignature}, but says why a delivery was rejected:
+ * `missing_headers`, `stale_timestamp` or `signature_mismatch`. Log the
+ * reason; answer 401 either way.
+ */
 export declare function verifyQueekSignatureDetailed(input: SignatureInput, options?: VerifyOptions): {
     ok: true;
 } | {
     ok: false;
     reason: SignatureFailure;
 };
-//# sourceMappingURL=signatures.d.ts.map

package/dist/signatures.js

@@ -22,6 +22,15 @@ export const WEBHOOK_SIGNATURE_HEADER = "webhook-signature";
 export const SECRET_PREFIX = "whsec_";
 /** Maximum age of a delivery before it is rejected as stale (5 minutes, the Standard Webhooks default). */
 export const MAX_TIMESTAMP_SKEW_SECONDS = 5 * 60;
+/**
+ * True when `timestamp` is a plain unix-seconds integer within `maxSkewSeconds`
+ * of `nowSeconds`, in either direction. Anything else (`""`, `"1e3"`,
+ * `"0x10"`, `"12.5"`) is stale: the signed header must be what Queek sent.
+ */
+export function isFreshTimestamp(timestamp, nowSeconds, maxSkewSeconds) {
+    return /^\d{1,15}$/.test(timestamp) && Math.abs(nowSeconds - Number(timestamp)) <= maxSkewSeconds;
+}
+/** The decoded MAC key for a `whsec_` secret (a secret that is not valid base64 is used as raw text). */
 export function secretKeyBytes(secret) {
     const encoded = secret.startsWith(SECRET_PREFIX) ? secret.slice(SECRET_PREFIX.length) : secret;
     try {
@@ -44,19 +53,37 @@ export function signQueekPayload(eventId, timestamp, body, secret) {
         .digest();
     return `v1,${mac.toString("base64")}`;
 }
+/**
+ * True when one of the signatures in the header matches the body, and the
+ * timestamp is within the skew window. The compare is constant-time and
+ * covers every signature in the header (a secret rotation sends two).
+ *
+ * @example
+ * const ok = verifyQueekSignature({
+ *   id: request.headers.get("webhook-id") ?? "",
+ *   timestamp: request.headers.get("webhook-timestamp") ?? "",
+ *   signatureHeader: request.headers.get("webhook-signature") ?? "",
+ *   body: await request.text(), // the raw text, before any JSON.parse
+ *   secret: installation.webhookSecret,
+ * });
+ */
 export function verifyQueekSignature(input, options = {}) {
     return verifyQueekSignatureDetailed(input, options).ok;
 }
+/**
+ * Like {@link verifyQueekSignature}, but says why a delivery was rejected:
+ * `missing_headers`, `stale_timestamp` or `signature_mismatch`. Log the
+ * reason; answer 401 either way.
+ */
 export function verifyQueekSignatureDetailed(input, options = {}) {
     const { id, timestamp, body, signatureHeader, secret } = input;
     if (!id || !timestamp || !signatureHeader || !secret) {
         return { ok: false, reason: "missing_headers" };
     }
     if (!options.skipFreshnessCheck) {
-        const ts = Number(timestamp);
         const now = options.nowSeconds ?? Math.floor(Date.now() / 1000);
         const maxSkew = options.maxSkewSeconds ?? MAX_TIMESTAMP_SKEW_SECONDS;
-        if (!Number.isFinite(ts) || Math.abs(now - ts) > maxSkew) {
+        if (!isFreshTimestamp(timestamp, now, maxSkew)) {
             return { ok: false, reason: "stale_timestamp" };
         }
     }
@@ -72,4 +99,3 @@ export function verifyQueekSignatureDetailed(input, options = {}) {
     }
     return { ok: false, reason: "signature_mismatch" };
 }
-//# sourceMappingURL=signatures.js.map

package/dist/store.d.ts

@@ -74,6 +74,12 @@ export interface WebhookSecretCandidate {
     installationId: string;
     secret: string;
 }
+/**
+ * Where installations live. The SDK ships `SqliteInstallationStore` (local
+ * and test) and `PostgresInstallationStore` (production); both encrypt
+ * secrets at rest. Implement this interface to use another database, and
+ * keep `claimWebhookId` atomic: handlers rely on it to run each delivery once.
+ */
 export interface InstallationStore {
     saveInstallation(record: InstallationRecord): Promise<void> | void;
     getInstallation(installationId: string): Promise<InstallationRecord | null> | InstallationRecord | null;
@@ -303,4 +309,3 @@ export interface InstallationStoreSelector {
  * container-local database).
  */
 export declare function createInstallationStore(options: InstallationStoreSelector): InstallationStore;
-//# sourceMappingURL=store.d.ts.map

package/dist/store.js

@@ -714,4 +714,3 @@ export function createInstallationStore(options) {
         storeKey: options.storeKey,
     });
 }
-//# sourceMappingURL=store.js.map

package/dist/theme.d.ts

@@ -97,4 +97,3 @@ export interface ThemeListenerOptions {
  * Returns an unsubscribe function.
  */
 export declare function installThemeListener(options: ThemeListenerOptions): () => void;
-//# sourceMappingURL=theme.d.ts.map

package/dist/theme.js

@@ -159,4 +159,3 @@ export function installThemeListener(options) {
         },
     });
 }
-//# sourceMappingURL=theme.js.map

package/dist/tokens.d.ts

@@ -75,7 +75,14 @@ export interface TokenProviderOptions {
  * (`<origin>/api/v1/apps`). Throws `InvalidApiBaseError` before any fetch.
  */
 export declare function resolveAppApiBase(raw: string, allowedApiHosts?: string[]): string;
+/** The app-API path that mints a token for one installation. */
 export declare function mintPath(installationId: string): string;
+/**
+ * Mints, caches and refreshes installation tokens for one app. Tokens are
+ * minted with the app's RSA key, cached encrypted in the installation store,
+ * and shared by concurrent callers in one process. Build one with
+ * {@link createAppTokenProvider} and pass it to `createInstallationClient`.
+ */
 export declare class AppTokenProvider implements AppTokens {
     private readonly credential;
     private readonly store;
@@ -153,6 +160,8 @@ export interface InstallationClientOptions {
     userAgent?: string;
     /** Extra allowed `apiBase` hosts (test/local API hosts). */
     allowedApiHosts?: string[];
+    /** Time one attempt may take, in ms (default 30000). `0` disables the client timeout. */
+    timeoutMs?: number;
 }
 /**
  * A `QueekClient` whose every call goes through `acquireToken()`: the
@@ -174,4 +183,3 @@ export interface InstallationClientOptions {
  * does NOT auto-update (re-run codegen in the app; sunset signal at 1.0).
  */
 export declare function createInstallationClient<TPaths = MerchantPaths>(options: InstallationClientOptions): QueekClient<ResolvedPaths<TPaths>>;
-//# sourceMappingURL=tokens.d.ts.map