lampamazaza-new-internal-utils 0.24.3

package/dist/utils/poll.d.ts

@@ -0,0 +1,54 @@
+import { BaseError } from "../errors/base.js";
+
+//#region src/utils/poll.d.ts
+
+/**
+ * Sentinel value to signal that polling should continue.
+ * Return this from the poll function to indicate "not done yet".
+ */
+declare const POLL_PENDING: unique symbol;
+type PollTimeoutErrorType = PollTimeoutError & {
+  name: "PollTimeoutError";
+};
+declare class PollTimeoutError extends BaseError {
+  elapsedMs: number;
+  timeoutMs: number;
+  name: "PollTimeoutError";
+  constructor(elapsedMs: number, timeoutMs: number);
+}
+interface CompletionStats {
+  /** 50th percentile (median completion time in ms) */
+  p50: number;
+  /** 90th percentile (in ms) */
+  p90: number;
+  /** 99th percentile - hard timeout (in ms) */
+  p99: number;
+}
+interface PollOptions {
+  stats: CompletionStats;
+  signal?: AbortSignal;
+  /** Minimum interval floor (default: 300ms) */
+  minInterval?: number;
+  /** Maximum interval ceiling (default: 30000ms) */
+  maxInterval?: number;
+}
+/**
+ * Polls a function using latency-optimized intervals.
+ *
+ * Polls aggressively early (when completion is most likely), backs off later
+ * for outliers. Optimized for latency-sensitive operations like swaps.
+ *
+ * Interval strategy:
+ * - 0 → p50: HOT (300ms) - most completions happen here (~50%)
+ * - p50 → p90: COOLING (3s) - moderate polling (~40%)
+ * - p90 → p99: COLD (10s) - back off for outliers (~9%)
+ *
+ * @param fn - Function to poll. Return POLL_PENDING to continue, any other value to complete.
+ * @param options - Polling configuration with completion stats
+ * @returns The resolved value from fn
+ * @throws PollTimeoutError when p99 is exceeded
+ * @throws AbortError when signal is aborted
+ */
+declare function poll<T>(fn: () => Promise<T | typeof POLL_PENDING>, options: PollOptions): Promise<T>;
+//#endregion
+export { CompletionStats, POLL_PENDING, PollOptions, PollTimeoutError, PollTimeoutErrorType, poll };

package/dist/utils/poll.js

@@ -0,0 +1,85 @@
+import { BaseError } from "../errors/base.js";
+
+//#region src/utils/poll.ts
+const PHASE = {
+	HOT: "HOT",
+	COOLING: "COOLING",
+	COLD: "COLD"
+};
+const DEFAULT_INTERVALS = {
+	[PHASE.HOT]: 300,
+	[PHASE.COOLING]: 3e3,
+	[PHASE.COLD]: 1e4
+};
+/**
+* Sentinel value to signal that polling should continue.
+* Return this from the poll function to indicate "not done yet".
+*/
+const POLL_PENDING = Symbol("poll.pending");
+var PollTimeoutError = class extends BaseError {
+	constructor(elapsedMs, timeoutMs) {
+		super("Polling timed out", { details: `Operation did not complete within ${timeoutMs}ms (elapsed: ${elapsedMs}ms)` });
+		this.elapsedMs = elapsedMs;
+		this.timeoutMs = timeoutMs;
+		this.name = "PollTimeoutError";
+	}
+};
+/**
+* Polls a function using latency-optimized intervals.
+*
+* Polls aggressively early (when completion is most likely), backs off later
+* for outliers. Optimized for latency-sensitive operations like swaps.
+*
+* Interval strategy:
+* - 0 → p50: HOT (300ms) - most completions happen here (~50%)
+* - p50 → p90: COOLING (3s) - moderate polling (~40%)
+* - p90 → p99: COLD (10s) - back off for outliers (~9%)
+*
+* @param fn - Function to poll. Return POLL_PENDING to continue, any other value to complete.
+* @param options - Polling configuration with completion stats
+* @returns The resolved value from fn
+* @throws PollTimeoutError when p99 is exceeded
+* @throws AbortError when signal is aborted
+*/
+async function poll(fn, options) {
+	const { stats, signal, minInterval = 300, maxInterval = 3e4 } = options;
+	const { p50, p90, p99 } = stats;
+	const startTime = performance.now();
+	while (true) {
+		signal?.throwIfAborted();
+		const elapsed = performance.now() - startTime;
+		if (elapsed >= p99) throw new PollTimeoutError(elapsed, p99);
+		const result = await fn();
+		if (result !== POLL_PENDING) return result;
+		const rawInterval = DEFAULT_INTERVALS[getPhase(elapsed, p50, p90)];
+		await sleep(clamp(rawInterval, minInterval, maxInterval), signal);
+	}
+}
+function getPhase(elapsed, p50, p90) {
+	if (elapsed < p50) return PHASE.HOT;
+	if (elapsed < p90) return PHASE.COOLING;
+	return PHASE.COLD;
+}
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const abortHandler = () => {
+			clearTimeout(timeoutId);
+			reject(signal?.reason);
+		};
+		const timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", abortHandler);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", abortHandler);
+	});
+}
+
+//#endregion
+export { POLL_PENDING, PollTimeoutError, poll };

