@gcmdev/faxios 0.1.0

package/dist/lib/helpers/validator.js

@@ -0,0 +1,86 @@
+"use strict";
+import FaxiosError from "../core/FaxiosError.js";
+import { VERSION } from "../env/data.js";
+const validators = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
+    validators[type] = function validator(thing) {
+        return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+    };
+});
+const deprecatedWarnings = {};
+/**
+ * Transitional option validator
+ *
+ * @param {function|boolean?} validator - set to false if the transitional option has been removed
+ * @param {string?} version - deprecated version / removed since version
+ * @param {string?} message - some message with additional info
+ *
+ * @returns {function}
+ */
+validators["transitional"] = function transitional(validator, version, message) {
+    function formatMessage(opt, desc) {
+        return ("[Faxios v" +
+            VERSION +
+            "] Transitional option '" +
+            opt +
+            "'" +
+            desc +
+            (message ? ". " + message : ""));
+    }
+    return (value, opt, opts) => {
+        if (validator === false) {
+            throw new FaxiosError(formatMessage(opt ?? "", " has been removed" + (version ? " in " + version : "")), FaxiosError.ERR_DEPRECATED);
+        }
+        if (version && opt && !deprecatedWarnings[opt]) {
+            deprecatedWarnings[opt] = true;
+            // eslint-disable-next-line no-console
+            console.warn(formatMessage(opt, " has been deprecated since v" + version + " and will be removed in the near future"));
+        }
+        return validator ? validator(value, opt, opts) : true;
+    };
+};
+validators["spelling"] = function spelling(correctSpelling) {
+    return (_value, opt) => {
+        // eslint-disable-next-line no-console
+        console.warn(`${opt ?? ""} is likely a misspelling of ${correctSpelling}`);
+        return true;
+    };
+};
+/**
+ * Assert object's properties type
+ *
+ * @param {object} options
+ * @param {object} schema
+ * @param {boolean?} allowUnknown
+ *
+ * @returns {object}
+ */
+function assertOptions(options, schema, allowUnknown) {
+    if (typeof options !== "object") {
+        throw new FaxiosError("options must be an object", FaxiosError.ERR_BAD_OPTION_VALUE);
+    }
+    const keys = Object.keys(options);
+    let i = keys.length;
+    while (i-- > 0) {
+        const opt = keys[i];
+        // Use hasOwnProperty so a polluted Object.prototype.<opt> cannot supply
+        // a non-function validator and cause a TypeError.
+        const validator = Object.prototype.hasOwnProperty.call(schema, opt) ? schema[opt] : undefined;
+        if (validator) {
+            const value = options[opt];
+            const result = value === undefined || validator(value, opt, options);
+            if (result !== true) {
+                throw new FaxiosError("option " + opt + " must be " + result, FaxiosError.ERR_BAD_OPTION_VALUE);
+            }
+            continue;
+        }
+        if (allowUnknown !== true) {
+            throw new FaxiosError("Unknown option " + opt, FaxiosError.ERR_BAD_OPTION);
+        }
+    }
+}
+export default {
+    assertOptions,
+    validators,
+};
+//# sourceMappingURL=validator.js.map

package/dist/lib/helpers/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../../src/lib/helpers/validator.ts"],"names":[],"mappings":"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"}

package/dist/lib/platform.d.ts

@@ -0,0 +1,22 @@
+import FaxiosURLSearchParams from "./helpers/FaxiosURLSearchParams.js";
+declare const _default: {
+    isBrowser: boolean;
+    classes: {
+        URLSearchParams: {
+            new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+            prototype: URLSearchParams;
+        } | typeof FaxiosURLSearchParams;
+        FormData: (new (...args: Array<unknown>) => object) | null;
+        Blob: (new (...args: Array<unknown>) => object) | null;
+    };
+    protocols: string[];
+    hasBrowserEnv: boolean;
+    hasStandardBrowserEnv: boolean;
+    hasStandardBrowserWebWorkerEnv: boolean;
+    navigator: {
+        product?: string;
+        userAgent?: string;
+    } | undefined;
+    origin: string;
+};
+export default _default;

package/dist/lib/platform.js

