@ovok/core 0.4.49-dev.495 → 0.4.49-dev.497

package/dist/next/auth/token-endpoint.d.ts

@@ -0,0 +1,12 @@
+import { OvokSettings } from "../config/ovok-config";
+export type OAuthTokenResponse = {
+    access_token: string;
+    refresh_token?: string;
+    expires_in: number;
+    token_type: string;
+};
+export declare class TokenEndpoint {
+    private readonly settings;
+    constructor(settings: OvokSettings);
+    request(form: Record<string, string>): Promise<OAuthTokenResponse>;
+}

package/dist/next/auth/token-endpoint.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenEndpoint = void 0;
+const error_from_response_1 = require("../errors/error-from-response");
+const transmit_1 = require("../http/transmit");
+const TOKEN_PATH = "oauth2/token";
+const FORM_TYPE = "application/x-www-form-urlencoded";
+class TokenEndpoint {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    async request(form) {
+        const response = await (0, transmit_1.transmit)(this.settings, {
+            url: `${this.settings.baseUrl}${TOKEN_PATH}`,
+            method: "POST",
+            headers: { "Content-Type": FORM_TYPE, Accept: "application/json" },
+            body: encodeForm(form),
+        });
+        if (response.ok) {
+            return (await response.json());
+        }
+        throw await (0, error_from_response_1.errorFromResponse)(response);
+    }
+}
+exports.TokenEndpoint = TokenEndpoint;
+const encodeForm = (form) => Object.entries(form)
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join("&");

package/dist/next/auth/user-session.d.ts

@@ -0,0 +1,39 @@
+import { OvokSettings } from "../config/ovok-config";
+import { Clock } from "./access-token";
+import { Credentials } from "./credentials";
+import { SavedAccount, SavedAccountsStore, StoredSavedAccount } from "./saved-accounts-store";
+import { LoginTokens, Session } from "./session";
+import { SessionStore } from "./session-store";
+import { TokenEndpoint } from "./token-endpoint";
+type SessionSettings = Pick<OvokSettings, "clientId" | "onUnauthenticated">;
+export type SessionChangeListener = (session: Session | null) => void;
+export declare class UserSession implements Credentials {
+    private readonly store;
+    private readonly endpoint;
+    private readonly settings;
+    private readonly now;
+    private readonly savedAccounts;
+    private loaded;
+    private pendingRefresh;
+    private readonly changeListeners;
+    constructor(store: SessionStore, endpoint: TokenEndpoint, settings: SessionSettings, now?: Clock, savedAccounts?: SavedAccountsStore | null);
+    current(): Promise<Session | null>;
+    onChange(listener: SessionChangeListener): () => void;
+    begin(tokens: LoginTokens): Promise<Session>;
+    end(): Promise<void>;
+    listSavedAccounts(): Promise<SavedAccount[]>;
+    getSavedAccount(accountId: string): Promise<StoredSavedAccount | null>;
+    switchSavedAccount(accountId: string): Promise<void>;
+    removeSavedAccount(accountId: string): Promise<void>;
+    markSavedAccountExpired(accountId: string): Promise<void>;
+    forSavedAccount(session: Session): UserSession;
+    accessToken(): Promise<string | null>;
+    refresh(): Promise<boolean>;
+    private exchangeRefreshToken;
+    /** Only a refused refresh token signs the user out; an outage keeps the session for a later retry. */
+    private signOutIfRejected;
+    private refreshForm;
+    private save;
+    private notifyChange;
+}
+export {};

