hume 0.15.3-beta.2 → 0.15.3

package/dist/cjs/core/fetcher/Fetcher.js

@@ -12,7 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetcher = void 0;
 exports.fetcherImpl = fetcherImpl;
 const json_js_1 = require("../json.js");
+const logger_js_1 = require("../logging/logger.js");
 const createRequestUrl_js_1 = require("./createRequestUrl.js");
+const EndpointSupplier_js_1 = require("./EndpointSupplier.js");
 const getErrorResponseBody_js_1 = require("./getErrorResponseBody.js");
 const getFetchFn_js_1 = require("./getFetchFn.js");
 const getRequestBody_js_1 = require("./getRequestBody.js");
@@ -20,9 +22,125 @@ const getResponseBody_js_1 = require("./getResponseBody.js");
 const makeRequest_js_1 = require("./makeRequest.js");
 const RawResponse_js_1 = require("./RawResponse.js");
 const requestWithRetries_js_1 = require("./requestWithRetries.js");
-const Supplier_js_1 = require("./Supplier.js");
+const SENSITIVE_HEADERS = new Set([
+    "authorization",
+    "x-api-key",
+    "api-key",
+    "x-auth-token",
+    "cookie",
+    "set-cookie",
+    "proxy-authorization",
+    "x-csrf-token",
+    "x-xsrf-token",
+]);
+function redactHeaders(headers) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (SENSITIVE_HEADERS.has(key.toLowerCase())) {
+            filtered[key] = "[REDACTED]";
+        }
+        else {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
+const SENSITIVE_QUERY_PARAMS = new Set([
+    "api_key",
+    "api-key",
+    "apikey",
+    "token",
+    "access_token",
+    "access-token",
+    "auth_token",
+    "auth-token",
+    "password",
+    "passwd",
+    "secret",
+    "api_secret",
+    "api-secret",
+    "apisecret",
+    "key",
+    "session",
+    "session_id",
+    "session-id",
+]);
+function redactQueryParameters(queryParameters) {
+    if (queryParameters == null) {
+        return queryParameters;
+    }
+    const redacted = {};
+    for (const [key, value] of Object.entries(queryParameters)) {
+        if (SENSITIVE_QUERY_PARAMS.has(key.toLowerCase())) {
+            redacted[key] = "[REDACTED]";
+        }
+        else {
+            redacted[key] = value;
+        }
+    }
+    return redacted;
+}
+function redactUrl(url) {
+    const protocolIndex = url.indexOf("://");
+    if (protocolIndex === -1)
+        return url;
+    const afterProtocol = protocolIndex + 3;
+    const atIndex = url.indexOf("@", afterProtocol);
+    if (atIndex !== -1) {
+        const pathStart = url.indexOf("/", afterProtocol);
+        const queryStart = url.indexOf("?", afterProtocol);
+        const fragmentStart = url.indexOf("#", afterProtocol);
+        const firstDelimiter = Math.min(pathStart === -1 ? url.length : pathStart, queryStart === -1 ? url.length : queryStart, fragmentStart === -1 ? url.length : fragmentStart);
+        if (atIndex < firstDelimiter) {
+            url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+        }
+    }
+    const queryStart = url.indexOf("?");
+    if (queryStart === -1)
+        return url;
+    const fragmentStart = url.indexOf("#", queryStart);
+    const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+    const queryString = url.slice(queryStart + 1, queryEnd);
+    if (queryString.length === 0)
+        return url;
+    // FAST PATH: Quick check if any sensitive keywords present
+    // Using indexOf is faster than regex for simple substring matching
+    const lower = queryString.toLowerCase();
+    const hasSensitive = lower.includes("token") || // catches token, access_token, auth_token, etc.
+        lower.includes("key") || // catches key, api_key, apikey, api-key, etc.
+        lower.includes("password") || // catches password
+        lower.includes("passwd") || // catches passwd
+        lower.includes("secret") || // catches secret, api_secret, etc.
+        lower.includes("session") || // catches session, session_id, session-id
+        lower.includes("auth"); // catches auth_token, auth-token, etc.
+    if (!hasSensitive) {
+        return url; // Early exit - no sensitive params
+    }
+    // SLOW PATH: Parse and redact
+    const redactedParams = [];
+    const params = queryString.split("&");
+    for (const param of params) {
+        const equalIndex = param.indexOf("=");
+        if (equalIndex === -1) {
+            redactedParams.push(param);
+            continue;
+        }
+        const key = param.slice(0, equalIndex);
+        let shouldRedact = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+        if (!shouldRedact && key.includes("%")) {
+            try {
+                const decodedKey = decodeURIComponent(key);
+                shouldRedact = SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+            }
+            catch (_a) { }
+        }
+        redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+    }
+    return url.slice(0, queryStart + 1) + redactedParams.join("&") + url.slice(queryEnd);
+}
 function getHeaders(args) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const newHeaders = {};
         if (args.body !== undefined && args.contentType != null) {
             newHeaders["Content-Type"] = args.contentType;
@@ -31,7 +149,7 @@ function getHeaders(args) {
             return newHeaders;
         }
         for (const [key, value] of Object.entries(args.headers)) {
-            const result = yield Supplier_js_1.Supplier.get(value);
+            const result = yield EndpointSupplier_js_1.EndpointSupplier.get(value, { endpointMetadata: (_a = args.endpointMetadata) !== null && _a !== void 0 ? _a : {} });
             if (typeof result === "string") {
                 newHeaders[key] = result;
                 continue;
@@ -46,17 +164,38 @@ function getHeaders(args) {
 }
 function fetcherImpl(args) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const url = (0, createRequestUrl_js_1.createRequestUrl)(args.url, args.queryParameters);
         const requestBody = yield (0, getRequestBody_js_1.getRequestBody)({
             body: args.body,
-            type: args.requestType === "json" ? "json" : "other",
+            type: (_a = args.requestType) !== null && _a !== void 0 ? _a : "other",
         });
-        const fetchFn = yield (0, getFetchFn_js_1.getFetchFn)();
+        const fetchFn = (_b = args.fetchFn) !== null && _b !== void 0 ? _b : (yield (0, getFetchFn_js_1.getFetchFn)());
+        const headers = yield getHeaders(args);
+        const logger = (0, logger_js_1.createLogger)(args.logging);
+        if (logger.isDebug()) {
+            const metadata = {
+                method: args.method,
+                url: redactUrl(url),
+                headers: redactHeaders(headers),
+                queryParameters: redactQueryParameters(args.queryParameters),
+                hasBody: requestBody != null,
+            };
+            logger.debug("Making HTTP request", metadata);
+        }
         try {
             const response = yield (0, requestWithRetries_js_1.requestWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
-                return (0, makeRequest_js_1.makeRequest)(fetchFn, url, args.method, yield getHeaders(args), requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
+                return (0, makeRequest_js_1.makeRequest)(fetchFn, url, args.method, headers, requestBody, args.timeoutMs, args.abortSignal, args.withCredentials, args.duplex);
             }), args.maxRetries);
             if (response.status >= 200 && response.status < 400) {
+                if (logger.isDebug()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        statusCode: response.status,
+                    };
+                    logger.debug("HTTP request succeeded", metadata);
+                }
                 return {
                     ok: true,
                     body: (yield (0, getResponseBody_js_1.getResponseBody)(response, args.responseType)),
@@ -65,6 +204,14 @@ function fetcherImpl(args) {
                 };
             }
             else {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        statusCode: response.status,
+                    };
+                    logger.error("HTTP request failed with error status", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -77,7 +224,14 @@ function fetcherImpl(args) {
             }
         }
         catch (error) {
-            if (args.abortSignal != null && args.abortSignal.aborted) {
+            if ((_c = args.abortSignal) === null || _c === void 0 ? void 0 : _c.aborted) {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                    };
+                    logger.error("HTTP request was aborted", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -88,6 +242,14 @@ function fetcherImpl(args) {
                 };
             }
             else if (error instanceof Error && error.name === "AbortError") {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        timeoutMs: args.timeoutMs,
+                    };
+                    logger.error("HTTP request timed out", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -97,6 +259,14 @@ function fetcherImpl(args) {
                 };
             }
             else if (error instanceof Error) {
+                if (logger.isError()) {
+                    const metadata = {
+                        method: args.method,
+                        url: redactUrl(url),
+                        errorMessage: error.message,
+                    };
+                    logger.error("HTTP request failed with error", metadata);
+                }
                 return {
                     ok: false,
                     error: {
@@ -106,6 +276,14 @@ function fetcherImpl(args) {
                     rawResponse: RawResponse_js_1.unknownRawResponse,
                 };
             }
+            if (logger.isError()) {
+                const metadata = {
+                    method: args.method,
+                    url: redactUrl(url),
+                    error: (0, json_js_1.toJson)(error),
+                };
+                logger.error("HTTP request failed with unknown error", metadata);
+            }
             return {
                 ok: false,
                 error: {

package/dist/cjs/core/fetcher/HttpResponsePromise.d.ts

@@ -1,4 +1,4 @@
-import { WithRawResponse } from "./RawResponse.js";
+import type { WithRawResponse } from "./RawResponse.js";
 /**
  * A promise that returns the parsed response and lets you retrieve the raw response too.
  */

package/dist/cjs/core/fetcher/getErrorResponseBody.js

@@ -28,9 +28,10 @@ function getErrorResponseBody(response) {
             case "application/ld+json":
             case "application/problem+json":
             case "application/vnd.api+json":
-            case "text/json":
+            case "text/json": {
                 const text = yield response.text();
                 return text.length > 0 ? (0, json_js_1.fromJson)(text) : undefined;
+            }
             default:
                 if (contentType.startsWith("application/vnd.") && contentType.endsWith("+json")) {
                     const text = yield response.text();

package/dist/cjs/core/fetcher/getRequestBody.d.ts

@@ -1,7 +1,7 @@
 export declare namespace GetRequestBody {
     interface Args {
         body: unknown;
-        type: "json" | "file" | "bytes" | "other";
+        type: "json" | "file" | "bytes" | "form" | "other";
     }
 }
 export declare function getRequestBody({ body, type }: GetRequestBody.Args): Promise<BodyInit | undefined>;

package/dist/cjs/core/fetcher/getRequestBody.js

@@ -11,8 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRequestBody = getRequestBody;
 const json_js_1 = require("../json.js");
+const qs_js_1 = require("../url/qs.js");
 function getRequestBody(_a) {
     return __awaiter(this, arguments, void 0, function* ({ body, type }) {
+        if (type === "form") {
+            return (0, qs_js_1.toQueryString)(body, { arrayFormat: "repeat", encode: true });
+        }
         if (type.includes("json")) {
             return (0, json_js_1.toJson)(body);
         }

package/dist/cjs/core/fetcher/getResponseBody.js

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getResponseBody = getResponseBody;
+const json_js_1 = require("../json.js");
 const BinaryResponse_js_1 = require("./BinaryResponse.js");
 const ResponseWithBody_js_1 = require("./ResponseWithBody.js");
-const json_js_1 = require("../json.js");
 function getResponseBody(response, responseType) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!(0, ResponseWithBody_js_1.isResponseWithBody)(response)) {
@@ -36,10 +36,10 @@ function getResponseBody(response, responseType) {
         const text = yield response.text();
         if (text.length > 0) {
             try {
-                let responseBody = (0, json_js_1.fromJson)(text);
+                const responseBody = (0, json_js_1.fromJson)(text);
                 return responseBody;
             }
-            catch (err) {
+            catch (_err) {
                 return {
                     ok: false,
                     error: {

package/dist/cjs/core/fetcher/index.d.ts

@@ -1,5 +1,7 @@
 export type { APIResponse } from "./APIResponse.js";
 export type { BinaryResponse } from "./BinaryResponse.js";
+export type { EndpointMetadata } from "./EndpointMetadata.js";
+export { EndpointSupplier } from "./EndpointSupplier.js";
 export type { Fetcher, FetchFunction } from "./Fetcher.js";
 export { fetcher } from "./Fetcher.js";
 export { getHeader } from "./getHeader.js";

package/dist/cjs/core/fetcher/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Supplier = exports.unknownRawResponse = exports.toRawResponse = exports.abortRawResponse = exports.HttpResponsePromise = exports.getHeader = exports.fetcher = void 0;
+exports.Supplier = exports.unknownRawResponse = exports.toRawResponse = exports.abortRawResponse = exports.HttpResponsePromise = exports.getHeader = exports.fetcher = exports.EndpointSupplier = void 0;
+var EndpointSupplier_js_1 = require("./EndpointSupplier.js");
+Object.defineProperty(exports, "EndpointSupplier", { enumerable: true, get: function () { return EndpointSupplier_js_1.EndpointSupplier; } });
 var Fetcher_js_1 = require("./Fetcher.js");
 Object.defineProperty(exports, "fetcher", { enumerable: true, get: function () { return Fetcher_js_1.fetcher; } });
 var getHeader_js_1 = require("./getHeader.js");

package/dist/cjs/core/fetcher/makeRequest.js

@@ -14,7 +14,7 @@ const signals_js_1 = require("./signals.js");
 const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex) => __awaiter(void 0, void 0, void 0, function* () {
     const signals = [];
     // Add timeout signal
-    let timeoutAbortId = undefined;
+    let timeoutAbortId;
     if (timeoutMs != null) {
         const { signal, abortId } = (0, signals_js_1.getTimeoutSignal)(timeoutMs);
         timeoutAbortId = abortId;
@@ -24,7 +24,7 @@ const makeRequest = (fetchFn, url, method, headers, requestBody, timeoutMs, abor
     if (abortSignal != null) {
         signals.push(abortSignal);
     }
-    let newSignals = (0, signals_js_1.anySignal)(signals);
+    const newSignals = (0, signals_js_1.anySignal)(signals);
     const response = yield fetchFn(url, {
         method: method,
         headers,

package/dist/cjs/core/fetcher/requestWithRetries.js

@@ -14,53 +14,57 @@ const INITIAL_RETRY_DELAY = 1000; // in milliseconds
 const MAX_RETRY_DELAY = 60000; // in milliseconds
 const DEFAULT_MAX_RETRIES = 2;
 const JITTER_FACTOR = 0.2; // 20% random jitter
-function addJitter(delay) {
-    // Generate a random value between -JITTER_FACTOR and +JITTER_FACTOR
-    const jitterMultiplier = 1 + (Math.random() * 2 - 1) * JITTER_FACTOR;
+function addPositiveJitter(delay) {
+    // Generate a random value between 0 and +JITTER_FACTOR
+    const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+    // Generate a random value in a JITTER_FACTOR-sized percentage range around delay
+    const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
     return delay * jitterMultiplier;
 }
 function getRetryDelayFromHeaders(response, retryAttempt) {
-    // Check for Retry-After header first (RFC 7231)
+    // Check for Retry-After header first (RFC 7231), with no jitter
     const retryAfter = response.headers.get("Retry-After");
     if (retryAfter) {
         // Parse as number of seconds...
         const retryAfterSeconds = parseInt(retryAfter, 10);
-        if (!isNaN(retryAfterSeconds)) {
-            // Convert seconds to milliseconds and cap at MAX_RETRY_DELAY
+        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
             return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
         }
         // ...or as an HTTP date; both are valid
         const retryAfterDate = new Date(retryAfter);
-        if (!isNaN(retryAfterDate.getTime())) {
+        if (!Number.isNaN(retryAfterDate.getTime())) {
             const delay = retryAfterDate.getTime() - Date.now();
-            return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+            if (delay > 0) {
+                return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+            }
         }
     }
-    // Then check for industry-standard X-RateLimit-Reset header
+    // Then check for industry-standard X-RateLimit-Reset header, with positive jitter
     const rateLimitReset = response.headers.get("X-RateLimit-Reset");
     if (rateLimitReset) {
         const resetTime = parseInt(rateLimitReset, 10);
-        if (!isNaN(resetTime)) {
+        if (!Number.isNaN(resetTime)) {
             // Assume Unix timestamp in epoch seconds
             const delay = resetTime * 1000 - Date.now();
             if (delay > 0) {
-                return Math.min(delay, MAX_RETRY_DELAY);
+                return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
             }
         }
     }
-    // Fall back to exponential backoff
-    return Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY);
+    // Fall back to exponential backoff, with symmetric jitter
+    return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * Math.pow(2, retryAttempt), MAX_RETRY_DELAY));
 }
 function requestWithRetries(requestFn_1) {
     return __awaiter(this, arguments, void 0, function* (requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
         let response = yield requestFn();
         for (let i = 0; i < maxRetries; ++i) {
             if ([408, 429].includes(response.status) || response.status >= 500) {
-                // Get delay from headers or fall back to exponential backoff
-                const baseDelay = getRetryDelayFromHeaders(response, i);
-                // Add jitter to the delay
-                const delayWithJitter = addJitter(baseDelay);
-                yield new Promise((resolve) => setTimeout(resolve, delayWithJitter));
+                // Get delay with appropriate jitter applied
+                const delay = getRetryDelayFromHeaders(response, i);
+                yield new Promise((resolve) => setTimeout(resolve, delay));
                 response = yield requestFn();
             }
             else {

package/dist/cjs/core/file/exports.d.ts

@@ -1 +1 @@
-export { Uploadable } from "./types.js";
+export type { Uploadable } from "./types.js";

package/dist/cjs/core/file/file.d.ts

@@ -1,5 +1,10 @@
-import { Uploadable } from "./types.js";
+import type { Uploadable } from "./types.js";
 export declare function toBinaryUploadRequest(file: Uploadable): Promise<{
     body: Uploadable.FileLike;
     headers?: Record<string, string>;
 }>;
+export declare function toMultipartDataPart(file: Uploadable): Promise<{
+    data: Uploadable.FileLike;
+    filename?: string;
+    contentType?: string;
+}>;

package/dist/cjs/core/file/file.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toBinaryUploadRequest = toBinaryUploadRequest;
+exports.toMultipartDataPart = toMultipartDataPart;
 function toBinaryUploadRequest(file) {
     return __awaiter(this, void 0, void 0, function* () {
         const { data, filename, contentLength, contentType } = yield getFileWithMetadata(file);
@@ -62,13 +63,25 @@ function toBinaryUploadRequest(file) {
         return request;
     });
 }
-function getFileWithMetadata(file) {
+function toMultipartDataPart(file) {
     return __awaiter(this, void 0, void 0, function* () {
+        const { data, filename, contentType } = yield getFileWithMetadata(file, {
+            noSniffFileSize: true,
+        });
+        return {
+            data,
+            filename,
+            contentType,
+        };
+    });
+}
+function getFileWithMetadata(file_1) {
+    return __awaiter(this, arguments, void 0, function* (file, { noSniffFileSize } = {}) {
         var _a, _b, _c, _d, _e;
         if (isFileLike(file)) {
             return getFileWithMetadata({
                 data: file,
-            });
+            }, { noSniffFileSize });
         }
         if ("path" in file) {
             const fs = yield Promise.resolve().then(() => __importStar(require("fs")));
@@ -76,7 +89,7 @@ function getFileWithMetadata(file) {
                 throw new Error("File path uploads are not supported in this environment.");
             }
             const data = fs.createReadStream(file.path);
-            const contentLength = (_a = file.contentLength) !== null && _a !== void 0 ? _a : (yield tryGetFileSizeFromPath(file.path));
+            const contentLength = (_a = file.contentLength) !== null && _a !== void 0 ? _a : (noSniffFileSize === true ? undefined : yield tryGetFileSizeFromPath(file.path));
             const filename = (_b = file.filename) !== null && _b !== void 0 ? _b : getNameFromPath(file.path);
             return {
                 data,
@@ -87,7 +100,9 @@ function getFileWithMetadata(file) {
         }
         if ("data" in file) {
             const data = file.data;
-            const contentLength = (_c = file.contentLength) !== null && _c !== void 0 ? _c : (yield tryGetContentLengthFromFileLike(data));
+            const contentLength = (_c = file.contentLength) !== null && _c !== void 0 ? _c : (yield tryGetContentLengthFromFileLike(data, {
+                noSniffFileSize,
+            }));
             const filename = (_d = file.filename) !== null && _d !== void 0 ? _d : tryGetNameFromFileLike(data);
             return {
                 data,
@@ -119,7 +134,7 @@ function tryGetFileSizeFromPath(path) {
             const fileStat = yield fs.promises.stat(path);
             return fileStat.size;
         }
-        catch (fallbackError) {
+        catch (_fallbackError) {
             return undefined;
         }
     });
@@ -133,8 +148,8 @@ function tryGetNameFromFileLike(data) {
     }
     return undefined;
 }
-function tryGetContentLengthFromFileLike(data) {
-    return __awaiter(this, void 0, void 0, function* () {
+function tryGetContentLengthFromFileLike(data_1) {
+    return __awaiter(this, arguments, void 0, function* (data, { noSniffFileSize } = {}) {
         if (isBuffer(data)) {
             return data.length;
         }
@@ -150,6 +165,9 @@ function tryGetContentLengthFromFileLike(data) {
         if (isFile(data)) {
             return data.size;
         }
+        if (noSniffFileSize === true) {
+            return undefined;
+        }
         if (isPathedValue(data)) {
             return yield tryGetFileSizeFromPath(data.path.toString());
         }

package/dist/cjs/core/form-data-utils/FormDataWrapper.d.ts

@@ -1,3 +1,4 @@
+import { type Uploadable } from "../../core/file/index.js";
 interface FormDataRequest<Body> {
     body: Body;
     headers: Record<string, string>;
@@ -8,9 +9,7 @@ export declare class FormDataWrapper {
     private fd;
     setup(): Promise<void>;
     append(key: string, value: unknown): void;
-    private getFileName;
-    private convertToBlob;
-    appendFile(key: string, value: unknown, fileName?: string): Promise<void>;
+    appendFile(key: string, value: Uploadable): Promise<void>;
     getRequest(): FormDataRequest<FormData>;
 }
 export {};