@spec2ts/openapi-client 3.1.3 → 4.0.1

package/lib/core-parser.js

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMethod = exports.parseOperation = void 0;
-const ts = require("typescript");
-const core = require("@spec2ts/core");
-const core_parser_1 = require("@spec2ts/jsonschema/lib/core-parser");
-const core_parser_2 = require("@spec2ts/openapi/lib/core-parser");
-const util_1 = require("./util");
-const methods = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
-const contentTypes = {
-    "*/*": "json",
-    "application/json": "json",
-    "application/x-www-form-urlencoded": "form",
-    "multipart/form-data": "multipart",
-};
-function parseOperation(path, item, method, operation, context) {
-    const result = {
-        name: getOperationVar(method, path, operation.operationId, context),
-        paramsVars: {},
-        args: [],
-        query: [],
-        header: [],
-        response: core.keywordType.void
-    };
-    parseArgs(result, item, operation, context);
-    parseResponses(result, path, method, operation, context);
-    return result;
-}
-exports.parseOperation = parseOperation;
-function parseArgs(result, item, operation, context) {
-    parseParameters(result, item, operation, context);
-    if (operation.requestBody) {
-        parseRequestBody(result, operation.requestBody, context);
-    }
-    result.args.push(core.createParameter("options", {
-        type: ts.factory.createTypeReferenceNode("RequestOptions", undefined),
-        questionToken: true,
-    }));
-}
-function parseResponses(result, path, method, operation, context) {
-    const operationName = (0, core_parser_2.getOperationName)(method, path, operation.operationId, context);
-    result.response = getTypeFromResponses(operationName, operation.responses, context);
-    result.responseJSON = isJSONResponse(operation.responses, context);
-    result.responseVoid = result.response === core.keywordType.void;
-}
-function parseParameters(result, item, operation, context) {
-    const parameters = fixDeepObjects([
-        ...resolveReferences(item.parameters, context),
-        ...resolveReferences(operation.parameters, context),
-    ]);
-    result.query = parameters.filter((p) => p.in === "query");
-    result.header = parameters.filter((p) => p.in === "header");
-    const argNames = result.paramsVars = createParametersNames(parameters);
-    let objectBindingParams = parameters;
-    if (context.options.inlineRequired) {
-        const [required, optional] = splitParameters(parameters);
-        objectBindingParams = optional;
-        required.forEach(p => {
-            result.args.push(core.createParameter(argNames[p.name], {
-                type: (0, core_parser_1.getTypeFromSchema)(p.schema, context),
-            }));
-        });
-    }
-    if (!objectBindingParams.length) {
-        return;
-    }
-    result.args.push(core.createParameter(core.createObjectBinding(objectBindingParams.map(({ name }) => ({ name: argNames[name] }))), {
-        initializer: objectBindingParams.some(p => p.required) ? undefined : ts.factory.createObjectLiteralExpression(),
-        type: ts.factory.createTypeLiteralNode(objectBindingParams.map((p) => core.createPropertySignature({
-            name: argNames[p.name],
-            questionToken: !p.required,
-            type: (0, core_parser_1.getTypeFromSchema)(p.schema, context)
-        }))),
-    }));
-}
-function parseRequestBody(result, requestBody, context) {
-    const body = (0, core_parser_1.resolveReference)(requestBody, context);
-    const [schema, mode] = getSchemaFromContent(body.content);
-    const type = (0, core_parser_1.getTypeFromSchema)(schema, context);
-    const bodyVar = result.bodyVar = (0, util_1.camelCase)(type.name || getReferenceName(schema) || "body");
-    result.bodyMode = mode;
-    result.args.push(core.createParameter(bodyVar, { type }));
-}
-function createParametersNames(parameters) {
-    const argNames = {};
-    parameters.forEach(({ name }) => {
-        // strip leading namespaces, eg. foo.name -> name
-        const stripped = (0, util_1.camelCase)(name.replace(/.+\./, ""));
-        // keep the prefix if the stripped-down name is already taken
-        argNames[name] = stripped in argNames ? (0, util_1.camelCase)(name) : stripped;
-    });
-    return argNames;
-}
-function splitParameters(parameters) {
-    const required = [];
-    const optional = [];
-    parameters.forEach(p => {
-        if (p.required)
-            required.push(p);
-        else
-            optional.push(p);
-    });
-    return [required, optional];
-}
-function getTypeFromResponses(operationName, res, context) {
-    const codes = Object.keys(res);
-    const types = [];
-    codes.forEach(code => {
-        const isOK = isOKResponse(code, codes.length);
-        const type = getTypeFromResponse(res[code], context);
-        if (!type)
-            console.log(res[code]);
-        if (ts.isTypeReferenceNode(type) || core.isKeywordTypeNode(type)) {
-            isOK && types.push(type);
-        }
-        else {
-            const name = (0, core_parser_2.getResponseName)(operationName, code, context);
-            context.aliases.push(core.createTypeOrInterfaceDeclaration({
-                modifiers: [core.modifier.export],
-                name, type
-            }));
-            if (isOK) {
-                types.push(ts.factory.createTypeReferenceNode(name, undefined));
-            }
-        }
-    });
-    if (types.length === 1) {
-        return types[0];
-    }
-    return ts.factory.createUnionTypeNode(types);
-}
-function isJSONResponse(responses, context) {
-    var _a, _b;
-    const codes = Object.keys(responses);
-    const resCode = codes.find(code => isOKResponse(code, codes.length));
-    if (!resCode) {
-        return false;
-    }
-    const response = (0, core_parser_1.resolveReference)(responses[resCode], context);
-    return (!!((_a = response === null || response === void 0 ? void 0 : response.content) === null || _a === void 0 ? void 0 : _a["application/json"]) ||
-        !!((_b = response === null || response === void 0 ? void 0 : response.content) === null || _b === void 0 ? void 0 : _b["*/*"]));
-}
-function isOKResponse(code, codesCount) {
-    return codesCount === 1 || parseInt(code, 10) < 400;
-}
-//#endregion
-//#region Private
-function isMethod(method) {
-    return methods.includes(method);
-}
-exports.isMethod = isMethod;
-//#endregion
-//#region Private
-function getTypeFromResponse(res, context) {
-    res = (0, core_parser_1.resolveReference)(res, context);
-    if (!(res === null || res === void 0 ? void 0 : res.content)) {
-        return core.keywordType.void;
-    }
-    return (0, core_parser_1.getTypeFromSchema)(getSchemaFromContent(res.content)[0], context);
-}
-function getSchemaFromContent(content) {
-    var _a;
-    const res = Object.entries(contentTypes).find(([t]) => t in content);
-    let schema;
-    let mode;
-    if (res) {
-        const [contentType, contentMode] = res;
-        mode = contentMode;
-        schema = (_a = content === null || content === void 0 ? void 0 : content[contentType]) === null || _a === void 0 ? void 0 : _a.schema;
-    }
-    return [schema || { type: "string" }, mode];
-}
-function resolveReferences(array, context) {
-    var _a;
-    return (_a = array === null || array === void 0 ? void 0 : array.map(ref => (0, core_parser_1.resolveReference)(ref, context))) !== null && _a !== void 0 ? _a : [];
-}
-function getReferenceName(obj) {
-    if ((0, core_parser_1.isReference)(obj)) {
-        return (0, util_1.camelCase)(obj.$ref.split("/").slice(-1)[0]);
-    }
-}
-/**
- * Despite its name, OpenApi's `deepObject` serialization does not support
- * deeply nested objects. As a workaround we detect parameters that contain
- * square brackets and merge them into a single object.
- */
-function fixDeepObjects(params) {
-    const res = [];
-    const merged = {};
-    params.forEach((p) => {
-        const m = /^(.+?)\[(.*?)\]/.exec(p.name);
-        if (!m) {
-            res.push(p);
-            return;
-        }
-        const [, name, prop] = m;
-        let obj = merged[name];
-        if (!obj) {
-            obj = merged[name] = {
-                name,
-                in: p.in,
-                style: "deepObject",
-                schema: {
-                    type: "object",
-                    properties: {},
-                },
-            };
-            res.push(obj);
-        }
-        obj.schema.properties[prop] = p.schema;
-    });
-    return res;
-}
-function getOperationVar(verb, path, operationId, context) {
-    const id = getOperationVarId(operationId);
-    if (id) {
-        return id;
-    }
-    return getPathVar(`${verb} ${path}`, context);
-}
-function getPathVar(path, context) {
-    path = path.replace(/\{(.+?)\}/, "by $1").replace(/\{(.+?)\}/g, "and $1");
-    let name = (0, util_1.camelCase)(path);
-    const count = (context.names[name] = (context.names[name] || 0) + 1);
-    if (count > 1) {
-        name += count;
-    }
-    return name;
-}
-function getOperationVarId(id) {
-    if (!id)
-        return;
-    if (id.match(/[^\w\s]/))
-        return;
-    id = (0, util_1.camelCase)(id);
-    if (core.isValidIdentifier(id))
-        return id;
-}
-//#endregion