package/dist/utils/prepareBroadcastRequest.cjs

@@ -0,0 +1,98 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_assert = require('./assert.cjs');
+const require_stellarAddressToBytes = require('./stellarAddressToBytes.cjs');
+const require_webauthn = require('./multiPayload/webauthn.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/utils/prepareBroadcastRequest.ts
+var prepareBroadcastRequest_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	normalizeERC191Signature: () => normalizeERC191Signature,
+	prepareSwapSignedData: () => prepareSwapSignedData,
+	transformERC191Signature: () => transformERC191Signature
+});
+function prepareSwapSignedData(signature, userInfo) {
+	switch (signature.type) {
+		case "NEP413": return {
+			standard: "nep413",
+			payload: {
+				message: signature.signedData.message,
+				nonce: _scure_base.base64.encode(signature.signedData.nonce),
+				recipient: signature.signedData.recipient,
+				callbackUrl: signature.signedData.callbackUrl
+			},
+			public_key: signature.signatureData.publicKey,
+			signature: transformNEP141Signature(signature.signatureData.signature)
+		};
+		case "ERC191": return {
+			standard: "erc191",
+			payload: signature.signedData.message,
+			signature: transformERC191Signature(signature.signatureData)
+		};
+		case "SOLANA":
+			require_assert.assert(userInfo.userChainType === "solana", "User chain and signature chain must match");
+			return {
+				standard: "raw_ed25519",
+				payload: new TextDecoder().decode(signature.signedData.message),
+				public_key: `ed25519:${userInfo.userAddress}`,
+				signature: transformED25519Signature(signature.signatureData)
+			};
+		case "WEBAUTHN": return require_webauthn.makeWebAuthnMultiPayload(userInfo, signature);
+		case "TON_CONNECT": return {
+			standard: "ton_connect",
+			address: signature.signatureData.address,
+			domain: signature.signatureData.domain,
+			timestamp: signature.signatureData.timestamp,
+			payload: signature.signatureData.payload,
+			public_key: `ed25519:${_scure_base.base58.encode(_scure_base.hex.decode(userInfo.userAddress))}`,
+			signature: `ed25519:${_scure_base.base58.encode(_scure_base.base64.decode(signature.signatureData.signature))}`
+		};
+		case "STELLAR_SEP53":
+			require_assert.assert(userInfo.userChainType === "stellar", "User chain and signature chain must match");
+			return {
+				standard: "sep53",
+				payload: signature.signedData.message,
+				public_key: `ed25519:${_scure_base.base58.encode(require_stellarAddressToBytes.stellarAddressToBytes(userInfo.userAddress))}`,
+				signature: transformED25519Signature(signature.signatureData)
+			};
+		case "TRON": return {
+			standard: "tip191",
+			payload: signature.signedData.message,
+			signature: transformERC191Signature(signature.signatureData)
+		};
+		default: throw new Error("exhaustive check failed");
+	}
+}
+function transformNEP141Signature(signature) {
+	return `ed25519:${_scure_base.base58.encode(_scure_base.base64.decode(signature))}`;
+}
+function transformERC191Signature(signature) {
+	const normalizedSignature = normalizeERC191Signature(signature);
+	const bytes = _scure_base.hex.decode(normalizedSignature.startsWith("0x") ? normalizedSignature.slice(2) : normalizedSignature);
+	return `secp256k1:${_scure_base.base58.encode(bytes)}`;
+}
+function normalizeERC191Signature(signature) {
+	let v = Number.parseInt(signature.slice(-2), 16);
+	v = toRecoveryBit(v);
+	const vHex = v.toString(16).padStart(2, "0");
+	return signature.slice(0, -2) + vHex;
+}
+function toRecoveryBit(yParityOrV) {
+	if (yParityOrV === 0 || yParityOrV === 1) return yParityOrV;
+	if (yParityOrV === 27) return 0;
+	if (yParityOrV === 28) return 1;
+	throw new Error("Invalid yParityOrV value");
+}
+function transformED25519Signature(signature) {
+	return `ed25519:${_scure_base.base58.encode(signature)}`;
+}
+
+//#endregion
+exports.normalizeERC191Signature = normalizeERC191Signature;
+Object.defineProperty(exports, 'prepareBroadcastRequest_exports', {
+  enumerable: true,
+  get: function () {
+    return prepareBroadcastRequest_exports;
+  }
+});
+exports.prepareSwapSignedData = prepareSwapSignedData;
+exports.transformERC191Signature = transformERC191Signature;

