@authx-rs/sdk-web

Generated from packages/authx-sdk-web/dist/types.

Browser token storage, authenticated fetch, and refresh orchestration.

Modules

• errors
• oidc
• storage
• token-manager

errors

AuthxTokenManagerError

export declare class AuthxTokenManagerError extends Error {
    readonly cause?: unknown;
    constructor(message: string, options?: {
        cause?: unknown;
    });
}

oidc

OidcTokenRefresherOptions

export interface OidcTokenRefresherOptions {
    tokenEndpoint: string;
    clientId: string;
    clientSecret?: string;
    scope?: string;
    headers?: HeadersInit;
    fetch?: typeof globalThis.fetch;
}

createOidcTokenRefresher

export declare function createOidcTokenRefresher(options: OidcTokenRefresherOptions): TokenRefreshHandler;

storage

TokenStore

export interface TokenStore {
    load(): StoredTokenState | null | Promise<StoredTokenState | null>;
    save(tokens: StoredTokenState | null): void | Promise<void>;
}

StorageLike

export interface StorageLike {
    getItem(key: string): string | null;
    setItem(key: string, value: string): void;
    removeItem(key: string): void;
}

BrowserStorageTokenStoreOptions

export interface BrowserStorageTokenStoreOptions {
    key?: string;
    storage?: StorageLike;
}

MemoryTokenStore

export declare class MemoryTokenStore implements TokenStore {
    constructor(initialValue?: StoredTokenState | null);
    load(): StoredTokenState | null;
    save(tokens: StoredTokenState | null): void;
}

BrowserStorageTokenStore

export declare class BrowserStorageTokenStore implements TokenStore {
    constructor(options?: BrowserStorageTokenStoreOptions);
    load(): StoredTokenState | null;
    save(tokens: StoredTokenState | null): void;
}

token-manager

OidcTokenResponse

export interface OidcTokenResponse {
    access_token: string;
    token_type: string;
    expires_in: number;
    refresh_token?: string;
    scope?: string;
    id_token?: string;
    [key: string]: unknown;
}

StoredTokenState

export interface StoredTokenState {
    accessToken: string;
    tokenType: string;
    expiresAt: number;
    refreshToken?: string;
    scope?: string;
    idToken?: string;
    [key: string]: unknown;
}

AuthxTokenSnapshot

export interface AuthxTokenSnapshot {
    tokens: StoredTokenState | null;
    isAuthenticated: boolean;
    isRefreshing: boolean;
    error?: unknown;
}

AuthxFetchOptions

export interface AuthxFetchOptions {
    minValidityMs?: number;
    retryOnUnauthorized?: boolean;
}

SetTokenResponseOptions

export interface SetTokenResponseOptions {
    now?: number;
    preserveRefreshToken?: boolean;
}

TokenRefreshHandler

export type TokenRefreshHandler = (tokens: StoredTokenState) => Promise<OidcTokenResponse> | OidcTokenResponse;

AuthxTokenManagerOptions

export interface AuthxTokenManagerOptions {
    storage: TokenStore;
    refresh?: TokenRefreshHandler;
    autoRefresh?: boolean;
    refreshWindowMs?: number;
    clearOnRefreshError?: boolean;
    now?: () => number;
    fetch?: typeof globalThis.fetch;
    onRefreshError?: (error: unknown) => void;
}

AuthxTokenManager

export declare class AuthxTokenManager {
    constructor(options: AuthxTokenManagerOptions);
    start(): Promise<AuthxTokenSnapshot>;
    stop(): void;
    subscribe(listener: SnapshotListener): () => void;
    getSnapshot(): AuthxTokenSnapshot;
    setTokens(tokens: StoredTokenState | null): Promise<AuthxTokenSnapshot>;
    setTokenResponse(response: OidcTokenResponse, options?: SetTokenResponseOptions): Promise<AuthxTokenSnapshot>;
    clear(): Promise<AuthxTokenSnapshot>;
    getAccessToken(minValidityMs?: number): Promise<string | null>;
    refresh(): Promise<StoredTokenState>;
    fetch(input: RequestInfo | URL, init?: RequestInit, options?: AuthxFetchOptions): Promise<Response>;
}

tokenResponseToStoredState

export declare function tokenResponseToStoredState(response: OidcTokenResponse, options?: {
    now?: number;
    previous?: StoredTokenState | null;
    preserveRefreshToken?: boolean;
}): StoredTokenState;