doFetch = async () => {
          if (requestMethod !== "GET" && requestMethod !== "HEAD") {
            const contentType = requestHeaders.get("Content-Type");
            const { sharedParams } = this;
            const extendedBody = body ?? {};

            if (extendedBody instanceof FormData) {
              Object.entries(sharedParams ?? {}).forEach(([key, value]) => {
                extendedBody.append(key, value);
              });
            } else {
              Object.assign(extendedBody, {
                ...(sharedParams ?? {}),
                ...(body ?? {}),
              });
            }

            if (extendedBody instanceof FormData) {
              requestParams.body = extendedBody;
            } else if (contentType === "multipart/form-data") {
              requestParams.body = this.createRequestBody(extendedBody);
            } else if (contentType === "application/json") {
              requestParams.body = this.bodyToJSON(extendedBody);
            } else {
              requestParams.body = extendedBody;
            }

            // @todo better check for files maybe?
            if (contentType === "multipart/form-data") {
              // fetch will set correct header with boundaries
              requestHeaders.delete("Content-Type");
            }
          }

          /** @type {Response} */
          let rawResponse;

          if (methodSettings.mock && process.env.NODE_ENV === "development" && !this.mockDisabled) {
            rawResponse = await this.mockRequest(apiCallURL, urlParams, requestParams, methodSettings);
          } else {
            rawResponse = await fetch(apiCallURL, requestParams);
          }

          if (raw || rawResponse.isCanceled) return rawResponse;

          responseMeta = {
            headers: new Map(Array.from(rawResponse.headers)),
            status: rawResponse.status,
            url: rawResponse.url,
          };

          if (rawResponse.ok && rawResponse.status !== 401) {
            const responseText = await rawResponse.text();

            try {
              const responseData =
                rawResponse.status !== 204
                  ? parseJson(this.alwaysExpectJSON && alwaysExpectJSON ? responseText : responseText || "{}")
                  : { ok: true };

              if (methodSettings.convert instanceof Function) {
                const convertedData = await methodSettings.convert(responseData);

                return convertedData;
              }

              responseResult = responseData;
            } catch (err) {
              responseResult = this.generateException(err, responseText);
            }
          } else {
            responseResult = await this.generateError(rawResponse);
          }

          Object.defineProperty(responseResult, "$meta", {
            value: responseMeta,
            configurable: false,
            enumerable: false,
            writable: false,
          });

          return responseResult;
        }
Object to be used to control the cache for the request
@type {Object}
@property {number} [staleTime]
@property {string} [keyPrefix]