@serialsubscriptions/platform-integration 0.0.8-5.1

package/lib/frontend/session/SessionClient.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionClient = void 0;
+const clientConfig_1 = require("../../clientConfig");
+/** Session cookie name; must match SessionManager (SSI_COOKIE_NAME env or default). */
+const SESSION_COOKIE_NAME = process.env.SSI_COOKIE_NAME ?? "ssi_session";
+class SessionClient {
+    static normalizeBaseUrl(baseUrl) {
+        if (!baseUrl) {
+            return "";
+        }
+        try {
+            const url = new URL(baseUrl);
+            // Remove trailing slash and default ports
+            url.pathname = url.pathname.replace(/\/$/, "");
+            if ((url.protocol === "https:" && url.port === "443") || (url.protocol === "http:" && url.port === "80")) {
+                url.port = "";
+            }
+            return url.toString().replace(/\/$/, "");
+        }
+        catch {
+            return baseUrl;
+        }
+    }
+    constructor(baseUrl, cookieHeader) {
+        this.cookieHeader = cookieHeader;
+        this.claims = null;
+        this.ttl = null;
+        const resolvedBaseUrl = baseUrl ?? process.env.NEXT_PUBLIC_BASE_URL ?? "";
+        this.baseUrl = SessionClient.normalizeBaseUrl(resolvedBaseUrl);
+        if (!this.baseUrl || !this.baseUrl.startsWith("http://") && !this.baseUrl.startsWith("https://")) {
+            console.error(`You must set baseUrl to SessionClient or you must set env variable NEXT_PUBLIC_BASE_URL. Incorrect value \`${resolvedBaseUrl}\``);
+        }
+        this.initPromise = this.loadClaims();
+    }
+    /**
+     * Returns a new SessionClient for this request. Call once per request (or per user
+     * context) so session is not shared across requests.
+     *
+     * Accepts a base URL string or an SSIClientConfig (e.g. from getClientConfig());
+     * when given config, uses config.apiUrl ?? config.baseUrl.
+     *
+     * In Next.js server components/route handlers you can omit cookieHeader: the client
+     * will automatically use the current request's session cookie (via next/headers).
+     * In other server contexts (e.g. middleware, non-Next), pass the request's Cookie
+     * header so this client is bound to that request's session.
+     */
+    static getSessionClient(baseUrlOrConfig, cookieHeader) {
+        const baseUrl = typeof baseUrlOrConfig === 'string' ? baseUrlOrConfig : (0, clientConfig_1.getSessionClientBaseUrl)(baseUrlOrConfig);
+        return new SessionClient(baseUrl, cookieHeader);
+    }
+    async isLoggedIn() {
+        await this.initPromise;
+        return this.claims != null;
+    }
+    // Non-awaiting stub to ensure initialization happens without blocking
+    warmup() {
+        void this.initPromise;
+    }
+    async getTtl() {
+        await this.initPromise;
+        return this.ttl;
+    }
+    async get(claimName) {
+        await this.initPromise;
+        if (this.claims && typeof this.claims === "object") {
+            const record = this.claims;
+            return record[claimName];
+        }
+        return undefined;
+    }
+    /**
+     * Get a specific claim from the session.
+     * Alias for `get()` method for consistency with SessionManager.
+     */
+    async getClaim(claimName) {
+        return this.get(claimName);
+    }
+    async getAll() {
+        await this.initPromise;
+        return this.claims;
+    }
+    async withSession(init = {}) {
+        if (this.cookieHeader) {
+            const headers = new Headers(init.headers ?? {});
+            if (!headers.has("Cookie")) {
+                headers.set("Cookie", this.cookieHeader);
+            }
+            return {
+                ...init,
+                headers,
+            };
+        }
+        if (typeof window !== "undefined") {
+            return init;
+        }
+        try {
+            // Dynamic import of next/headers - only available in Next.js server context (request-scoped)
+            const { cookies } = await import("next/headers");
+            const cookieStore = await cookies();
+            const sessionCookie = cookieStore.get(SESSION_COOKIE_NAME);
+            const serializedCookies = sessionCookie
+                ? `${sessionCookie.name}=${sessionCookie.value}`
+                : "";
+            if (!serializedCookies) {
+                return init;
+            }
+            const headers = new Headers(init.headers ?? {});
+            if (!headers.has("Cookie")) {
+                headers.set("Cookie", serializedCookies);
+            }
+            return {
+                ...init,
+                headers,
+            };
+        }
+        catch {
+            return init;
+        }
+    }
+    async loadClaims() {
+        try {
+            const url = new URL("/api/v1/auth/session", this.baseUrl).toString();
+            const response = await fetch(url, await this.withSession({
+                method: "GET",
+                headers: { accept: "application/json" },
+                credentials: "include",
+            }));
+            if (!response.ok) {
+                this.claims = null;
+                this.ttl = null;
+                return;
+            }
+            const data = (await response.json());
+            if (data.ok) {
+                this.claims = data.claims ?? null;
+                this.ttl = typeof data.ttl_seconds === "number" ? data.ttl_seconds : null;
+            }
+            else {
+                this.claims = null;
+                this.ttl = null;
+            }
+        }
+        catch (_err) {
+            this.claims = null;
+            this.ttl = null;
+        }
+    }
+}
+exports.SessionClient = SessionClient;
+exports.default = SessionClient;

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './auth.server';
+export * from './requestConfig';
+export * from './clientConfig';
+export * from './stateStore';
+export * from './storage/SSIStorage';
+export * from './storage/types';
+export * from './session/SessionManager';
+export { SessionClient } from './frontend/session/SessionClient';
+export * from './cache/SSICache';
+export * from './cache/types';
+export * from './cache/constants';
+export * from './SSIProjectApi';
+export { SSISubscribedFeatureApi } from './SSISubscribedFeatureApi';
+export { SSISubscribedLimitApi } from './SSISubscribedLimitApi';
+export { SSISubscribedPlanApi } from './SSISubscribedPlanApi';
+export * from './SubscribedPlanManager';
+export * from './UsageApi';