package/dist/utils/prepareBroadcastRequest.d.cts

@@ -0,0 +1,16 @@
+import { Params, PublishIntentRequest } from "../solverRelay/solverRelayHttpClient/types.cjs";
+import { AuthMethod } from "../types/authHandle.cjs";
+import { WalletSignatureResult } from "../types/walletMessage.cjs";
+
+//#region src/utils/prepareBroadcastRequest.d.ts
+declare namespace prepareBroadcastRequest_d_exports {
+  export { normalizeERC191Signature, prepareSwapSignedData, transformERC191Signature };
+}
+declare function prepareSwapSignedData(signature: WalletSignatureResult, userInfo: {
+  userAddress: string;
+  userChainType: AuthMethod;
+}): Params<PublishIntentRequest>["signed_data"];
+declare function transformERC191Signature(signature: string): string;
+declare function normalizeERC191Signature(signature: string): string;
+//#endregion
+export { normalizeERC191Signature, prepareBroadcastRequest_d_exports, prepareSwapSignedData, transformERC191Signature };

package/dist/utils/prepareBroadcastRequest.d.ts

@@ -0,0 +1,16 @@
+import { Params, PublishIntentRequest } from "../solverRelay/solverRelayHttpClient/types.js";
+import { AuthMethod } from "../types/authHandle.js";
+import { WalletSignatureResult } from "../types/walletMessage.js";
+
+//#region src/utils/prepareBroadcastRequest.d.ts
+declare namespace prepareBroadcastRequest_d_exports {
+  export { normalizeERC191Signature, prepareSwapSignedData, transformERC191Signature };
+}
+declare function prepareSwapSignedData(signature: WalletSignatureResult, userInfo: {
+  userAddress: string;
+  userChainType: AuthMethod;
+}): Params<PublishIntentRequest>["signed_data"];
+declare function transformERC191Signature(signature: string): string;
+declare function normalizeERC191Signature(signature: string): string;
+//#endregion
+export { normalizeERC191Signature, prepareBroadcastRequest_d_exports, prepareSwapSignedData, transformERC191Signature };

package/dist/utils/prepareBroadcastRequest.js