@@ -0,0 +1,26 @@
+"use strict";
+import FaxiosURLSearchParams from "./helpers/FaxiosURLSearchParams.js";
+const _globalThis = globalThis;
+const hasBrowserEnv = typeof _globalThis.window !== "undefined" && typeof _globalThis.document !== "undefined";
+const _navigator = typeof _globalThis.navigator === "object" ? _globalThis.navigator : undefined;
+const hasStandardBrowserEnv = hasBrowserEnv &&
+    (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product ?? "") < 0);
+const hasStandardBrowserWebWorkerEnv = (() => (typeof _globalThis.WorkerGlobalScope !== "undefined" &&
+    _globalThis.self instanceof _globalThis.WorkerGlobalScope &&
+    typeof _globalThis.self?.importScripts === "function"))();
+const origin = (hasBrowserEnv && _globalThis.window?.location?.href) || "http://localhost";
+export default {
+    isBrowser: true,
+    classes: {
+        URLSearchParams: typeof URLSearchParams !== "undefined" ? URLSearchParams : FaxiosURLSearchParams,
+        FormData: _globalThis.FormData !== undefined ? _globalThis.FormData : null,
+        Blob: _globalThis.Blob !== undefined ? _globalThis.Blob : null,
+    },
+    protocols: ["http", "https", "file", "blob", "url", "data"],
+    hasBrowserEnv,
+    hasStandardBrowserEnv,
+    hasStandardBrowserWebWorkerEnv,
+    navigator: _navigator,
+    origin,
+};
+//# sourceMappingURL=platform.js.map

package/dist/lib/platform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../src/lib/platform.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,qBAAqB,2CAA2C;AAEvE,MAAM,WAAW,GAAG,UAQnB,CAAC;AAEF,MAAM,aAAa,GAAG,OAAO,WAAW,CAAC,MAAM,KAAK,WAAW,IAAI,OAAO,WAAW,CAAC,QAAQ,KAAK,WAAW,CAAC;AAE/G,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AAEjG,MAAM,qBAAqB,GACzB,aAAa;IACb,CAAC,CAAC,UAAU,IAAI,CAAE,aAAa,EAAE,cAAc,EAAE,IAAI,CAAE,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AAEjG,MAAM,8BAA8B,GAAG,CAAC,GAAG,EAAE,CAAC,CAC5C,OAAO,WAAW,CAAC,iBAAiB,KAAK,WAAW;IAClD,WAAW,CAAC,IAAI,YAAa,WAAW,CAAC,iBAA8D;IACvG,OAAO,WAAW,CAAC,IAAI,EAAE,aAAa,KAAK,UAAU,CACxD,CAAC,EAAE,CAAC;AAEL,MAAM,MAAM,GAAG,CAAC,aAAa,IAAI,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,kBAAkB,CAAC;AAE3F,eAAe;IACb,SAAS,EAAE,IAAI;IACf,OAAO,EAAE;QACP,eAAe,EAAE,OAAO,eAAe,KAAK,WAAW,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,qBAAqB;QACjG,QAAQ,EAAE,WAAW,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI;QAC1E,IAAI,EAAE,WAAW,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI;KAC/D;IACD,SAAS,EAAE,CAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAE;IAC7D,aAAa;IACb,qBAAqB;IACrB,8BAA8B;IAC9B,SAAS,EAAE,UAAU;IACrB,MAAM;CACP,CAAC"}

package/dist/lib/types/standard-schema.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Vendored Standard Schema v1 types.
+ * @see https://standardschema.dev
+ * @see https://github.com/standard-schema/standard-schema
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly types?: Types<Input, Output>;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}

package/dist/lib/types/standard-schema.js

@@ -0,0 +1,8 @@
+// @ts-self-types="./standard-schema.d.ts"
+/**
+ * Vendored Standard Schema v1 types.
+ * @see https://standardschema.dev
+ * @see https://github.com/standard-schema/standard-schema
+ */
+export {};
+//# sourceMappingURL=standard-schema.js.map

package/dist/lib/types/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../../src/lib/types/standard-schema.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C;;;;GAIG"}

package/dist/lib/types.d.ts