package/lib/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSISubscribedPlanApi = exports.SSISubscribedLimitApi = exports.SSISubscribedFeatureApi = exports.SessionClient = void 0;
+__exportStar(require("./auth.server"), exports);
+__exportStar(require("./requestConfig"), exports);
+__exportStar(require("./clientConfig"), exports);
+__exportStar(require("./stateStore"), exports);
+__exportStar(require("./storage/SSIStorage"), exports);
+__exportStar(require("./storage/types"), exports);
+__exportStar(require("./session/SessionManager"), exports);
+var SessionClient_1 = require("./frontend/session/SessionClient");
+Object.defineProperty(exports, "SessionClient", { enumerable: true, get: function () { return SessionClient_1.SessionClient; } });
+__exportStar(require("./cache/SSICache"), exports);
+__exportStar(require("./cache/types"), exports);
+__exportStar(require("./cache/constants"), exports);
+// Export all types and classes from SSIProjectApi (includes shared JSON:API types)
+__exportStar(require("./SSIProjectApi"), exports);
+// Export only the unique classes from subscribed APIs (types are already exported from SSIProjectApi)
+var SSISubscribedFeatureApi_1 = require("./SSISubscribedFeatureApi");
+Object.defineProperty(exports, "SSISubscribedFeatureApi", { enumerable: true, get: function () { return SSISubscribedFeatureApi_1.SSISubscribedFeatureApi; } });
+var SSISubscribedLimitApi_1 = require("./SSISubscribedLimitApi");
+Object.defineProperty(exports, "SSISubscribedLimitApi", { enumerable: true, get: function () { return SSISubscribedLimitApi_1.SSISubscribedLimitApi; } });
+var SSISubscribedPlanApi_1 = require("./SSISubscribedPlanApi");
+Object.defineProperty(exports, "SSISubscribedPlanApi", { enumerable: true, get: function () { return SSISubscribedPlanApi_1.SSISubscribedPlanApi; } });
+__exportStar(require("./SubscribedPlanManager"), exports);
+__exportStar(require("./UsageApi"), exports);

package/lib/lib/session/SessionClient.d.ts