package/lib/openapi-generator.d.ts

@@ -1,22 +0,0 @@
-import * as ts from "typescript";
-import type { OpenAPIObject } from "openapi3-ts/oas31";
-import { ParserOptions } from "@spec2ts/jsonschema/lib/core-parser";
-export interface OApiGeneratorOptions extends ParserOptions {
-    inlineRequired?: boolean;
-    importFetch?: "node-fetch" | "cross-fetch" | "isomorphic-fetch";
-    typesPath?: string;
-    baseUrl?: string;
-    prefix?: string;
-}
-export declare function generateClientFromFile(file: string, options: OApiGeneratorOptions & {
-    typesPath: string;
-}): Promise<SeparatedClientResult>;
-export declare function generateClientFromFile(file: string, options?: OApiGeneratorOptions): Promise<ts.SourceFile>;
-export declare function generateClient(spec: OpenAPIObject, options: OApiGeneratorOptions & {
-    typesPath: string;
-}): Promise<SeparatedClientResult>;
-export declare function generateClient(spec: OpenAPIObject, options?: OApiGeneratorOptions): Promise<ts.SourceFile>;
-export interface SeparatedClientResult {
-    client: ts.SourceFile;
-    types: ts.SourceFile;
-}

package/lib/openapi-generator.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateClient = exports.generateClientFromFile = void 0;
-const path = require("path");
-const ts = require("typescript");
-const core = require("@spec2ts/core");
-const json_schema_ref_parser_1 = require("@apidevtools/json-schema-ref-parser");
-const core_parser_1 = require("@spec2ts/jsonschema/lib/core-parser");
-const core_parser_2 = require("@spec2ts/openapi/lib/core-parser");
-const core_generator_1 = require("./core-generator");
-async function generateClientFromFile(file, options = {}) {
-    const schema = await json_schema_ref_parser_1.default.parse(file);
-    return generateClient(schema, {
-        cwd: path.resolve(path.dirname(file)) + "/",
-        ...options
-    });
-}
-exports.generateClientFromFile = generateClientFromFile;
-async function generateClient(spec, options = {}) {
-    if (!options.parseReference) {
-        options.parseReference = core_parser_2.parseReference;
-    }
-    const context = await (0, core_parser_1.createContext)(spec, options);
-    let file = await core.createSourceFileFromFile(__dirname + "/templates/_client.tpl.ts");
-    if (context.options.typesPath) {
-        context.typesFile = ts.createSourceFile("types.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    }
-    file = (0, core_generator_1.generateServers)(file, spec, context);
-    file = (0, core_generator_1.generateDefaults)(file, context);
-    file = (0, core_generator_1.generateFunctions)(file, spec, context);
-    if (context.options.typesPath) {
-        return {
-            client: file,
-            types: context.typesFile
-        };
-    }
-    return file;
-}
-exports.generateClient = generateClient;

package/lib/server-parser.d.ts

@@ -1,4 +0,0 @@
-import * as ts from "typescript";
-import type { ServerObject } from "openapi3-ts/oas31";
-export declare function parseServers(servers: ServerObject[]): ts.ObjectLiteralExpression;
-export declare function defaultBaseUrl(servers: ServerObject[]): ts.StringLiteral;

package/lib/server-parser.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultBaseUrl = exports.parseServers = void 0;
-const ts = require("typescript");
-const core = require("@spec2ts/core");
-const util_1 = require("./util");
-function parseServers(servers) {
-    const props = servers.map((server, i) => [serverName(server, i), generateServerExpression(server)]);
-    return core.createObjectLiteral(props);
-}
-exports.parseServers = parseServers;
-function defaultBaseUrl(servers) {
-    return ts.factory.createStringLiteral(defaultUrl(servers[0]));
-}
-exports.defaultBaseUrl = defaultBaseUrl;
-function serverName(server, index) {
-    return server.description ?
-        (0, util_1.camelCase)(server.description.replace(/\W+/, " ")) :
-        `server${index + 1}`;
-}
-function generateServerExpression(server) {
-    return server.variables ?
-        createServerFunction(server.url, server.variables) :
-        ts.factory.createStringLiteral(server.url);
-}
-function createServerFunction(template, vars) {
-    const params = [
-        core.createParameter(core.createObjectBinding(Object.entries(vars || {}).map(([name, value]) => {
-            return {
-                name,
-                initializer: createLiteral(value.default),
-            };
-        })), {
-            type: ts.factory.createTypeLiteralNode(Object.entries(vars || {}).map(([name, value]) => {
-                return core.createPropertySignature({
-                    name,
-                    type: value.enum ?
-                        ts.factory.createUnionTypeNode(createUnion(value.enum)) :
-                        ts.factory.createUnionTypeNode([
-                            core.keywordType.string,
-                            core.keywordType.number,
-                            core.keywordType.boolean,
-                        ]),
-                });
-            })),
-        }),
-    ];
-    return core.createArrowFunction(params, createTemplate(template));
-}
-function createUnion(strs) {
-    return strs.map((e) => ts.factory.createLiteralTypeNode(createLiteral(e)));
-}
-function createTemplate(url) {
-    const tokens = url.split(/{([\s\S]+?)}/g);
-    const spans = [];
-    const len = tokens.length;
-    for (let i = 1; i < len; i += 2) {
-        spans.push(ts.factory.createTemplateSpan(ts.factory.createIdentifier(tokens[i]), (i === len - 2 ? ts.factory.createTemplateTail : ts.factory.createTemplateMiddle)(tokens[i + 1])));
-    }
-    return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(tokens[0]), spans);
-}
-function createLiteral(v) {
-    switch (typeof v) {
-        case "string":
-            return ts.factory.createStringLiteral(v);
-        case "boolean":
-            return v ? ts.factory.createTrue() : ts.factory.createFalse();
-        case "number":
-            return ts.factory.createNumericLiteral(String(v));
-    }
-}
-function defaultUrl(server) {
-    if (!server)
-        return "/";
-    const { url, variables } = server;
-    if (!variables)
-        return url;
-    return url.replace(/\{(.+?)\}/g, (m, name) => variables[name] ? String(variables[name].default) : m);
-}

package/lib/templates/_client.tpl.d.ts

@@ -1,81 +0,0 @@
-export declare const defaults: RequestOptions;
-export declare const servers: {};
-export type RequestOptions = {
-    baseUrl?: string;
-    fetch?: typeof fetch;
-    headers?: Record<string, string | undefined>;
-} & Omit<RequestInit, "body" | "headers">;
-export type ApiResponse<T> = {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    data: T;
-};
-type Encoders = Array<(s: string) => string>;
-type TagFunction = (strings: TemplateStringsArray, ...values: any[]) => string;
-type FetchRequestOptions = RequestOptions & {
-    body?: string | FormData;
-};
-type JsonRequestOptions = RequestOptions & {
-    body: unknown;
-};
-type FormRequestOptions<T extends Record<string, unknown>> = RequestOptions & {
-    body: T;
-};
-type MultipartRequestOptions = RequestOptions & {
-    body: Record<string, any>;
-};
-/** Utilities functions */
-export declare const _: {
-    encodeReserved: (typeof encodeURI)[];
-    allowReserved: (typeof encodeURI)[];
-    /** Deeply remove all properties with undefined values. */
-    stripUndefined<T extends Record<string, U | undefined>, U>(obj?: T | undefined): Record<string, U> | undefined;
-    isEmpty(v: unknown): boolean;
-    /** Creates a tag-function to encode template strings with the given encoders. */
-    encode(encoders: Encoders, delimiter?: string): TagFunction;
-    /** Separate array values by the given delimiter. */
-    delimited(delimiter?: string): (params: Record<string, any>, encoders?: Encoders) => string;
-    /** Join URLs parts. */
-    joinUrl(...parts: Array<string | undefined>): string;
-};
-/** Functions to serialize query parameters in different styles. */
-export declare const QS: {
-    /** Join params using an ampersand and prepends a questionmark if not empty. */
-    query(...params: string[]): string;
-    /**
-     * Serializes nested objects according to the `deepObject` style specified in
-     * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#style-values
-     */
-    deep(params: Record<string, any>, [k, v]?: (typeof encodeURI)[]): string;
-    /**
-     * Property values of type array or object generate separate parameters
-     * for each value of the array, or key-value-pair of the map.
-     * For other types of properties this property has no effect.
-     * See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#encoding-object
-     */
-    explode(params: Record<string, any>, encoders?: (typeof encodeURI)[]): string;
-    form: (params: Record<string, any>, encoders?: Encoders) => string;
-    pipe: (params: Record<string, any>, encoders?: Encoders) => string;
-    space: (params: Record<string, any>, encoders?: Encoders) => string;
-};
-/** Http request base methods. */
-export declare const http: {
-    fetch(url: string, req?: FetchRequestOptions): Promise<ApiResponse<string | undefined>>;
-    fetchJson(url: string, req?: FetchRequestOptions): Promise<ApiResponse<any>>;
-    fetchVoid(url: string, req?: FetchRequestOptions): Promise<ApiResponse<undefined>>;
-    json({ body, headers, ...req }: JsonRequestOptions): FetchRequestOptions;
-    form<T extends Record<string, unknown>>({ body, headers, ...req }: FormRequestOptions<T>): FetchRequestOptions;
-    multipart({ body, ...req }: MultipartRequestOptions): FetchRequestOptions;
-    headers(headers: Headers): Record<string, string>;
-};
-export declare class HttpError extends Error {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    data?: Record<string, unknown>;
-    constructor(status: number, statusText: string, url: string, headers: Headers, text?: string);
-}
-/** Utility Type to extract returns type from a method. */
-export type ApiResult<Fn> = Fn extends (...args: any) => Promise<ApiResponse<infer T>> ? T : never;
-export {};

package/lib/templates/_client.tpl.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpError = exports.http = exports.QS = exports._ = exports.servers = exports.defaults = void 0;
-exports.defaults = {
-    baseUrl: "/",
-};
-exports.servers = {};
-/** Utilities functions */
-exports._ = {
-    // Encode param names and values as URIComponent
-    encodeReserved: [encodeURI, encodeURIComponent],
-    allowReserved: [encodeURI, encodeURI],
-    /** Deeply remove all properties with undefined values. */
-    stripUndefined(obj) {
-        return obj && JSON.parse(JSON.stringify(obj));
-    },
-    isEmpty(v) {
-        return typeof v === "object" && !!v ?
-            Object.keys(v).length === 0 && v.constructor === Object :
-            v === undefined;
-    },
-    /** Creates a tag-function to encode template strings with the given encoders. */
-    encode(encoders, delimiter = ",") {
-        return (strings, ...values) => {
-            return strings.reduce((prev, s, i) => { var _a; return `${prev}${s}${q((_a = values[i]) !== null && _a !== void 0 ? _a : "", i)}`; }, "");
-        };
-        function q(v, i) {
-            const encoder = encoders[i % encoders.length];
-            if (typeof v === "object") {
-                if (Array.isArray(v)) {
-                    return v.map(encoder).join(delimiter);
-                }
-                const flat = Object.entries(v).reduce((flat, entry) => [...flat, ...entry], []);
-                return flat.map(encoder).join(delimiter);
-            }
-            return encoder(String(v));
-        }
-    },
-    /** Separate array values by the given delimiter. */
-    delimited(delimiter = ",") {
-        return (params, encoders = exports._.encodeReserved) => Object.entries(params)
-            .filter(([, value]) => !exports._.isEmpty(value))
-            .map(([name, value]) => exports._.encode(encoders, delimiter) `${name}=${value}`)
-            .join("&");
-    },
-    /** Join URLs parts. */
-    joinUrl(...parts) {
-        return parts
-            .filter(Boolean)
-            .join("/")
-            .replace(/([^:]\/)\/+/, "$1");
-    }
-};
-/** Functions to serialize query parameters in different styles. */
-exports.QS = {
-    /** Join params using an ampersand and prepends a questionmark if not empty. */
-    query(...params) {
-        const s = params.filter(p => !!p).join("&");
-        return s && `?${s}`;
-    },
-    /**
-     * Serializes nested objects according to the `deepObject` style specified in
-     * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#style-values
-     */
-    deep(params, [k, v] = exports._.encodeReserved) {
-        const qk = exports._.encode([(s) => s, k]);
-        const qv = exports._.encode([(s) => s, v]);
-        // don't add index to arrays
-        // https://github.com/expressjs/body-parser/issues/289
-        const visit = (obj, prefix = "") => Object.entries(obj)
-            .filter(([, v]) => !exports._.isEmpty(v))
-            .map(([prop, v]) => {
-            const isValueObject = typeof v === "object";
-            const index = Array.isArray(obj) && !isValueObject ? "" : prop;
-            const key = prefix ? qk `${prefix}[${index}]` : prop;
-            if (isValueObject) {
-                return visit(v, key);
-            }
-            return qv `${key}=${v}`;
-        })
-            .join("&");
-        return visit(params);
-    },
-    /**
-     * Property values of type array or object generate separate parameters
-     * for each value of the array, or key-value-pair of the map.
-     * For other types of properties this property has no effect.
-     * See https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#encoding-object
-     */
-    explode(params, encoders = exports._.encodeReserved) {
-        const q = exports._.encode(encoders);
-        return Object.entries(params)
-            .filter(([, value]) => typeof value !== "undefined")
-            .map(([name, value]) => {
-            if (Array.isArray(value)) {
-                return value.map((v) => q `${name}=${v}`).join("&");
-            }
-            if (typeof value === "object") {
-                return exports.QS.explode(value, encoders);
-            }
-            return q `${name}=${value}`;
-        })
-            .join("&");
-    },
-    form: exports._.delimited(),
-    pipe: exports._.delimited("|"),
-    space: exports._.delimited("%20"),
-};
-/** Http request base methods. */
-exports.http = {
-    async fetch(url, req) {
-        const { baseUrl, headers, fetch: customFetch, ...init } = { ...exports.defaults, ...req };
-        const href = exports._.joinUrl(baseUrl, url);
-        const res = await (customFetch || fetch)(href, {
-            ...init,
-            headers: exports._.stripUndefined({ ...exports.defaults.headers, ...headers }),
-        });
-        let text;
-        try {
-            text = await res.text();
-        }
-        catch (err) { /* ok */ }
-        if (!res.ok) {
-            throw new HttpError(res.status, res.statusText, href, res.headers, text);
-        }
-        return {
-            status: res.status,
-            statusText: res.statusText,
-            headers: exports.http.headers(res.headers),
-            data: text
-        };
-    },
-    async fetchJson(url, req = {}) {
-        const res = await exports.http.fetch(url, {
-            ...req,
-            headers: {
-                ...req.headers,
-                Accept: "application/json",
-            },
-        });
-        res.data = res.data && JSON.parse(res.data);
-        return res;
-    },
-    async fetchVoid(url, req = {}) {
-        const res = await exports.http.fetch(url, {
-            ...req,
-            headers: {
-                ...req.headers,
-                Accept: "application/json",
-            },
-        });
-        return res;
-    },
-    json({ body, headers, ...req }) {
-        return {
-            ...req,
-            body: JSON.stringify(body),
-            headers: {
-                ...headers,
-                "Content-Type": "application/json",
-            },
-        };
-    },
-    form({ body, headers, ...req }) {
-        return {
-            ...req,
-            body: exports.QS.form(body),
-            headers: {
-                ...headers,
-                "Content-Type": "application/x-www-form-urlencoded",
-            },
-        };
-    },
-    multipart({ body, ...req }) {
-        const data = new FormData();
-        Object.entries(body).forEach(([name, value]) => {
-            data.append(name, value);
-        });
-        return {
-            ...req,
-            body: data,
-        };
-    },
-    headers(headers) {
-        const res = {};
-        headers.forEach((value, key) => res[key] = value);
-        return res;
-    }
-};
-class HttpError extends Error {
-    constructor(status, statusText, url, headers, text) {
-        super(`${url} - ${statusText} (${status})`);
-        this.status = status;
-        this.statusText = statusText;
-        this.headers = exports.http.headers(headers);
-        if (text) {
-            try {
-                this.data = JSON.parse(text);
-            }
-            catch (err) { /* ok */ }
-        }
-    }
-}
-exports.HttpError = HttpError;