@@ -0,0 +1,219 @@
+import type { StandardSchemaV1 } from "./types/standard-schema.js";
+export type StringLiteralsOrString<Literals extends string> = Literals | (string & {});
+export type FaxiosHeaderValue = string | Array<string> | number | boolean | null;
+export interface RawFaxiosHeaders {
+    [key: string]: FaxiosHeaderValue;
+}
+type UppercaseMethod = "GET" | "DELETE" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | "PURGE" | "LINK" | "UNLINK" | "QUERY";
+export type Method = UppercaseMethod | Lowercase<UppercaseMethod>;
+type CommonRequestHeadersList = "Accept" | "Content-Length" | "User-Agent" | "Content-Encoding" | "Authorization" | "Location";
+type ContentType = FaxiosHeaderValue | "text/html" | "text/plain" | "multipart/form-data" | "application/json" | "application/x-www-form-urlencoded" | "application/octet-stream";
+export type RawFaxiosRequestHeaders = Partial<RawFaxiosHeaders & {
+    [Key in CommonRequestHeadersList]: FaxiosHeaderValue;
+} & {
+    "Content-Type": ContentType;
+}>;
+export type ResponseType = "arraybuffer" | "blob" | "document" | "json" | "text" | "stream" | "formdata" | "response";
+type UppercaseResponseEncoding = "ASCII" | "ANSI" | "BINARY" | "BASE64" | "BASE64URL" | "HEX" | "LATIN1" | "UCS-2" | "UCS2" | "UTF-8" | "UTF8" | "UTF16LE";
+export type responseEncoding = UppercaseResponseEncoding | Lowercase<UppercaseResponseEncoding>;
+export interface TransitionalOptions {
+    silentJSONParsing?: boolean;
+    forcedJSONParsing?: boolean;
+    clarifyTimeoutError?: boolean;
+    legacyInterceptorReqResOrdering?: boolean;
+    advertiseZstdAcceptEncoding?: boolean;
+    validateStatusUndefinedResolves?: boolean;
+}
+export interface GenericAbortSignal {
+    readonly aborted: boolean;
+    onabort?: ((event: Event) => void) | null;
+    addEventListener?: (...args: Array<unknown>) => unknown;
+    removeEventListener?: (...args: Array<unknown>) => unknown;
+}
+export interface GenericFormData {
+    append: (name: string, value: unknown, options?: unknown) => unknown;
+}
+export interface GenericHTMLFormElement {
+    name: string;
+    method: string;
+    submit: () => void;
+}
+export interface FormDataVisitorHelpers {
+    defaultVisitor: SerializerVisitor;
+    convertValue: (value: unknown) => unknown;
+    isVisitable: (value: unknown) => boolean;
+}
+export interface SerializerVisitor {
+    (this: GenericFormData, value: unknown, key: string | number, path: null | Array<string | number>, helpers: FormDataVisitorHelpers): boolean;
+}
+export interface SerializerOptions {
+    visitor?: SerializerVisitor;
+    dots?: boolean;
+    metaTokens?: boolean;
+    indexes?: boolean | null;
+}
+export type FormSerializerOptions = SerializerOptions;
+export interface ParamEncoder {
+    (value: unknown, defaultEncoder: (value: unknown) => unknown): unknown;
+}
+export interface CustomParamsSerializer {
+    (params: Record<string, unknown>, options?: ParamsSerializerOptions): string;
+}
+export interface ParamsSerializerOptions extends SerializerOptions {
+    encode?: ParamEncoder;
+    serialize?: CustomParamsSerializer;
+}
+type BrowserProgressEvent = unknown;
+type Milliseconds = number;
+export interface FaxiosProgressEvent {
+    loaded: number;
+    total?: number;
+    progress?: number;
+    bytes: number;
+    rate?: number;
+    estimated?: number;
+    upload?: boolean;
+    download?: boolean;
+    event?: BrowserProgressEvent;
+    lengthComputable: boolean;
+}
+export interface FaxiosBasicCredentials {
+    username: string;
+    password: string;
+}
+type HeaderMatcher = string | RegExp | ((value: string, name: string) => boolean);
+type HeaderRewrite = boolean | ((value: string, name: string) => boolean);
+type HeaderGetResult = string | Array<string> | Record<string, string> | RegExpExecArray | true | null | undefined;
+export type FaxiosRequestHeaders = Record<string, FaxiosHeaderValue> & {
+    set: (header: string | Record<string, unknown>, value?: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    get: (header: string, parser?: boolean | RegExp) => HeaderGetResult;
+    has: (header: string, matcher?: HeaderMatcher) => boolean;
+    delete: (header: string | Array<string>, matcher?: HeaderMatcher) => boolean;
+    clear: (matcher?: HeaderMatcher) => boolean;
+    normalize: (format?: boolean) => FaxiosRequestHeaders;
+    concat: (...targets: Array<unknown>) => FaxiosRequestHeaders;
+    getContentType: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setContentType: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasContentType: (matcher?: HeaderMatcher) => boolean;
+    getContentLength: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setContentLength: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasContentLength: (matcher?: HeaderMatcher) => boolean;
+    getAccept: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setAccept: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasAccept: (matcher?: HeaderMatcher) => boolean;
+    getUserAgent: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setUserAgent: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasUserAgent: (matcher?: HeaderMatcher) => boolean;
+    getContentEncoding: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setContentEncoding: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasContentEncoding: (matcher?: HeaderMatcher) => boolean;
+    getAuthorization: (matcher?: HeaderMatcher) => HeaderGetResult;
+    setAuthorization: (value: FaxiosHeaderValue, rewrite?: HeaderRewrite) => FaxiosRequestHeaders;
+    hasAuthorization: (matcher?: HeaderMatcher) => boolean;
+    toJSON: (asStrings?: boolean) => Record<string, FaxiosHeaderValue>;
+};
+export interface FaxiosRequestTransformer {
+    (this: InternalFaxiosRequestConfig, data: unknown, headers: FaxiosRequestHeaders): unknown;
+}
+export interface FaxiosResponseTransformer {
+    (this: InternalFaxiosRequestConfig, data: unknown, headers: RawFaxiosHeaders, status?: number): unknown;
+}
+export interface FaxiosRequestConfig<D = unknown> {
+    url?: string;
+    method?: StringLiteralsOrString<Method>;
+    baseURL?: string;
+    allowAbsoluteUrls?: boolean;
+    transformRequest?: FaxiosRequestTransformer | Array<FaxiosRequestTransformer>;
+    transformResponse?: FaxiosResponseTransformer | Array<FaxiosResponseTransformer>;
+    headers?: Record<string, unknown>;
+    params?: Record<string, unknown> | URLSearchParams;
+    paramsSerializer?: ParamsSerializerOptions | CustomParamsSerializer;
+    data?: D;
+    timeout?: Milliseconds;
+    timeoutErrorMessage?: string;
+    withCredentials?: boolean;
+    auth?: FaxiosBasicCredentials;
+    responseType?: ResponseType;
+    responseEncoding?: StringLiteralsOrString<responseEncoding>;
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
+    onUploadProgress?: (progressEvent: FaxiosProgressEvent) => void;
+    onDownloadProgress?: (progressEvent: FaxiosProgressEvent) => void;
+    maxContentLength?: number;
+    validateStatus?: ((status: number) => boolean) | null;
+    maxBodyLength?: number;
+    transitional?: TransitionalOptions;
+    signal?: AbortSignal | GenericAbortSignal;
+    env?: {
+        FormData?: new (...args: Array<unknown>) => object;
+        fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+        Request?: new (input: string | URL | Request, init?: RequestInit) => unknown;
+        Response?: new (...args: Array<unknown>) => unknown;
+    };
+    formSerializer?: FormSerializerOptions;
+    withXSRFToken?: boolean | ((config: InternalFaxiosRequestConfig) => boolean | undefined);
+    parseReviver?: (this: unknown, key: string, value: unknown, context?: {
+        source?: string;
+    }) => unknown;
+    fetchOptions?: Record<string, unknown>;
+    formDataHeaderPolicy?: "legacy" | "content-only";
+    redact?: Array<string>;
+    responseSchema?: StandardSchemaV1;
+    requestSchema?: StandardSchemaV1;
+    paramsSchema?: StandardSchemaV1;
+    pathParams?: Record<string, unknown>;
+    pathParamsSchema?: StandardSchemaV1<unknown, Record<string, unknown>>;
+}
+export type SchemaConfig<O, D = unknown> = FaxiosRequestConfig<D> & {
+    responseSchema: StandardSchemaV1<unknown, O>;
+};
+export type RawFaxiosRequestConfig<D = unknown> = FaxiosRequestConfig<D>;
+export interface InternalFaxiosRequestConfig<D = unknown> extends FaxiosRequestConfig<D> {
+    headers: FaxiosRequestHeaders;
+}
+export interface FaxiosResponseHeadersLike {
+    [key: string]: unknown;
+    get: (header: string) => FaxiosHeaderValue | undefined;
+}
+export interface FaxiosResponse<T = unknown, D = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: FaxiosResponseHeadersLike;
+    config: InternalFaxiosRequestConfig<D>;
+    request?: Request | null;
+}
+export type FaxiosPromise<T = unknown> = Promise<FaxiosResponse<T>>;
+export interface HeadersDefaults {
+    common: RawFaxiosRequestHeaders;
+    delete: RawFaxiosRequestHeaders;
+    get: RawFaxiosRequestHeaders;
+    head: RawFaxiosRequestHeaders;
+    post: RawFaxiosRequestHeaders;
+    put: RawFaxiosRequestHeaders;
+    patch: RawFaxiosRequestHeaders;
+    options?: RawFaxiosRequestHeaders;
+    purge?: RawFaxiosRequestHeaders;
+    link?: RawFaxiosRequestHeaders;
+    unlink?: RawFaxiosRequestHeaders;
+    query?: RawFaxiosRequestHeaders;
+}
+export interface FaxiosDefaults<D = unknown> extends Omit<FaxiosRequestConfig<D>, "headers"> {
+    headers: HeadersDefaults;
+}
+export interface CreateFaxiosDefaults<D = unknown> extends Omit<FaxiosRequestConfig<D>, "headers"> {
+    headers?: RawFaxiosRequestHeaders | Partial<HeadersDefaults>;
+}
+export interface FaxiosInterceptorOptions {
+    synchronous?: boolean;
+    runWhen?: ((config: InternalFaxiosRequestConfig) => boolean) | null;
+}
+export type FaxiosInterceptorFulfilled<T> = (value: T) => T | Promise<T>;
+export type FaxiosInterceptorRejected = (error: unknown) => unknown;
+export interface FaxiosInterceptorHandler<T> {
+    fulfilled: FaxiosInterceptorFulfilled<T>;
+    rejected?: FaxiosInterceptorRejected;
+    synchronous: boolean;
+    runWhen?: ((config: InternalFaxiosRequestConfig) => boolean) | null;
+}
+export {};