@@ -0,0 +1,90 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { assert } from "./assert.js";
+import { stellarAddressToBytes } from "./stellarAddressToBytes.js";
+import { makeWebAuthnMultiPayload } from "./multiPayload/webauthn.js";
+import { base58, base64, hex } from "@scure/base";
+
+//#region src/utils/prepareBroadcastRequest.ts
+var prepareBroadcastRequest_exports = /* @__PURE__ */ __exportAll({
+	normalizeERC191Signature: () => normalizeERC191Signature,
+	prepareSwapSignedData: () => prepareSwapSignedData,
+	transformERC191Signature: () => transformERC191Signature
+});
+function prepareSwapSignedData(signature, userInfo) {
+	switch (signature.type) {
+		case "NEP413": return {
+			standard: "nep413",
+			payload: {
+				message: signature.signedData.message,
+				nonce: base64.encode(signature.signedData.nonce),
+				recipient: signature.signedData.recipient,
+				callbackUrl: signature.signedData.callbackUrl
+			},
+			public_key: signature.signatureData.publicKey,
+			signature: transformNEP141Signature(signature.signatureData.signature)
+		};
+		case "ERC191": return {
+			standard: "erc191",
+			payload: signature.signedData.message,
+			signature: transformERC191Signature(signature.signatureData)
+		};
+		case "SOLANA":
+			assert(userInfo.userChainType === "solana", "User chain and signature chain must match");
+			return {
+				standard: "raw_ed25519",
+				payload: new TextDecoder().decode(signature.signedData.message),
+				public_key: `ed25519:${userInfo.userAddress}`,
+				signature: transformED25519Signature(signature.signatureData)
+			};
+		case "WEBAUTHN": return makeWebAuthnMultiPayload(userInfo, signature);
+		case "TON_CONNECT": return {
+			standard: "ton_connect",
+			address: signature.signatureData.address,
+			domain: signature.signatureData.domain,
+			timestamp: signature.signatureData.timestamp,
+			payload: signature.signatureData.payload,
+			public_key: `ed25519:${base58.encode(hex.decode(userInfo.userAddress))}`,
+			signature: `ed25519:${base58.encode(base64.decode(signature.signatureData.signature))}`
+		};
+		case "STELLAR_SEP53":
+			assert(userInfo.userChainType === "stellar", "User chain and signature chain must match");
+			return {
+				standard: "sep53",
+				payload: signature.signedData.message,
+				public_key: `ed25519:${base58.encode(stellarAddressToBytes(userInfo.userAddress))}`,
+				signature: transformED25519Signature(signature.signatureData)
+			};
+		case "TRON": return {
+			standard: "tip191",
+			payload: signature.signedData.message,
+			signature: transformERC191Signature(signature.signatureData)
+		};
+		default: throw new Error("exhaustive check failed");
+	}
+}
+function transformNEP141Signature(signature) {
+	return `ed25519:${base58.encode(base64.decode(signature))}`;
+}
+function transformERC191Signature(signature) {
+	const normalizedSignature = normalizeERC191Signature(signature);
+	const bytes = hex.decode(normalizedSignature.startsWith("0x") ? normalizedSignature.slice(2) : normalizedSignature);
+	return `secp256k1:${base58.encode(bytes)}`;
+}
+function normalizeERC191Signature(signature) {
+	let v = Number.parseInt(signature.slice(-2), 16);
+	v = toRecoveryBit(v);
+	const vHex = v.toString(16).padStart(2, "0");
+	return signature.slice(0, -2) + vHex;
+}
+function toRecoveryBit(yParityOrV) {
+	if (yParityOrV === 0 || yParityOrV === 1) return yParityOrV;
+	if (yParityOrV === 27) return 0;
+	if (yParityOrV === 28) return 1;
+	throw new Error("Invalid yParityOrV value");
+}
+function transformED25519Signature(signature) {
+	return `ed25519:${base58.encode(signature)}`;
+}
+
+//#endregion
+export { normalizeERC191Signature, prepareBroadcastRequest_exports, prepareSwapSignedData, transformERC191Signature };

package/dist/utils/promise/withTimeout.cjs