@@ -0,0 +1,11 @@
+import type { SessionClientInit, SessionSnapshot, TokenBundle } from './types';
+export declare class SessionClient {
+    private readonly init;
+    constructor(init: SessionClientInit);
+    private k;
+    getAll(sessionId: string): Promise<SessionSnapshot>;
+    setTokens(sessionId: string, t: TokenBundle): Promise<void>;
+    getTtl(_sessionId: string): Promise<number | null>;
+    clear(sessionId: string): Promise<void>;
+    maybeRefresh(_sessionId: string): Promise<boolean>;
+}

package/lib/lib/session/SessionClient.js

@@ -0,0 +1,47 @@
+const ACCESS = 'access';
+const ID = 'id';
+const REFRESH = 'refresh';
+const CLAIMS = 'claims';
+const DEFAULT_REFRESH_TTL_SEC = 7 * 24 * 60 * 60;
+export class SessionClient {
+    constructor(init) {
+        this.init = init;
+    }
+    k(sessionId, suffix) {
+        return `${sessionId}:${suffix}`;
+    }
+    async getAll(sessionId) {
+        const claims = await this.init.store.get(this.k(sessionId, CLAIMS));
+        const access_token = await this.init.store.get(this.k(sessionId, ACCESS));
+        const id_token = await this.init.store.get(this.k(sessionId, ID));
+        const refresh_token = await this.init.store.get(this.k(sessionId, REFRESH));
+        return { claims, access_token, id_token, refresh_token };
+    }
+    async setTokens(sessionId, t) {
+        const { store } = this.init;
+        await store.set(this.k(sessionId, ACCESS), t.access_token, t.ttlSec);
+        await store.set(this.k(sessionId, ID), t.id_token, t.ttlSec);
+        if (t.refresh_token) {
+            const refreshTtl = this.init.refresh?.defaultTtlSec ?? DEFAULT_REFRESH_TTL_SEC;
+            await store.set(this.k(sessionId, REFRESH), t.refresh_token, refreshTtl);
+        }
+        // No JWT verification. Clear cached claims to force re-derive later (future step).
+        await store.del(this.k(sessionId, CLAIMS));
+    }
+    async getTtl(_sessionId) {
+        // Will compute from JWT exp later; parity with original means null for now.
+        return null;
+    }
+    async clear(sessionId) {
+        await Promise.all([
+            this.init.store.del(this.k(sessionId, ACCESS)),
+            this.init.store.del(this.k(sessionId, ID)),
+            this.init.store.del(this.k(sessionId, REFRESH)),
+            this.init.store.del(this.k(sessionId, CLAIMS)),
+        ]);
+    }
+    async maybeRefresh(_sessionId) {
+        // Stub; parity with original (no auto-refresh yet).
+        return false;
+    }
+}

package/lib/lib/session/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './SessionClient';
+export * from './stores';

package/lib/lib/session/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './SessionClient';
+export * from './stores';

package/lib/lib/session/stores/MemoryStore.d.ts

@@ -0,0 +1,7 @@
+import type { SessionStore } from '../types';
+export declare class MemoryStore implements SessionStore {
+    private map;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttlSec?: number): Promise<void>;
+    del(key: string): Promise<void>;
+}

package/lib/lib/session/stores/MemoryStore.js

@@ -0,0 +1,23 @@
+export class MemoryStore {
+    constructor() {
+        this.map = new Map();
+    }
+    async get(key) {
+        const now = Date.now();
+        const hit = this.map.get(key);
+        if (!hit)
+            return null;
+        if (hit.expiresAt !== undefined && hit.expiresAt <= now) {
+            this.map.delete(key);
+            return null;
+        }
+        return hit.value;
+    }
+    async set(key, value, ttlSec) {
+        const expiresAt = ttlSec !== undefined && ttlSec > 0 ? Date.now() + ttlSec * 1000 : undefined;
+        this.map.set(key, { value, expiresAt });
+    }
+    async del(key) {
+        this.map.delete(key);
+    }
+}

package/lib/lib/session/stores/index.d.ts

@@ -0,0 +1 @@
+export { MemoryStore } from './MemoryStore';

package/lib/lib/session/stores/index.js

