newscatcher-catchall-sdk 1.1.2 → 1.4.0

package/dist/esm/api/types/index.mjs

@@ -1,35 +1,64 @@
+export * from "./AdditionalAttributes.mjs";
 export * from "./BaseRecord.mjs";
 export * from "./Citation.mjs";
+export * from "./CompanyAttributes.mjs";
 export * from "./CompanyEnrichmentOutput.mjs";
+export * from "./ConnectedEntity.mjs";
 export * from "./Context.mjs";
 export * from "./ContinueResponseDto.mjs";
+export * from "./CreateDatasetCsvResponse.mjs";
+export * from "./CreateEntitiesBatchResponse.mjs";
+export * from "./CreateEntityRequest.mjs";
+export * from "./CreateEntityResponse.mjs";
 export * from "./CreateMonitorResponseDto.mjs";
+export * from "./DatasetEntityIdsRequest.mjs";
+export * from "./DatasetEntityListResponse.mjs";
+export * from "./DatasetListResponse.mjs";
+export * from "./DatasetResponse.mjs";
+export * from "./DatasetSortBy.mjs";
+export * from "./DatasetStatus.mjs";
+export * from "./DatasetStatusEntry.mjs";
+export * from "./DatasetStatusHistoryResponse.mjs";
 export * from "./EndDate.mjs";
 export * from "./EnrichmentSchema.mjs";
 export * from "./EnrichmentType.mjs";
+export * from "./EntityListResponse.mjs";
+export * from "./EntityResponse.mjs";
+export * from "./EntitySortBy.mjs";
+export * from "./EntityStatus.mjs";
+export * from "./EntitySummary.mjs";
+export * from "./EntityType.mjs";
+export * from "./EntityValidationErrorBody.mjs";
 export * from "./Error_.mjs";
+export * from "./GetPlanLimitsResponseDto.mjs";
 export * from "./InitializeResponseDto.mjs";
 export * from "./JobStep.mjs";
 export * from "./Limit.mjs";
 export * from "./ListMonitorsResponseDto.mjs";
 export * from "./ListUserJobsResponseDto.mjs";
+export * from "./ManageEntitiesResponse.mjs";
 export * from "./MonitorCitation.mjs";
 export * from "./MonitorJobItem.mjs";
 export * from "./MonitorListItemDto.mjs";
 export * from "./MonitorRecord.mjs";
+export * from "./PlanFeature.mjs";
 export * from "./PublicJobStatus.mjs";
 export * from "./PullJobResponseDto.mjs";
 export * from "./PullMonitorResponseDto.mjs";
 export * from "./Query.mjs";
 export * from "./Record_.mjs";
 export * from "./ReferenceJob.mjs";
+export * from "./SkippedRow.mjs";
+export * from "./SortOrder.mjs";
 export * from "./StartDate.mjs";
 export * from "./StatusResponseDto.mjs";
 export * from "./SubmitResponseDto.mjs";
 export * from "./UpdateMonitorResponseDto.mjs";
+export * from "./UploadCsvToDatasetResponse.mjs";
 export * from "./UserJob.mjs";
 export * from "./ValidationErrorDetail.mjs";
 export * from "./ValidationErrorResponse.mjs";
+export * from "./ValidationReport.mjs";
 export * from "./ValidatorSchema.mjs";
 export * from "./WebhookDto.mjs";
 export * from "./WebhookPayload.mjs";

package/dist/esm/core/auth/BasicAuth.d.mts