package/dist/next/auth/user-session.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSession = void 0;
+const ovok_account_error_1 = require("../errors/ovok-account-error");
+const ovok_errors_1 = require("../errors/ovok-errors");
+const ovok_storage_1 = require("../storage/ovok-storage");
+const session_1 = require("./session");
+const session_store_1 = require("./session-store");
+const REJECTED_REFRESH_STATUSES = new Set([400, 401, 403]);
+class UserSession {
+    constructor(store, endpoint, settings, now = Date.now, savedAccounts = null) {
+        this.store = store;
+        this.endpoint = endpoint;
+        this.settings = settings;
+        this.now = now;
+        this.savedAccounts = savedAccounts;
+        this.loaded = null;
+        this.pendingRefresh = null;
+        this.changeListeners = new Set();
+    }
+    current() {
+        if (this.loaded === null) {
+            const pending = this.store.load().catch((error) => {
+                if (this.loaded === pending) {
+                    this.loaded = null;
+                }
+                throw error;
+            });
+            this.loaded = pending;
+        }
+        return this.loaded;
+    }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => this.changeListeners.delete(listener);
+    }
+    async begin(tokens) {
+        const session = (0, session_1.sessionFromLogin)(tokens, this.now());
+        await this.save(session);
+        this.notifyChange(session);
+        return session;
+    }
+    async end() {
+        var _a;
+        const current = await this.current().catch(() => null);
+        this.loaded = Promise.resolve(null);
+        await this.store.clear();
+        if (current) {
+            await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.remove(current.profile.reference));
+        }
+        this.notifyChange(null);
+    }
+    async listSavedAccounts() {
+        var _a;
+        const current = await this.current();
+        const currentAccountId = (_a = current === null || current === void 0 ? void 0 : current.profile.reference) !== null && _a !== void 0 ? _a : null;
+        if (this.savedAccounts === null) {
+            return [];
+        }
+        const accounts = await this.savedAccounts.list(currentAccountId);
+        if (current && !accounts.some((account) => account.active)) {
+            await this.savedAccounts.save(current);
+            return this.savedAccounts.list(currentAccountId);
+        }
+        return accounts;
+    }
+    async getSavedAccount(accountId) {
+        var _a, _b;
+        return (_b = (_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.get(accountId)) !== null && _b !== void 0 ? _b : null;
+    }
+    async switchSavedAccount(accountId) {
+        const account = await this.getSavedAccount(accountId);
+        if (account === null) {
+            throw new ovok_account_error_1.OvokAccountError("account_not_found");
+        }
+        if (account.expired) {
+            throw new ovok_account_error_1.OvokAccountError("account_expired");
+        }
+        const current = await this.current();
+        if ((current === null || current === void 0 ? void 0 : current.profile.reference) === accountId) {
+            return;
+        }
+        await this.store.save(account.session);
+        this.loaded = Promise.resolve(account.session);
+        this.notifyChange(account.session);
+    }
+    async removeSavedAccount(accountId) {
+        var _a, _b, _c;
+        const account = await this.getSavedAccount(accountId);
+        if (account === null) {
+            throw new ovok_account_error_1.OvokAccountError("account_not_found");
+        }
+        const current = await this.current();
+        const wasActive = (current === null || current === void 0 ? void 0 : current.profile.reference) === accountId;
+        if (wasActive) {
+            await this.store.clear();
+            this.loaded = Promise.resolve(null);
+        }
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.remove(accountId));
+        if (wasActive) {
+            const nextAccount = ((_c = await ((_b = this.savedAccounts) === null || _b === void 0 ? void 0 : _b.list(null))) !== null && _c !== void 0 ? _c : []).find((saved) => !saved.expired);
+            if (nextAccount) {
+                await this.switchSavedAccount(nextAccount.id);
+            }
+            else {
+                this.notifyChange(null);
+            }
+        }
+    }
+    async markSavedAccountExpired(accountId) {
+        var _a;
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.markExpired(accountId));
+    }
+    forSavedAccount(session) {
+        const isolated = new UserSession(new session_store_1.SessionStore(new ovok_storage_1.MemoryStorage(), "ovok:isolated-session"), this.endpoint, { ...this.settings, onUnauthenticated: () => undefined }, this.now);
+        isolated.loaded = Promise.resolve(session);
+        return isolated;
+    }
+    async accessToken() {
+        var _a, _b;
+        const session = await this.current();
+        const refreshable = session !== null && session.refreshToken !== null;
+        if (refreshable && (0, session_1.isSessionStaleAt)(session, this.now())) {
+            await this.refresh();
+        }
+        return (_b = (_a = (await this.current())) === null || _a === void 0 ? void 0 : _a.accessToken) !== null && _b !== void 0 ? _b : null;
+    }
+    refresh() {
+        var _a;
+        (_a = this.pendingRefresh) !== null && _a !== void 0 ? _a : (this.pendingRefresh = this.exchangeRefreshToken().finally(() => {
+            this.pendingRefresh = null;
+        }));
+        return this.pendingRefresh;
+    }
+    async exchangeRefreshToken() {
+        var _a;
+        const session = await this.current();
+        const refreshToken = (_a = session === null || session === void 0 ? void 0 : session.refreshToken) !== null && _a !== void 0 ? _a : null;
+        if (session === null || refreshToken === null) {
+            return false;
+        }
+        try {
+            const response = await this.endpoint.request(this.refreshForm(refreshToken));
+            await this.save((0, session_1.sessionAfterRefresh)(session, response, this.now()));
+            return true;
+        }
+        catch (error) {
+            return this.signOutIfRejected(error);
+        }
+    }
+    /** Only a refused refresh token signs the user out; an outage keeps the session for a later retry. */
+    async signOutIfRejected(error) {
+        var _a;
+        const status = error instanceof ovok_errors_1.OvokError ? error.status : null;
+        const rejected = status !== null && REJECTED_REFRESH_STATUSES.has(status);
+        if (rejected) {
+            const current = await this.current();
+            if (current) {
+                await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.markExpired(current.profile.reference));
+            }
+            this.loaded = Promise.resolve(null);
+            await this.store.clear();
+            this.notifyChange(null);
+            this.settings.onUnauthenticated({ type: "refresh-rejected", status });
+            return false;
+        }
+        throw error;
+    }
+    refreshForm(refreshToken) {
+        const client = this.settings.clientId ? { client_id: this.settings.clientId } : {};
+        return { grant_type: "refresh_token", refresh_token: refreshToken, ...client };
+    }
+    async save(session) {
+        var _a;
+        await this.store.save(session);
+        await ((_a = this.savedAccounts) === null || _a === void 0 ? void 0 : _a.save(session));
+        this.loaded = Promise.resolve(session);
+    }
+    notifyChange(session) {
+        this.changeListeners.forEach((listener) => listener(session));
+    }
+}
+exports.UserSession = UserSession;