@@ -0,0 +1,34 @@
+const require_base = require('../../errors/base.cjs');
+
+//#region src/utils/promise/withTimeout.ts
+function withTimeout(fn, { errorInstance = /* @__PURE__ */ new Error("timed out"), timeout, signal }) {
+	return new Promise((resolve, reject) => {
+		(async () => {
+			let timeoutId;
+			try {
+				const controller = new AbortController();
+				if (timeout > 0) timeoutId = setTimeout(() => {
+					if (signal) controller.abort(new SpecialInternalTimeoutError());
+					else reject(errorInstance);
+				}, timeout);
+				resolve(await fn({ signal: signal ? controller.signal : null }));
+			} catch (err) {
+				if (err instanceof SpecialInternalTimeoutError) reject(errorInstance);
+				reject(err);
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		})();
+	});
+}
+var SpecialInternalTimeoutError = class extends require_base.BaseError {
+	constructor() {
+		super("Special internal timeout error.", {
+			name: "SpecialInternalTimeoutError",
+			details: "This error should be never be caught since another error instance is rethrown."
+		});
+	}
+};
+
+//#endregion
+exports.withTimeout = withTimeout;

package/dist/utils/promise/withTimeout.d.cts

@@ -0,0 +1,16 @@
+//#region src/utils/promise/withTimeout.d.ts
+declare function withTimeout<data>(fn: ({
+  signal
+}: {
+  signal: AbortController["signal"] | null;
+}) => Promise<data>, {
+  errorInstance,
+  timeout,
+  signal
+}: {
+  errorInstance?: Error | undefined;
+  timeout: number;
+  signal?: boolean | undefined;
+}): Promise<data>;
+//#endregion
+export { withTimeout };

package/dist/utils/promise/withTimeout.d.ts

@@ -0,0 +1,16 @@
+//#region src/utils/promise/withTimeout.d.ts
+declare function withTimeout<data>(fn: ({
+  signal
+}: {
+  signal: AbortController["signal"] | null;
+}) => Promise<data>, {
+  errorInstance,
+  timeout,
+  signal
+}: {
+  errorInstance?: Error | undefined;
+  timeout: number;
+  signal?: boolean | undefined;
+}): Promise<data>;
+//#endregion
+export { withTimeout };

package/dist/utils/promise/withTimeout.js

@@ -0,0 +1,34 @@
+import { BaseError } from "../../errors/base.js";
+
+//#region src/utils/promise/withTimeout.ts
+function withTimeout(fn, { errorInstance = /* @__PURE__ */ new Error("timed out"), timeout, signal }) {
+	return new Promise((resolve, reject) => {
+		(async () => {
+			let timeoutId;
+			try {
+				const controller = new AbortController();
+				if (timeout > 0) timeoutId = setTimeout(() => {
+					if (signal) controller.abort(new SpecialInternalTimeoutError());
+					else reject(errorInstance);
+				}, timeout);
+				resolve(await fn({ signal: signal ? controller.signal : null }));
+			} catch (err) {
+				if (err instanceof SpecialInternalTimeoutError) reject(errorInstance);
+				reject(err);
+			} finally {
+				clearTimeout(timeoutId);
+			}
+		})();
+	});
+}
+var SpecialInternalTimeoutError = class extends BaseError {
+	constructor() {
+		super("Special internal timeout error.", {
+			name: "SpecialInternalTimeoutError",
+			details: "This error should be never be caught since another error instance is rethrown."
+		});
+	}
+};
+
+//#endregion
+export { withTimeout };

package/dist/utils/request.cjs

@@ -0,0 +1,100 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_request = require('../errors/request.cjs');
+const require_isNetworkError = require('../errors/utils/isNetworkError.cjs');
+const require_toError = require('../errors/utils/toError.cjs');
+const require_abortSignal = require('./abortSignal.cjs');
+const require_withTimeout = require('./promise/withTimeout.cjs');
+const require_requestShouldRetry = require('./requestShouldRetry.cjs');
+let _lifeomic_attempt = require("@lifeomic/attempt");
+
+//#region src/utils/request.ts
+async function request({ retryOptions = { maxAttempts: 1 }, logger, ...params }) {
+	const overallStartTime = performance.now();
+	let totalNetworkTime = 0;
+	let attemptCount = 0;
+	const response = await (0, _lifeomic_attempt.retry)(async (ctx) => {
+		attemptCount = ctx.attemptNum + 1;
+		const attemptStartTime = performance.now();
+		logger?.debug("Sending HTTP request", {
+			url: params.url.toString(),
+			method: params.fetchOptions?.method || "GET",
+			body: JSON.stringify(params.body),
+			attempt: ctx.attemptNum
+		});
+		const response$1 = await request_(params);
+		const attemptDuration = performance.now() - attemptStartTime;
+		totalNetworkTime += attemptDuration;
+		logger?.debug("HTTP request attempt completed", {
+			attempt: ctx.attemptNum,
+			attemptDuration: Math.floor(attemptDuration),
+			statusCode: response$1.status,
+			success: response$1.ok,
+			responseSize: response$1.headers.get("content-length")
+		});
+		return response$1;
+	}, {
+		...retryOptions,
+		handleError: (err, context) => {
+			logger?.error("HTTP request attempt failed", {
+				attempt: context.attemptNum,
+				errorMessage: require_toError.toError(err).message
+			});
+			if (!require_requestShouldRetry.requestShouldRetry(err) || params.fetchOptions?.signal?.reason === err) context.abort();
+		}
+	});
+	const overallDuration = performance.now() - overallStartTime;
+	const retryOverhead = overallDuration - totalNetworkTime;
+	logger?.[attemptCount > 1 ? "info" : "debug"]("HTTP request completed", {
+		statusCode: response.status,
+		success: response.ok,
+		totalDuration: Math.floor(overallDuration),
+		networkTime: Math.floor(totalNetworkTime),
+		retryOverhead: Math.floor(retryOverhead),
+		attempts: attemptCount,
+		responseSize: response.headers.get("content-length")
+	});
+	return response;
+}
+async function request_({ url, body, timeout = 1e4, fetchOptions }) {
+	const { headers: customHeaders, method, signal: signal_ } = fetchOptions ?? {};
+	try {
+		const headers = new Headers(customHeaders);
+		headers.set("Content-Type", "application/json");
+		const response = await require_withTimeout.withTimeout(({ signal }) => {
+			return fetch(url, {
+				...fetchOptions,
+				method,
+				headers,
+				body: JSON.stringify(body),
+				signal: require_abortSignal.mergeAbortSignals([signal_, timeout > 0 ? signal : null].filter(Boolean))
+			});
+		}, {
+			errorInstance: new require_request.TimeoutError({
+				body,
+				url: url.toString()
+			}),
+			timeout,
+			signal: true
+		});
+		if (!response.ok) throw new require_request.HttpRequestError({
+			body,
+			details: response.statusText,
+			headers: response.headers,
+			status: response.status,
+			url: url.toString()
+		});
+		return response;
+	} catch (err) {
+		if (err instanceof require_request.HttpRequestError) throw err;
+		if (err instanceof require_request.TimeoutError) throw err;
+		if (require_isNetworkError.isNetworkError(err)) throw new require_request.HttpRequestError({
+			body,
+			cause: err,
+			url: url.toString()
+		});
+		throw err;
+	}
+}
+
+//#endregion
+exports.request = request;

package/dist/utils/request.d.cts

@@ -0,0 +1,27 @@
+import { HttpRequestError, TimeoutError } from "../errors/request.cjs";
+import { ILogger } from "../logger.cjs";
+import { RetryOptions } from "./retry.cjs";
+
+//#region src/utils/request.d.ts
+type RequestErrorType = HttpRequestError | TimeoutError;
+declare function request({
+  retryOptions,
+  logger,
+  ...params
+}: Parameters<typeof request_>[0] & {
+  retryOptions?: RetryOptions;
+  logger?: ILogger;
+}): Promise<Response>;
+declare function request_({
+  url,
+  body,
+  timeout,
+  fetchOptions
+}: {
+  url: string | URL;
+  body?: unknown | undefined;
+  timeout?: number | undefined;
+  fetchOptions?: Omit<RequestInit, "body"> | undefined;
+}): Promise<Response>;
+//#endregion
+export { RequestErrorType, request };

package/dist/utils/request.d.ts

@@ -0,0 +1,27 @@
+import { HttpRequestError, TimeoutError } from "../errors/request.js";
+import { ILogger } from "../logger.js";
+import { RetryOptions } from "./retry.js";
+
+//#region src/utils/request.d.ts
+type RequestErrorType = HttpRequestError | TimeoutError;
+declare function request({
+  retryOptions,
+  logger,
+  ...params
+}: Parameters<typeof request_>[0] & {
+  retryOptions?: RetryOptions;
+  logger?: ILogger;
+}): Promise<Response>;
+declare function request_({
+  url,
+  body,
+  timeout,
+  fetchOptions
+}: {
+  url: string | URL;
+  body?: unknown | undefined;
+  timeout?: number | undefined;
+  fetchOptions?: Omit<RequestInit, "body"> | undefined;
+}): Promise<Response>;
+//#endregion
+export { RequestErrorType, request };