@@ -1,6 +1,6 @@
 export interface BasicAuth {
-    username: string;
-    password: string;
+    username?: string;
+    password?: string;
 }
 export declare const BasicAuth: {
     toAuthorizationHeader: (basicAuth: BasicAuth | undefined) => string | undefined;

package/dist/esm/core/auth/BasicAuth.mjs

@@ -2,10 +2,16 @@ import { base64Decode, base64Encode } from "../base64.mjs";
 const BASIC_AUTH_HEADER_PREFIX = /^Basic /i;
 export const BasicAuth = {
     toAuthorizationHeader: (basicAuth) => {
+        var _a, _b;
         if (basicAuth == null) {
             return undefined;
         }
-        const token = base64Encode(`${basicAuth.username}:${basicAuth.password}`);
+        const username = (_a = basicAuth.username) !== null && _a !== void 0 ? _a : "";
+        const password = (_b = basicAuth.password) !== null && _b !== void 0 ? _b : "";
+        if (username === "" && password === "") {
+            return undefined;
+        }
+        const token = base64Encode(`${username}:${password}`);
         return `Basic ${token}`;
     },
     fromAuthorizationHeader: (header) => {

package/dist/esm/core/exports.d.mts

@@ -1 +1,2 @@
+export * from "./file/exports.mjs";
 export * from "./logging/exports.mjs";

package/dist/esm/core/exports.mjs

@@ -1 +1,2 @@
+export * from "./file/exports.mjs";
 export * from "./logging/exports.mjs";

package/dist/esm/core/fetcher/BinaryResponse.d.mts

@@ -14,6 +14,6 @@ export type BinaryResponse = {
      * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/bytes)
      * Some versions of the Fetch API may not support this method.
      */
-    bytes?(): ReturnType<Response["bytes"]>;
+    bytes?(): Promise<Uint8Array>;
 };
 export declare function getBinaryResponse(response: Response): BinaryResponse;

package/dist/esm/core/fetcher/Fetcher.d.mts

@@ -38,10 +38,12 @@ export declare namespace Fetcher {
     }
     interface TimeoutError {
         reason: "timeout";
+        cause?: unknown;
     }
     interface UnknownError {
         reason: "unknown";
         errorMessage: string;
+        cause?: unknown;
     }
 }
 export declare function fetcherImpl<R = unknown>(args: Fetcher.Args): Promise<APIResponse<R, Fetcher.Error>>;

package/dist/esm/core/fetcher/Fetcher.mjs

@@ -257,6 +257,7 @@ export function fetcherImpl(args) {
                     error: {
                         reason: "unknown",
                         errorMessage: "The user aborted a request",
+                        cause: error,
                     },
                     rawResponse: abortRawResponse,
                 };
@@ -274,6 +275,7 @@ export function fetcherImpl(args) {
                     ok: false,
                     error: {
                         reason: "timeout",
+                        cause: error,
                     },
                     rawResponse: abortRawResponse,
                 };
@@ -292,6 +294,7 @@ export function fetcherImpl(args) {
                     error: {
                         reason: "unknown",
                         errorMessage: error.message,
+                        cause: error,
                     },
                     rawResponse: unknownRawResponse,
                 };
@@ -309,6 +312,7 @@ export function fetcherImpl(args) {
                 error: {
                     reason: "unknown",
                     errorMessage: toJson(error),
+                    cause: error,
                 },
                 rawResponse: unknownRawResponse,
             };

package/dist/esm/core/fetcher/index.d.mts

@@ -6,6 +6,8 @@ export type { Fetcher, FetchFunction } from "./Fetcher.mjs";
 export { fetcher } from "./Fetcher.mjs";
 export { getHeader } from "./getHeader.mjs";
 export { HttpResponsePromise } from "./HttpResponsePromise.mjs";
+export type { PassthroughRequest } from "./makePassthroughRequest.mjs";
+export { makePassthroughRequest } from "./makePassthroughRequest.mjs";
 export type { RawResponse, WithRawResponse } from "./RawResponse.mjs";
 export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.mjs";
 export { Supplier } from "./Supplier.mjs";

package/dist/esm/core/fetcher/index.mjs

@@ -2,5 +2,6 @@ export { EndpointSupplier } from "./EndpointSupplier.mjs";
 export { fetcher } from "./Fetcher.mjs";
 export { getHeader } from "./getHeader.mjs";
 export { HttpResponsePromise } from "./HttpResponsePromise.mjs";
+export { makePassthroughRequest } from "./makePassthroughRequest.mjs";
 export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.mjs";
 export { Supplier } from "./Supplier.mjs";

package/dist/esm/core/fetcher/makePassthroughRequest.d.mts

@@ -0,0 +1,49 @@
+import { type LogConfig, type Logger } from "../logging/logger.mjs";
+import { Supplier } from "./Supplier.mjs";
+export declare namespace PassthroughRequest {
+    /**
+     * Per-request options that can override the SDK client defaults.
+     */
+    interface RequestOptions {
+        /** Override the default timeout for this request (in seconds). */
+        timeoutInSeconds?: number;
+        /** Override the default number of retries for this request. */
+        maxRetries?: number;
+        /** Additional headers to include in this request. */
+        headers?: Record<string, string>;
+        /** Abort signal for this request. */
+        abortSignal?: AbortSignal;
+    }
+    /**
+     * SDK client configuration used by the passthrough fetch method.
+     */
+    interface ClientOptions {
+        /** The base URL or environment for the client. */
+        environment?: Supplier<string>;
+        /** Override the base URL. */
+        baseUrl?: Supplier<string>;
+        /** Default headers to include in requests. */
+        headers?: Record<string, unknown>;
+        /** Default maximum time to wait for a response in seconds. */
+        timeoutInSeconds?: number;
+        /** Default number of times to retry the request. Defaults to 2. */
+        maxRetries?: number;
+        /** A custom fetch function. */
+        fetch?: typeof fetch;
+        /** Logging configuration. */
+        logging?: LogConfig | Logger;
+        /** A function that returns auth headers. */
+        getAuthHeaders?: () => Promise<Record<string, string>>;
+    }
+}
+/**
+ * Makes a passthrough HTTP request using the SDK's configuration (auth, retry, logging, etc.)
+ * while mimicking the standard `fetch` API.
+ *
+ * @param input - The URL, path, or Request object. If a relative path, it will be resolved against the configured base URL.
+ * @param init - Standard RequestInit options (method, headers, body, signal, etc.)
+ * @param clientOptions - SDK client options (auth, default headers, logging, etc.)
+ * @param requestOptions - Per-request overrides (timeout, retries, extra headers, abort signal).
+ * @returns A standard Response object.
+ */
+export declare function makePassthroughRequest(input: Request | string | URL, init: RequestInit | undefined, clientOptions: PassthroughRequest.ClientOptions, requestOptions?: PassthroughRequest.RequestOptions): Promise<Response>;

package/dist/esm/core/fetcher/makePassthroughRequest.mjs

@@ -0,0 +1,132 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createLogger } from "../logging/logger.mjs";
+import { join } from "../url/join.mjs";
+import { EndpointSupplier } from "./EndpointSupplier.mjs";
+import { getFetchFn } from "./getFetchFn.mjs";
+import { makeRequest } from "./makeRequest.mjs";
+import { requestWithRetries } from "./requestWithRetries.mjs";
+import { Supplier } from "./Supplier.mjs";
+/**
+ * Makes a passthrough HTTP request using the SDK's configuration (auth, retry, logging, etc.)
+ * while mimicking the standard `fetch` API.
+ *
+ * @param input - The URL, path, or Request object. If a relative path, it will be resolved against the configured base URL.
+ * @param init - Standard RequestInit options (method, headers, body, signal, etc.)
+ * @param clientOptions - SDK client options (auth, default headers, logging, etc.)
+ * @param requestOptions - Per-request overrides (timeout, retries, extra headers, abort signal).
+ * @returns A standard Response object.
+ */
+export function makePassthroughRequest(input, init, clientOptions, requestOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const logger = createLogger(clientOptions.logging);
+        // Extract URL and default init properties from Request object if provided
+        let url;
+        let effectiveInit = init;
+        if (input instanceof Request) {
+            url = input.url;
+            // If no explicit init provided, extract properties from the Request object
+            if (init == null) {
+                effectiveInit = {
+                    method: input.method,
+                    headers: Object.fromEntries(input.headers.entries()),
+                    body: input.body,
+                    signal: input.signal,
+                    credentials: input.credentials,
+                    cache: input.cache,
+                    redirect: input.redirect,
+                    referrer: input.referrer,
+                    integrity: input.integrity,
+                    mode: input.mode,
+                };
+            }
+        }
+        else {
+            url = input instanceof URL ? input.toString() : input;
+        }
+        // Resolve the base URL
+        const baseUrl = (_a = (clientOptions.baseUrl != null ? yield Supplier.get(clientOptions.baseUrl) : undefined)) !== null && _a !== void 0 ? _a : (clientOptions.environment != null ? yield Supplier.get(clientOptions.environment) : undefined);
+        // Determine the full URL
+        let fullUrl;
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+            fullUrl = url;
+        }
+        else if (baseUrl != null) {
+            fullUrl = join(baseUrl, url);
+        }
+        else {
+            fullUrl = url;
+        }
+        // Merge headers: SDK default headers -> auth headers -> user-provided headers
+        const mergedHeaders = {};
+        // Apply SDK default headers (resolve suppliers)
+        if (clientOptions.headers != null) {
+            for (const [key, value] of Object.entries(clientOptions.headers)) {
+                const resolved = yield EndpointSupplier.get(value, { endpointMetadata: {} });
+                if (resolved != null) {
+                    mergedHeaders[key.toLowerCase()] = `${resolved}`;
+                }
+            }
+        }
+        // Apply auth headers
+        if (clientOptions.getAuthHeaders != null) {
+            const authHeaders = yield clientOptions.getAuthHeaders();
+            for (const [key, value] of Object.entries(authHeaders)) {
+                mergedHeaders[key.toLowerCase()] = value;
+            }
+        }
+        // Apply user-provided headers from init
+        if ((effectiveInit === null || effectiveInit === void 0 ? void 0 : effectiveInit.headers) != null) {
+            const initHeaders = effectiveInit.headers instanceof Headers
+                ? Object.fromEntries(effectiveInit.headers.entries())
+                : Array.isArray(effectiveInit.headers)
+                    ? Object.fromEntries(effectiveInit.headers)
+                    : effectiveInit.headers;
+            for (const [key, value] of Object.entries(initHeaders)) {
+                if (value != null) {
+                    mergedHeaders[key.toLowerCase()] = value;
+                }
+            }
+        }
+        // Apply per-request option headers (highest priority)
+        if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers) != null) {
+            for (const [key, value] of Object.entries(requestOptions.headers)) {
+                mergedHeaders[key.toLowerCase()] = value;
+            }
+        }
+        const method = (_b = effectiveInit === null || effectiveInit === void 0 ? void 0 : effectiveInit.method) !== null && _b !== void 0 ? _b : "GET";
+        const body = effectiveInit === null || effectiveInit === void 0 ? void 0 : effectiveInit.body;
+        const timeoutInSeconds = (_c = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) !== null && _c !== void 0 ? _c : clientOptions.timeoutInSeconds;
+        const timeoutMs = timeoutInSeconds != null ? timeoutInSeconds * 1000 : undefined;
+        const maxRetries = (_d = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.maxRetries) !== null && _d !== void 0 ? _d : clientOptions.maxRetries;
+        const abortSignal = (_f = (_e = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal) !== null && _e !== void 0 ? _e : effectiveInit === null || effectiveInit === void 0 ? void 0 : effectiveInit.signal) !== null && _f !== void 0 ? _f : undefined;
+        const fetchFn = (_g = clientOptions.fetch) !== null && _g !== void 0 ? _g : (yield getFetchFn());
+        if (logger.isDebug()) {
+            logger.debug("Making passthrough HTTP request", {
+                method,
+                url: fullUrl,
+                hasBody: body != null,
+            });
+        }
+        const response = yield requestWithRetries(() => __awaiter(this, void 0, void 0, function* () {
+            return makeRequest(fetchFn, fullUrl, method, mergedHeaders, body !== null && body !== void 0 ? body : undefined, timeoutMs, abortSignal, (effectiveInit === null || effectiveInit === void 0 ? void 0 : effectiveInit.credentials) === "include", undefined, // duplex
+            false);
+        }), maxRetries);
+        if (logger.isDebug()) {
+            logger.debug("Passthrough HTTP request completed", {
+                method,
+                url: fullUrl,
+                statusCode: response.status,
+            });
+        }
+        return response;
+    });
+}