@@ -0,0 +1 @@
+export { MemoryStore } from './MemoryStore';

package/lib/lib/session/types.d.ts

@@ -0,0 +1,37 @@
+export interface SessionStore {
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttlSec?: number): Promise<void>;
+    del(key: string): Promise<void>;
+}
+export type SameSite = 'lax' | 'strict' | 'none';
+export interface JWKSOptions {
+    issuer: string;
+    jwksUri: string;
+    cacheTtlSec?: number;
+}
+export interface RequiredClaims {
+    sub: string;
+    organization_id?: number | string;
+    role?: string;
+    [k: string]: unknown;
+}
+export interface SessionClientInit {
+    store: SessionStore;
+    refresh?: {
+        endpoint: string;
+        graceSec?: number;
+        defaultTtlSec?: number;
+    };
+}
+export interface TokenBundle {
+    id_token: string;
+    access_token: string;
+    refresh_token?: string;
+    ttlSec?: number;
+}
+export interface SessionSnapshot {
+    claims: unknown | null;
+    access_token: string | null;
+    id_token: string | null;
+    refresh_token: string | null;
+}

package/lib/lib/session/types.js

@@ -0,0 +1 @@
+export {};

package/lib/requestConfig.d.ts

@@ -0,0 +1,60 @@
+import type { AuthConfig } from './auth.server';
+/**
+ * SSI-related config that host apps typically derive from the current request
+ * (e.g. via getRequestConfig(req)) and pass to the library.
+ *
+ * Use this type when building a "request config" in your app so SessionManager,
+ * AuthServer, UsageApi, and SubscribedPlanManager get a consistent, typed shape.
+ *
+ * - **ssiIssuerBaseUrl**, **ssiRedirectUri**, **ssiClientId**: passed to
+ *   AuthServer and SessionManager.fromEnv(cookieHeader, config).
+ * - **ssiApiUrl**: base URL for SSI Platform API (UsageApi, SubscribedPlanManager,
+ *   SSIProjectApi, etc.).
+ * - **baseUrl** / **apiUrl**: optional; for app use (e.g. redirect after login).
+ *   The library does not use these; they are included so apps can use this type
+ *   as the SSI subset of a larger RequestConfig.
+ */
+export type SSIRequestConfig = {
+    baseUrl?: string | null;
+    apiUrl?: string | null;
+    ssiApiUrl: string | null;
+    ssiIssuerBaseUrl: string | null;
+    ssiRedirectUri: string | null;
+    ssiClientId: string | null;
+};
+/**
+ * Get the base URL from request headers or environment.
+ * Uses x-forwarded-proto, x-forwarded-host, origin, host, and NEXT_PUBLIC_APP_URL.
+ */
+export declare function getBaseUrl(req: Request): string | null;
+/** When baseUrl is a single URL or comma-separated list, return the first URL. */
+export declare function firstBaseUrl(baseUrl: string | null): string | null;
+/** App API base URL: NEXT_PUBLIC_API_URL or baseUrl. */
+export declare function getBaseApiUrl(req: Request): string | null;
+/** SSI client id: SSI_CLIENT_ID env or subdomain on known Cereal Stack domains. */
+export declare function getSsiClientId(baseUrl: string): string | null;
+/** SSI issuer base URL: SSI_ISSUER_BASE_URL env or derived from host (getSsiApiUrl). */
+export declare function getIssuerBaseUrl(baseUrl: string): string | null;
+/**
+ * SSI Platform API base URL: SSI_API_BASE_URL env or derived from host
+ * (e.g. https://<subdomain>.cerealstackdev.com on known domains).
+ */
+export declare function getSsiApiUrl(baseUrl: string): string | null;
+/** SSI redirect URI: SSI_REDIRECT_URI env or `${baseUrl}/api/v1/auth/callback`. */
+export declare function getSsiRedirectUri(baseUrl: string): string | null;
+export declare function getRequestConfig(req: Request): SSIRequestConfig;
+export declare function getRequestConfig(headers: Headers): SSIRequestConfig;
+/**
+ * Union type accepted anywhere AuthConfig is accepted (AuthServer, SessionManager).
+ */
+export type AuthConfigInput = AuthConfig | SSIRequestConfig;
+/**
+ * Converts SSIRequestConfig to AuthConfig for use with AuthServer and SessionManager.
+ * Drops null/undefined so the library can fall back to env vars where appropriate.
+ */
+export declare function toAuthConfig(rc: SSIRequestConfig): AuthConfig;
+/**
+ * Normalizes AuthConfigInput to AuthConfig. Use internally so AuthServer and SessionManager
+ * accept both AuthConfig and SSIRequestConfig.
+ */
+export declare function normalizeAuthConfig(input: AuthConfigInput | undefined): AuthConfig | undefined;

