public hasError() {
        if (hasValue(this._errors)) {
            return this._errors.hasError();
        }

        // istanbul ignore next: Only happens on network errors
        return false;
    }

export function mergeConfig(...config: RequestConfig[]): ConfigType {
    const res: RequestConfig = {};

    config.filter((x) => !!x).forEach((opts) => Object.assign(res, opts));

    if (res.statusSuccess) {
        if (!isArray(res.statusSuccess) && hasValue(res.statusSuccess) && isNumber(res.statusSuccess)) {
            res.statusSuccess = [res.statusSuccess];
        }
    }

    if (res.statusValidationError) {
        if (!isArray(res.statusValidationError) && hasValue(res.statusValidationError) && isNumber(res.statusValidationError)) {
            res.statusValidationError = [res.statusValidationError];
        }
    }

    // Expect to be filled by now - we use default config which will fill all the right data
    return res as ConfigType;
}

 protected wrapResponse(response: Response, error: ResponseError | Error | null = null) {
     // For superagent, all 4XX/5XX response codes also return an error object. Since
     // tg-resources handles these errors in the Resource we need to only send
     // error object here if it is not due to a response code.
     //
     // Network errors in superagent don't have `err.status`
     return new SuperagentResponse(
         response,
         error && ('status' in error) && hasValue(error.status) ? null : error,
     );
 }

    protected createRequest<
        D extends ObjectMap = any
    >(method: AllowedMethods, url: string, query: Query, data: D | null, attachments: Attachments, requestConfig: RequestConfig) {
        let req = request[method](url);

        if (this.config(requestConfig).withCredentials) {
            req = req.withCredentials();
        }

        if (query) {
            req = req.query(query);
        }

        if (hasValue(data)) {
            // If attachments are used construct a multipart request
            if (attachments) {
                attachments.forEach((attachment) => {
                    req = req.attach(attachment.field, attachment.file, attachment.name);
                });

                // Set all the fields
                Object.keys(data).forEach((fieldKey) => {
                    const value = data[fieldKey];

                    // Future: Make this logic configurable
                    if (hasValue(value)) {
                        if (isArray(value)) {
                            // Send arrays as multipart arrays
                            value.forEach((fValue) => {
                                req = req.field(`${fieldKey}[]`, fValue);
                            });
                        } else if (isObject(value)) {
                            // Posting objects as field contents is not supported by superagent
                            //  to work around this we just jsonify them
                            req = req.field(fieldKey, JSON.stringify(value));
                        } else {
                            // Convert values via their toString
                            req = req.field(fieldKey, `${value}`);
                        }
                    }
                });
            } else {
                req = req.send(data);
            }
        }

        return req;
    }

                Object.keys(data).forEach((fieldKey) => {
                    const value = data[fieldKey];

                    // Future: Make this logic configurable
                    if (hasValue(value)) {
                        if (isArray(value)) {
                            // Send arrays as multipart arrays
                            value.forEach((fValue) => {
                                form.append(`${fieldKey}[]`, fValue);
                            });
                        } else if (isObject(value)) {
                            // Posting objects as stringifyed field contents to keep things consistent
                            form.append(fieldKey, JSON.stringify(value));
                        } else {
                            // Convert values via their toString
                            form.append(fieldKey, `${value}`);
                        }
                    }
                });

 .filter((key: string) => hasValue(cookieVal[key]))

 Object.keys(headers).forEach((key) => {
     if (hasValue(headers)) {
         req.headers.set(key, headers[key]);
     }
 });