package/dist/next/config/ovok-config.d.ts

@@ -0,0 +1,42 @@
+import { OvokStorage } from "../storage/ovok-storage";
+export type OvokFetch = (url: string, init: RequestInit) => Promise<Response>;
+export type OvokUnauthenticatedReason = {
+    type: "refresh-rejected";
+    status: number;
+};
+type OvokBaseConfig = {
+    baseUrl: string;
+    tenantCode: string;
+    fhirPath?: string;
+    storage?: OvokStorage;
+    fetch?: OvokFetch;
+    timeoutMs?: number;
+    maxNetworkRetries?: number;
+    onUnauthenticated?: (reason: OvokUnauthenticatedReason) => void;
+};
+type OvokUserClientConfig = {
+    clientId?: string;
+    clientSecret?: undefined;
+};
+type OvokMachineClientConfig = {
+    clientId: string;
+    clientSecret: string;
+};
+export type OvokConfig = OvokBaseConfig & (OvokUserClientConfig | OvokMachineClientConfig);
+export type MachineClient = {
+    clientId: string;
+    clientSecret: string;
+};
+export type OvokSettings = {
+    baseUrl: string;
+    tenantCode: string;
+    fhirPath: string;
+    storage: OvokStorage;
+    fetch: OvokFetch;
+    timeoutMs: number;
+    maxNetworkRetries: number;
+    clientId: string | null;
+    machineClient: MachineClient | null;
+    onUnauthenticated: (reason: OvokUnauthenticatedReason) => void;
+};
+export {};

package/dist/next/config/ovok-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/next/config/settings.d.ts