package/dist/lib/types.js

@@ -0,0 +1,5 @@
+// @ts-self-types="./types.d.ts"
+// Internal shared types — imported by implementation files.
+// Public API types in index.d.ts re-export or extend these.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,4DAA4D;AAC5D,4DAA4D"}

package/dist/lib/utils.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Determine if a value is a Buffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a Buffer, otherwise false
+ */
+declare function isBuffer(val: unknown): boolean;
+/**
+ * Determine if a value is a view on an ArrayBuffer
+ *
+ * @param {*} val The value to test
+ *
+ * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
+ */
+declare function isArrayBufferView(val: unknown): boolean;
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array<unknown>} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ *
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys = false]
+ * @returns {any}
+ */
+declare function forEach(obj: unknown, fn: (value: unknown, key: unknown, obj: unknown) => void, { allOwnKeys }?: {
+    allOwnKeys?: boolean | undefined;
+}): void;
+/**
+ * Finds a key in an object, case-insensitive, returning the actual key name.
+ * Returns null if the object is a Buffer or if no match is found.
+ *
+ * @param {Object} obj - The object to search.
+ * @param {string} key - The key to find (case-insensitive).
+ * @returns {?string} The actual key name if found, otherwise null.
+ */
+declare function findKey(obj: unknown, key: string): string | null;
+type GlobalWithEvents = typeof globalThis & {
+    addEventListener?: (type: string, listener: (event: Record<string, unknown>) => void, capture?: boolean) => void;
+    postMessage?: (message: unknown, targetOrigin: string) => void;
+    setImmediate?: (cb: () => void) => void;
+    process?: {
+        nextTick?: (cb: () => void) => void;
+    };
+};
+/**
+ * Accepts varargs expecting each argument to be an object, then
+ * immutably merges the properties of each object and returns result.
+ *
+ * When multiple objects contain the same key the later object in
+ * the arguments list will take precedence.
+ *
+ * Example:
+ *
+ * ```js
+ * const result = merge({foo: 123}, {foo: 456});
+ * console.log(result.foo); // outputs 456
+ * ```
+ *
+ * @param {Object} obj1 Object to merge
+ *
+ * @returns {Object} Result of all merge properties
+ */
+declare function merge(this: unknown, ...objs: Array<unknown>): Record<string, unknown>;
+/**
+ * If the thing is a FormData object, return true, otherwise return false.
+ *
+ * @param {unknown} thing - The thing to check.
+ *
+ * @returns {boolean}
+ */
+declare function isSpecCompliantForm(thing: unknown): boolean;
+declare const _default: {
+    isArray: (arg: any) => arg is any[];
+    isArrayBuffer: (thing: unknown) => boolean;
+    isBuffer: typeof isBuffer;
+    isFormData: (thing: unknown) => boolean;
+    isArrayBufferView: typeof isArrayBufferView;
+    isString: (thing: unknown) => boolean;
+    isNumber: (thing: unknown) => boolean;
+    isBoolean: (thing: unknown) => thing is boolean;
+    isObject: (thing: unknown) => thing is object;
+    isPlainObject: (val: unknown) => boolean;
+    isEmptyObject: (val: unknown) => boolean;
+    isReadableStream: ((thing: unknown) => boolean) | undefined;
+    isRequest: ((thing: unknown) => boolean) | undefined;
+    isResponse: ((thing: unknown) => boolean) | undefined;
+    isHeaders: ((thing: unknown) => boolean) | undefined;
+    isUndefined: (thing: unknown) => boolean;
+    isDate: (thing: unknown) => boolean;
+    isFile: (thing: unknown) => boolean;
+    isReactNativeBlob: (value: unknown) => boolean;
+    isReactNative: (formData: unknown) => unknown;
+    isBlob: (thing: unknown) => boolean;
+    isRegExp: (thing: unknown) => boolean;
+    isFunction: (thing: unknown) => boolean;
+    isStream: (val: unknown) => boolean;
+    isURLSearchParams: (thing: unknown) => boolean;
+    isTypedArray: (thing: unknown) => boolean;
+    isFileList: (thing: unknown) => boolean;
+    forEach: typeof forEach;
+    merge: typeof merge;
+    extend: (a: Record<string, unknown>, b: unknown, thisArg: unknown, { allOwnKeys }?: {
+        allOwnKeys?: boolean;
+    }) => Record<string, unknown>;
+    stripBOM: (content: string) => string;
+    toFlatObject: (sourceObj: unknown, destObj?: Record<string, unknown>, filter?: ((src: object, dest: Record<string, unknown>) => boolean) | false, propFilter?: (prop: string, src: unknown, dest: Record<string, unknown>) => boolean) => Record<string, unknown>;
+    kindOf: (thing: unknown) => string;
+    kindOfTest: (type: string) => (thing: unknown) => boolean;
+    toArray: (thing?: unknown) => Array<unknown> | null;
+    forEachEntry: (obj: unknown, fn: (key: unknown, value: unknown) => void) => void;
+    matchAll: (regExp: RegExp, str: string) => RegExpExecArray[];
+    isHTMLForm: (thing: unknown) => boolean;
+    hasOwnProperty: (obj: unknown, prop: PropertyKey) => boolean;
+    hasOwnProp: (obj: unknown, prop: PropertyKey) => boolean;
+    hasOwnInPrototypeChain: (thing: unknown, prop: PropertyKey) => boolean;
+    getSafeProp: (obj: unknown, prop: PropertyKey) => unknown;
+    reduceDescriptors: (obj: object, reducer: (descriptor: PropertyDescriptor, name: string, obj: object) => PropertyDescriptor | false | undefined) => void;
+    freezeMethods: (obj: object) => void;
+    toObjectSet: (arrayOrString: Array<unknown> | string, delimiter: string) => Record<string, boolean>;
+    toCamelCase: (str: string) => string;
+    noop: () => void;
+    toFiniteNumber: (value: unknown, defaultValue?: number) => number | undefined;
+    findKey: typeof findKey;
+    global: GlobalWithEvents;
+    isContextDefined: (context: unknown) => boolean;
+    isSpecCompliantForm: typeof isSpecCompliantForm;
+    toJSONObject: (obj: unknown) => unknown;
+    isAsyncFn: (thing: unknown) => boolean;
+    isThenable: (thing: unknown) => unknown;
+    setImmediate: (cb: () => void) => unknown;
+    asap: typeof queueMicrotask;
+    isIterable: (thing: unknown) => boolean;
+    isSafeIterable: (thing: unknown) => boolean;
+};
+export default _default;