package/dist/esm/core/file/exports.d.mts

@@ -0,0 +1 @@
+export type { Uploadable } from "./types.mjs";

package/dist/esm/core/file/exports.mjs

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

package/dist/esm/core/file/file.d.mts

@@ -0,0 +1,10 @@
+import type { Uploadable } from "./types.mjs";
+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/esm/core/file/file.mjs

@@ -0,0 +1,185 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function toBinaryUploadRequest(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { data, filename, contentLength, contentType } = yield getFileWithMetadata(file);
+        const request = {
+            body: data,
+            headers: {},
+        };
+        if (filename) {
+            request.headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+        }
+        if (contentType) {
+            request.headers["Content-Type"] = contentType;
+        }
+        if (contentLength != null) {
+            request.headers["Content-Length"] = contentLength.toString();
+        }
+        return request;
+    });
+}
+export 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 import("fs");
+            if (!(fs === null || fs === void 0 ? void 0 : fs.createReadStream)) {
+                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 : (noSniffFileSize === true ? undefined : yield tryGetFileSizeFromPath(file.path));
+            const filename = (_b = file.filename) !== null && _b !== void 0 ? _b : getNameFromPath(file.path);
+            return {
+                data,
+                filename,
+                contentType: file.contentType,
+                contentLength,
+            };
+        }
+        if ("data" in file) {
+            const data = file.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,
+                filename,
+                contentType: (_e = file.contentType) !== null && _e !== void 0 ? _e : tryGetContentTypeFromFileLike(data),
+                contentLength,
+            };
+        }
+        throw new Error(`Invalid FileUpload of type ${typeof file}: ${JSON.stringify(file)}`);
+    });
+}
+function isFileLike(value) {
+    return (isBuffer(value) ||
+        isArrayBufferView(value) ||
+        isArrayBuffer(value) ||
+        isUint8Array(value) ||
+        isBlob(value) ||
+        isFile(value) ||
+        isStreamLike(value) ||
+        isReadableStream(value));
+}
+function tryGetFileSizeFromPath(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const fs = yield import("fs");
+            if (!((_a = fs === null || fs === void 0 ? void 0 : fs.promises) === null || _a === void 0 ? void 0 : _a.stat)) {
+                return undefined;
+            }
+            const fileStat = yield fs.promises.stat(path);
+            return fileStat.size;
+        }
+        catch (_fallbackError) {
+            return undefined;
+        }
+    });
+}
+function tryGetNameFromFileLike(data) {
+    if (isNamedValue(data)) {
+        return data.name;
+    }
+    if (isPathedValue(data)) {
+        return getNameFromPath(data.path.toString());
+    }
+    return undefined;
+}
+function tryGetContentLengthFromFileLike(data_1) {
+    return __awaiter(this, arguments, void 0, function* (data, { noSniffFileSize } = {}) {
+        if (isBuffer(data)) {
+            return data.length;
+        }
+        if (isArrayBufferView(data)) {
+            return data.byteLength;
+        }
+        if (isArrayBuffer(data)) {
+            return data.byteLength;
+        }
+        if (isBlob(data)) {
+            return data.size;
+        }
+        if (isFile(data)) {
+            return data.size;
+        }
+        if (noSniffFileSize === true) {
+            return undefined;
+        }
+        if (isPathedValue(data)) {
+            return yield tryGetFileSizeFromPath(data.path.toString());
+        }
+        return undefined;
+    });
+}
+function tryGetContentTypeFromFileLike(data) {
+    if (isBlob(data)) {
+        return data.type;
+    }
+    if (isFile(data)) {
+        return data.type;
+    }
+    return undefined;
+}
+function getNameFromPath(path) {
+    const lastForwardSlash = path.lastIndexOf("/");
+    const lastBackSlash = path.lastIndexOf("\\");
+    const lastSlashIndex = Math.max(lastForwardSlash, lastBackSlash);
+    return lastSlashIndex >= 0 ? path.substring(lastSlashIndex + 1) : path;
+}
+function isNamedValue(value) {
+    return typeof value === "object" && value != null && "name" in value;
+}
+function isPathedValue(value) {
+    return typeof value === "object" && value != null && "path" in value;
+}
+function isStreamLike(value) {
+    return typeof value === "object" && value != null && ("read" in value || "pipe" in value);
+}
+function isReadableStream(value) {
+    return typeof value === "object" && value != null && "getReader" in value;
+}
+function isBuffer(value) {
+    return typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(value);
+}
+function isArrayBufferView(value) {
+    return typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(value);
+}
+function isArrayBuffer(value) {
+    return typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer;
+}
+function isUint8Array(value) {
+    return typeof Uint8Array !== "undefined" && value instanceof Uint8Array;
+}
+function isBlob(value) {
+    return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFile(value) {
+    return typeof File !== "undefined" && value instanceof File;
+}

package/dist/esm/core/file/index.d.mts

@@ -0,0 +1,2 @@
+export * from "./file.mjs";
+export * from "./types.mjs";

package/dist/esm/core/file/index.mjs

@@ -0,0 +1,2 @@
+export * from "./file.mjs";
+export * from "./types.mjs";

package/dist/esm/core/file/types.d.mts

@@ -0,0 +1,66 @@
+/**
+ * A file that can be uploaded. Can be a file-like object (stream, buffer, blob, etc.),
+ * a path to a file, or an object with a file-like object and metadata.
+ */
+export type Uploadable = Uploadable.FileLike | Uploadable.FromPath | Uploadable.WithMetadata;
+export declare namespace Uploadable {
+    /**
+     * Various file-like objects that can be used to upload a file.
+     */
+    type FileLike = ArrayBuffer | ArrayBufferLike | ArrayBufferView | Uint8Array | import("buffer").Buffer | import("buffer").Blob | import("buffer").File | import("stream").Readable | import("stream/web").ReadableStream | globalThis.Blob | globalThis.File | ReadableStream;
+    /**
+     * A file path with optional metadata, used for uploading a file from the file system.
+     */
+    type FromPath = {
+        /** The path to the file to upload */
+        path: string;
+        /**
+         * Optional override for the file name (defaults to basename of path).
+         * This is used to set the `Content-Disposition` header in upload requests.
+         */
+        filename?: string;
+        /**
+         * Optional MIME type of the file (e.g., 'image/jpeg', 'text/plain').
+         * This is used to set the `Content-Type` header in upload requests.
+         */
+        contentType?: string;
+        /**
+         * Optional file size in bytes.
+         * If not provided, the file size will be determined from the file system.
+         * The content length is used to set the `Content-Length` header in upload requests.
+         */
+        contentLength?: number;
+    };
+    /**
+     * A file-like object with metadata, used for uploading files.
+     */
+    type WithMetadata = {
+        /** The file data */
+        data: FileLike;
+        /**
+         * Optional override for the file name (defaults to basename of path).
+         * This is used to set the `Content-Disposition` header in upload requests.
+         */
+        filename?: string;
+        /**
+         * Optional MIME type of the file (e.g., 'image/jpeg', 'text/plain').
+         * This is used to set the `Content-Type` header in upload requests.
+         *
+         * If not provided, the content type may be determined from the data itself.
+         * * If the data is a `File`, `Blob`, or similar, the content type will be determined from the file itself, if the type is set.
+         * * Any other data type will not have a content type set, and the upload request will use `Content-Type: application/octet-stream` instead.
+         */
+        contentType?: string;
+        /**
+         * Optional file size in bytes.
+         * The content length is used to set the `Content-Length` header in upload requests.
+         * If the content length is not provided and cannot be determined, the upload request will not include the `Content-Length` header, but will use `Transfer-Encoding: chunked` instead.
+         *
+         * If not provided, the file size will be determined depending on the data type.
+         * * If the data is of type `fs.ReadStream` (`createReadStream`), the size will be determined from the file system.
+         * * If the data is a `Buffer`, `ArrayBuffer`, `Uint8Array`, `Blob`, `File`, or similar, the size will be determined from the data itself.
+         * * If the data is a `Readable` or `ReadableStream`, the size will not be determined.
+         */
+        contentLength?: number;
+    };
+}

package/dist/esm/core/file/types.mjs

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

package/dist/esm/core/form-data-utils/FormDataWrapper.d.mts

@@ -0,0 +1,15 @@
+import { type Uploadable } from "../../core/file/index.mjs";
+interface FormDataRequest<Body> {
+    body: Body;
+    headers: Record<string, string>;
+    duplex?: "half";
+}
+export declare function newFormData(): Promise<FormDataWrapper>;
+export declare class FormDataWrapper {
+    private fd;
+    setup(): Promise<void>;
+    append(key: string, value: unknown): void;
+    appendFile(key: string, value: Uploadable): Promise<void>;
+    getRequest(): FormDataRequest<FormData>;
+}
+export {};