@@ -0,0 +1,6 @@
+import { OvokConfig, OvokSettings } from "./ovok-config";
+export type RuntimeEnvironment = {
+    hasDocument: boolean;
+};
+export declare const currentEnvironment: () => RuntimeEnvironment;
+export declare function readSettings(config: OvokConfig, environment: RuntimeEnvironment): OvokSettings;

package/dist/next/config/settings.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentEnvironment = void 0;
+exports.readSettings = readSettings;
+const ovok_errors_1 = require("../errors/ovok-errors");
+const ovok_storage_1 = require("../storage/ovok-storage");
+const DEFAULT_FHIR_PATH = "fhir";
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_NETWORK_RETRIES = 2;
+const ABSOLUTE_HTTP_URL = /^https?:\/\/[^/\s]+/i;
+const currentEnvironment = () => ({ hasDocument: typeof document !== "undefined" });
+exports.currentEnvironment = currentEnvironment;
+function readSettings(config, environment) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const machineClient = readMachineClient(config, environment);
+    return {
+        baseUrl: readBaseUrl(config.baseUrl),
+        tenantCode: requireText(config.tenantCode, "tenantCode"),
+        fhirPath: trimSlashes((_a = config.fhirPath) !== null && _a !== void 0 ? _a : DEFAULT_FHIR_PATH),
+        storage: (_b = config.storage) !== null && _b !== void 0 ? _b : new ovok_storage_1.MemoryStorage(),
+        fetch: (_c = config.fetch) !== null && _c !== void 0 ? _c : globalFetch(),
+        timeoutMs: requirePositive((_d = config.timeoutMs) !== null && _d !== void 0 ? _d : DEFAULT_TIMEOUT_MS, "timeoutMs"),
+        maxNetworkRetries: requireCount((_e = config.maxNetworkRetries) !== null && _e !== void 0 ? _e : DEFAULT_MAX_NETWORK_RETRIES, "maxNetworkRetries"),
+        clientId: (_f = config.clientId) !== null && _f !== void 0 ? _f : null,
+        machineClient,
+        onUnauthenticated: (_g = config.onUnauthenticated) !== null && _g !== void 0 ? _g : (() => undefined),
+    };
+}
+const configError = (message) => new ovok_errors_1.OvokConfigError((0, ovok_errors_1.detailsFor)(message));
+const readBaseUrl = (baseUrl) => {
+    if (!ABSOLUTE_HTTP_URL.test(baseUrl)) {
+        throw configError("baseUrl must be an absolute http(s) URL.");
+    }
+    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+};
+const readMachineClient = (config, environment) => {
+    if (config.clientSecret === undefined) {
+        return null;
+    }
+    if (environment.hasDocument) {
+        throw configError("clientSecret is for servers only: a secret shipped to a browser is public.");
+    }
+    return {
+        clientId: requireText(config.clientId, "clientId"),
+        clientSecret: requireText(config.clientSecret, "clientSecret"),
+    };
+};
+const requireText = (value, name) => {
+    var _a;
+    const text = (_a = value === null || value === void 0 ? void 0 : value.trim()) !== null && _a !== void 0 ? _a : "";
+    if (text === "") {
+        throw configError(`${name} is required.`);
+    }
+    return text;
+};
+const requirePositive = (value, name) => {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw configError(`${name} must be a positive number.`);
+    }
+    return value;
+};
+const requireCount = (value, name) => {
+    if (!Number.isInteger(value) || value < 0) {
+        throw configError(`${name} must be a whole number of at least 0.`);
+    }
+    return value;
+};
+const trimSlashes = (path) => path.replace(/^\/+|\/+$/g, "");
+const globalFetch = () => {
+    if (typeof globalThis.fetch !== "function") {
+        throw configError("No global fetch is available: pass config.fetch.");
+    }
+    return (url, init) => globalThis.fetch(url, init);
+};

package/dist/next/errors/error-from-response.d.ts