package/lib/requestConfig.js

@@ -0,0 +1,151 @@
+"use strict";
+// requestConfig.ts
+// Types and helpers for config that host apps derive per-request and pass into AuthServer, SessionManager, and SSI API clients.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseUrl = getBaseUrl;
+exports.firstBaseUrl = firstBaseUrl;
+exports.getBaseApiUrl = getBaseApiUrl;
+exports.getSsiClientId = getSsiClientId;
+exports.getIssuerBaseUrl = getIssuerBaseUrl;
+exports.getSsiApiUrl = getSsiApiUrl;
+exports.getSsiRedirectUri = getSsiRedirectUri;
+exports.getRequestConfig = getRequestConfig;
+exports.toAuthConfig = toAuthConfig;
+exports.normalizeAuthConfig = normalizeAuthConfig;
+// --- Helpers used by getRequestConfig (env: NEXT_PUBLIC_APP_URL, SSI_*, request headers) ---
+/**
+ * Get the base URL from request headers or environment.
+ * Uses x-forwarded-proto, x-forwarded-host, origin, host, and NEXT_PUBLIC_APP_URL.
+ */
+function getBaseUrl(req) {
+    const proto = req.headers.get('x-forwarded-proto') || 'https';
+    let baseUrl = process.env.NEXT_PUBLIC_APP_URL;
+    if (!baseUrl) {
+        const forwardedHost = req.headers.get('x-forwarded-host');
+        if (forwardedHost) {
+            baseUrl = `${proto}://${forwardedHost}`;
+        }
+        else {
+            const origin = req.headers.get('origin');
+            if (origin) {
+                baseUrl = origin;
+            }
+            else {
+                const host = req.headers.get('host');
+                const hostWithoutPort = host ? host.split(':')[0] : undefined;
+                if (hostWithoutPort) {
+                    baseUrl = `${proto}://${hostWithoutPort}`;
+                }
+            }
+        }
+    }
+    return baseUrl || null;
+}
+/** When baseUrl is a single URL or comma-separated list, return the first URL. */
+function firstBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return null;
+    const first = baseUrl.split(',')[0].trim();
+    return first || null;
+}
+/** App API base URL: NEXT_PUBLIC_API_URL or baseUrl. */
+function getBaseApiUrl(req) {
+    return process.env.NEXT_PUBLIC_API_URL || getBaseUrl(req) || null;
+}
+/** SSI client id: SSI_CLIENT_ID env or subdomain on known Cereal Stack domains. */
+function getSsiClientId(baseUrl) {
+    if (process.env.SSI_CLIENT_ID)
+        return process.env.SSI_CLIENT_ID;
+    try {
+        const url = new URL(baseUrl);
+        url.pathname = url.pathname.replace(/\/$/, '');
+        const hostname = url.hostname;
+        if (hostname.endsWith('.cerealstackdev.com') || hostname.endsWith('.cerealstackqa.com') || hostname.endsWith('.cerealstack.com')) {
+            const domainParts = hostname.split('.');
+            const subdomain = domainParts[domainParts.length - 3];
+            return subdomain ?? null;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/** SSI issuer base URL: SSI_ISSUER_BASE_URL env or derived from host (getSsiApiUrl). */
+function getIssuerBaseUrl(baseUrl) {
+    return process.env.SSI_ISSUER_BASE_URL || getSsiApiUrl(baseUrl) || null;
+}
+/**
+ * SSI Platform API base URL: SSI_API_BASE_URL env or derived from host
+ * (e.g. https://<subdomain>.cerealstackdev.com on known domains).
+ */
+function getSsiApiUrl(baseUrl) {
+    if (process.env.SSI_API_BASE_URL)
+        return process.env.SSI_API_BASE_URL;
+    try {
+        const url = new URL(baseUrl);
+        url.pathname = url.pathname.replace(/\/$/, '');
+        const hostname = url.hostname;
+        if (hostname.endsWith('.cerealstackdev.com') || hostname.endsWith('.cerealstackqa.com') || hostname.endsWith('.cerealstack.com')) {
+            const domainParts = hostname.split('.');
+            const subdomain = domainParts[domainParts.length - 3];
+            const domain = domainParts[domainParts.length - 2] + '.' + domainParts[domainParts.length - 1];
+            return `https://${subdomain}.${domain}`;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/** SSI redirect URI: SSI_REDIRECT_URI env or `${baseUrl}/api/v1/auth/callback`. */
+function getSsiRedirectUri(baseUrl) {
+    return process.env.SSI_REDIRECT_URI || `${baseUrl}/api/v1/auth/callback`;
+}
+/**
+ * Build SSIRequestConfig from the current request (or headers).
+ * Uses env vars (NEXT_PUBLIC_APP_URL, SSI_*, etc.) and request headers for base URL and SSI URLs.
+ * Apps can use this as-is or extend the result with app-specific fields (e.g. prisma, dbUrl).
+ */
+function getRequestConfig(arg) {
+    const req = arg instanceof Headers ? new Request('http://local', { headers: arg }) : arg;
+    const rawBaseUrl = getBaseUrl(req);
+    const baseUrl = firstBaseUrl(rawBaseUrl);
+    const fallback = baseUrl || '';
+    return {
+        baseUrl: baseUrl ?? null,
+        apiUrl: getBaseApiUrl(req),
+        ssiApiUrl: getSsiApiUrl(fallback),
+        ssiIssuerBaseUrl: getIssuerBaseUrl(fallback),
+        ssiRedirectUri: getSsiRedirectUri(fallback),
+        ssiClientId: getSsiClientId(fallback),
+    };
+}
+function isSSIRequestConfig(x) {
+    return x != null && typeof x === 'object' && 'ssiIssuerBaseUrl' in x;
+}
+/**
+ * Converts SSIRequestConfig to AuthConfig for use with AuthServer and SessionManager.
+ * Drops null/undefined so the library can fall back to env vars where appropriate.
+ */
+function toAuthConfig(rc) {
+    const auth = {};
+    if (rc.ssiIssuerBaseUrl != null && rc.ssiIssuerBaseUrl !== '')
+        auth.issuerBaseUrl = rc.ssiIssuerBaseUrl;
+    if (rc.ssiRedirectUri != null && rc.ssiRedirectUri !== '')
+        auth.redirectUri = rc.ssiRedirectUri;
+    if (rc.ssiClientId != null && rc.ssiClientId !== '')
+        auth.clientId = rc.ssiClientId;
+    return auth;
+}
+/**
+ * Normalizes AuthConfigInput to AuthConfig. Use internally so AuthServer and SessionManager
+ * accept both AuthConfig and SSIRequestConfig.
+ */
+function normalizeAuthConfig(input) {
+    if (input == null)
+        return undefined;
+    if (isSSIRequestConfig(input))
+        return toAuthConfig(input);
+    return input;
+}

package/lib/session/SessionClient.d.ts

@@ -0,0 +1,19 @@
+export declare class SessionClient {
+    private readonly cookieHeader?;
+    private static readonly instances;
+    private readonly baseUrl;
+    private claims;
+    private ttl;
+    private initPromise;
+    private static normalizeBaseUrl;
+    constructor(baseUrl?: string, cookieHeader?: string | null | undefined);
+    static getSessionManager(baseUrl?: string): SessionClient;
+    isLoggedIn(): Promise<boolean>;
+    warmup(): void;
+    getTtl(): Promise<number | null>;
+    get(claimName: string): Promise<unknown>;
+    getAll(): Promise<unknown | null>;
+    private withSession;
+    private loadClaims;
+}
+export default SessionClient;