@@ -0,0 +1,2 @@
+import { OvokError } from "./ovok-errors";
+export declare function errorFromResponse(response: Response): Promise<OvokError>;

package/dist/next/errors/error-from-response.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorFromResponse = errorFromResponse;
+const ovok_error_1 = require("../../client/errors/ovok-error");
+const retry_after_1 = require("../http/retry-after");
+const ovok_errors_1 = require("./ovok-errors");
+async function errorFromResponse(response) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const fallback = Object.assign(new Error(`Ovok API answered ${response.status}`), {
+        status: response.status,
+        body: parseBody(await response.text()),
+    });
+    const details = (0, ovok_error_1.readOvokError)(fallback);
+    return (0, ovok_errors_1.errorForStatus)({
+        status: response.status,
+        code: (_a = details.code) !== null && _a !== void 0 ? _a : null,
+        type: (_b = details.type) !== null && _b !== void 0 ? _b : null,
+        message: details.message,
+        traceId: (_d = (_c = response.headers.get("x-trace-id")) !== null && _c !== void 0 ? _c : details.traceId) !== null && _d !== void 0 ? _d : null,
+        requestId: (_f = (_e = response.headers.get("x-request-id")) !== null && _e !== void 0 ? _e : details.requestId) !== null && _f !== void 0 ? _f : null,
+        retryAfterMs: (_h = (_g = (0, retry_after_1.retryAfterMs)(response.headers.get("retry-after"))) !== null && _g !== void 0 ? _g : details.retryAfterMs) !== null && _h !== void 0 ? _h : null,
+        fieldErrors: details.fieldErrors,
+    });
+}
+const parseBody = (text) => {
+    if (text === "") {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return { message: text };
+    }
+};

package/dist/next/errors/ovok-account-error.d.ts

@@ -0,0 +1,5 @@
+export type OvokAccountErrorCode = "account_not_found" | "account_expired";
+export declare class OvokAccountError extends Error {
+    readonly code: OvokAccountErrorCode;
+    constructor(code: OvokAccountErrorCode);
+}

package/dist/next/errors/ovok-account-error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OvokAccountError = void 0;
+class OvokAccountError extends Error {
+    constructor(code) {
+        super(code === "account_not_found"
+            ? "Saved account was not found."
+            : "This account's session has expired. Sign in again.");
+        this.code = code;
+        this.name = "OvokAccountError";
+    }
+}
+exports.OvokAccountError = OvokAccountError;

package/dist/next/errors/ovok-errors.d.ts

@@ -0,0 +1,42 @@
+import { ValidationError } from "../../types/ValidationError";
+export type OvokErrorDetails = {
+    status: number | null;
+    code: string | null;
+    type: string | null;
+    message: string;
+    traceId: string | null;
+    requestId: string | null;
+    retryAfterMs: number | null;
+    fieldErrors: ValidationError[];
+};
+export declare class OvokError extends Error {
+    readonly status: number | null;
+    readonly code: string | null;
+    readonly type: string | null;
+    readonly traceId: string | null;
+    readonly requestId: string | null;
+    readonly retryAfterMs: number | null;
+    readonly fieldErrors: ValidationError[];
+    readonly cause: unknown;
+    constructor(details: OvokErrorDetails, cause?: unknown);
+}
+export declare class OvokValidationError extends OvokError {
+}
+export declare class OvokAuthenticationError extends OvokError {
+}
+export declare class OvokPermissionError extends OvokError {
+}
+export declare class OvokNotFoundError extends OvokError {
+}
+export declare class OvokConflictError extends OvokError {
+}
+export declare class OvokRateLimitError extends OvokError {
+}
+export declare class OvokServiceError extends OvokError {
+}
+export declare class OvokConnectionError extends OvokError {
+}
+export declare class OvokConfigError extends OvokError {
+}
+export declare function errorForStatus(details: OvokErrorDetails): OvokError;
+export declare const detailsFor: (message: string) => OvokErrorDetails;

package/dist/next/errors/ovok-errors.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detailsFor = exports.OvokConfigError = exports.OvokConnectionError = exports.OvokServiceError = exports.OvokRateLimitError = exports.OvokConflictError = exports.OvokNotFoundError = exports.OvokPermissionError = exports.OvokAuthenticationError = exports.OvokValidationError = exports.OvokError = void 0;
+exports.errorForStatus = errorForStatus;
+class OvokError extends Error {
+    constructor(details, cause) {
+        super(details.message);
+        this.name = new.target.name;
+        this.status = details.status;
+        this.code = details.code;
+        this.type = details.type;
+        this.traceId = details.traceId;
+        this.requestId = details.requestId;
+        this.retryAfterMs = details.retryAfterMs;
+        this.fieldErrors = details.fieldErrors;
+        Object.defineProperty(this, "cause", { value: cause, enumerable: false });
+    }
+}
+exports.OvokError = OvokError;
+class OvokValidationError extends OvokError {
+}
+exports.OvokValidationError = OvokValidationError;
+class OvokAuthenticationError extends OvokError {
+}
+exports.OvokAuthenticationError = OvokAuthenticationError;
+class OvokPermissionError extends OvokError {
+}
+exports.OvokPermissionError = OvokPermissionError;
+class OvokNotFoundError extends OvokError {
+}
+exports.OvokNotFoundError = OvokNotFoundError;
+class OvokConflictError extends OvokError {
+}
+exports.OvokConflictError = OvokConflictError;
+class OvokRateLimitError extends OvokError {
+}
+exports.OvokRateLimitError = OvokRateLimitError;
+class OvokServiceError extends OvokError {
+}
+exports.OvokServiceError = OvokServiceError;
+class OvokConnectionError extends OvokError {
+}
+exports.OvokConnectionError = OvokConnectionError;
+class OvokConfigError extends OvokError {
+}
+exports.OvokConfigError = OvokConfigError;
+const ERROR_CLASS_BY_STATUS = {
+    400: OvokValidationError,
+    401: OvokAuthenticationError,
+    403: OvokPermissionError,
+    404: OvokNotFoundError,
+    409: OvokConflictError,
+    422: OvokValidationError,
+    429: OvokRateLimitError,
+};
+const FIRST_SERVER_ERROR_STATUS = 500;
+function errorForStatus(details) {
+    var _a, _b;
+    const status = (_a = details.status) !== null && _a !== void 0 ? _a : 0;
+    const isServerError = status >= FIRST_SERVER_ERROR_STATUS;
+    const errorClass = isServerError ? OvokServiceError : (_b = ERROR_CLASS_BY_STATUS[status]) !== null && _b !== void 0 ? _b : OvokError;
+    return new errorClass(details);
+}
+const detailsFor = (message) => ({
+    status: null,
+    code: null,
+    type: null,
+    message,
+    traceId: null,
+    requestId: null,
+    retryAfterMs: null,
+    fieldErrors: [],
+});
+exports.detailsFor = detailsFor;

package/dist/next/http/http-client.d.ts

@@ -0,0 +1,36 @@
+import { Credentials } from "../auth/credentials";
+import { OvokSettings } from "../config/ovok-config";
+import { RetryPolicy } from "./retry-policy";
+import { RequestOptions } from "./transmit";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type HttpRequest = {
+    method: HttpMethod;
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    idempotent?: boolean;
+};
+export type HttpContext = {
+    settings: OvokSettings;
+    credentials: Credentials;
+    retryPolicy: RetryPolicy;
+};
+export declare class HttpClient {
+    private readonly context;
+    private readonly basePath;
+    constructor(context: HttpContext, basePath?: string);
+    under(path: string): HttpClient;
+    anonymous(): HttpClient;
+    withCredentials(credentials: Credentials): HttpClient;
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = void>(path: string, options?: RequestOptions): Promise<T>;
+    send<T>(request: HttpRequest, options?: RequestOptions): Promise<T>;
+    private sendAuthorized;
+    private sendWithRetries;
+    private attempt;
+    private isRetryable;
+    private toTransmit;
+}