@faasjs/http 0.0.2-beta.302 → 0.0.2-beta.314

package/dist/index.mjs

@@ -0,0 +1,498 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  usePlugin
+} from "@faasjs/func";
+import { deepMerge as deepMerge2 } from "@faasjs/deep_merge";
+import { Logger } from "@faasjs/logger";
+
+// src/session.ts
+import {
+  randomBytes,
+  pbkdf2Sync,
+  createCipheriv,
+  createHmac,
+  createDecipheriv
+} from "crypto";
+var Session = class {
+  constructor(cookie, config) {
+    this.cookie = cookie;
+    this.config = Object.assign({
+      key: "key",
+      secret: randomBytes(128).toString("hex"),
+      salt: "salt",
+      signedSalt: "signedSalt",
+      keylen: 64,
+      iterations: 100,
+      digest: "sha256",
+      cipherName: "aes-256-cbc"
+    }, config);
+    this.secret = pbkdf2Sync(this.config.secret, this.config.salt, this.config.iterations, this.config.keylen / 2, this.config.digest);
+    this.signedSecret = pbkdf2Sync(this.config.secret, this.config.signedSalt, this.config.iterations, this.config.keylen, this.config.digest);
+    this.content = Object.create(null);
+  }
+  invoke(cookie) {
+    try {
+      this.content = cookie ? this.decode(cookie) : Object.create(null);
+    } catch (error) {
+      console.error(error);
+      this.content = Object.create(null);
+    }
+    this.changed = false;
+  }
+  encode(text) {
+    if (typeof text !== "string")
+      text = JSON.stringify(text);
+    const iv = randomBytes(16);
+    const cipher = createCipheriv(this.config.cipherName, this.secret, iv);
+    const encrypted = Buffer.concat([cipher.update(text), cipher.final()]).toString("base64");
+    const main = Buffer.from([encrypted, iv.toString("base64")].join("--")).toString("base64");
+    const hmac = createHmac(this.config.digest, this.signedSecret);
+    hmac.update(main);
+    const digest = hmac.digest("hex");
+    return main + "--" + digest;
+  }
+  decode(text) {
+    text = decodeURIComponent(text);
+    const signedParts = text.split("--");
+    const hmac = createHmac(this.config.digest, this.signedSecret);
+    hmac.update(signedParts[0]);
+    const digest = hmac.digest("hex");
+    if (signedParts[1] !== digest)
+      throw Error("Not valid");
+    const message = Buffer.from(signedParts[0], "base64").toString();
+    const parts = message.split("--").map(function(part2) {
+      return Buffer.from(part2, "base64");
+    });
+    const cipher = createDecipheriv(this.config.cipherName, this.secret, parts[1]);
+    const part = Buffer.from(cipher.update(parts[0])).toString("utf8");
+    const final = cipher.final("utf8");
+    const decrypt = [part, final].join("");
+    return JSON.parse(decrypt);
+  }
+  read(key) {
+    return this.content[key];
+  }
+  write(key, value) {
+    if (value === null || typeof value === "undefined")
+      delete this.content[key];
+    else
+      this.content[key] = value;
+    this.changed = true;
+    return this;
+  }
+  update() {
+    if (this.changed)
+      this.cookie.write(this.config.key, this.encode(JSON.stringify(this.content)));
+    return this;
+  }
+};
+
+// src/cookie.ts
+import { deepMerge } from "@faasjs/deep_merge";
+var Cookie = class {
+  constructor(config) {
+    this.config = deepMerge({
+      path: "/",
+      expires: 31536e3,
+      secure: true,
+      httpOnly: true,
+      session: {}
+    }, config);
+    this.session = new Session(this, this.config.session);
+    this.content = Object.create(null);
+    this.setCookie = Object.create(null);
+  }
+  invoke(cookie) {
+    this.content = Object.create(null);
+    if (cookie)
+      cookie.split(";").forEach((x) => {
+        x = x.trim();
+        const k = /([^=]+)/.exec(x);
+        if (k !== null)
+          this.content[k[0]] = decodeURIComponent(x.replace(`${k[0]}=`, "").replace(/;$/, ""));
+      });
+    this.setCookie = Object.create(null);
+    this.session.invoke(this.read(this.session.config.key));
+    return this;
+  }
+  read(key) {
+    return this.content[key];
+  }
+  write(key, value, opts) {
+    opts = Object.assign(this.config, opts || {});
+    let cookie;
+    if (value === null || typeof value === "undefined") {
+      opts.expires = "Thu, 01 Jan 1970 00:00:01 GMT";
+      cookie = `${key}=;`;
+      delete this.content[key];
+    } else {
+      cookie = `${key}=${encodeURIComponent(value)};`;
+      this.content[key] = value;
+    }
+    if (typeof opts.expires === "number")
+      cookie += `max-age=${opts.expires};`;
+    else if (typeof opts.expires === "string")
+      cookie += `expires=${opts.expires};`;
+    cookie += `path=${opts.path || "/"};`;
+    if (opts.domain)
+      cookie += `domain=${opts.domain};`;
+    if (opts.secure)
+      cookie += "Secure;";
+    if (opts.httpOnly)
+      cookie += "HttpOnly;";
+    if (opts.sameSite)
+      cookie += `SameSite=${opts.sameSite};`;
+    this.setCookie[key] = cookie;
+    return this;
+  }
+  headers() {
+    if (Object.keys(this.setCookie).length === 0)
+      return {};
+    else
+      return { "Set-Cookie": Object.values(this.setCookie) };
+  }
+};
+
+// src/validator.ts
+var Validator = class {
+  constructor(config, logger) {
+    this.paramsConfig = config.params;
+    this.cookieConfig = config.cookie;
+    this.sessionConfig = config.session;
+    this.before = config.before;
+    this.logger = logger;
+  }
+  async valid(request) {
+    if (this.before) {
+      const result = await this.before(request);
+      if (result)
+        throw new HttpError(result);
+    }
+    this.request = request;
+    if (this.paramsConfig && request.params) {
+      this.logger.debug("Valid Params");
+      this.validContent("params", request.params, "", this.paramsConfig);
+    }
+    if (this.cookieConfig && request.cookie) {
+      this.logger.debug("Valid Cookie");
+      if (request.cookie == null)
+        throw Error("Not found Cookie");
+      this.validContent("cookie", request.cookie.content, "", this.cookieConfig);
+    }
+    if (this.sessionConfig && request.session) {
+      this.logger.debug("Valid Session");
+      if (request.session == null)
+        throw Error("Not found Session");
+      this.validContent("session", request.session.content, "", this.sessionConfig);
+    }
+  }
+  validContent(type, params, baseKey, config) {
+    if (config.whitelist) {
+      const paramsKeys = Object.keys(params);
+      const rulesKeys = Object.keys(config.rules);
+      const diff = paramsKeys.filter((k) => !rulesKeys.includes(k));
+      if (diff.length > 0) {
+        if (config.whitelist === "error") {
+          const diffKeys = diff.map((k) => `${baseKey}${k}`);
+          const error = Error(`[${type}] Not permitted keys: ${diffKeys.join(", ")}`);
+          if (config.onError) {
+            const res = config.onError(`${type}.whitelist`, baseKey, diffKeys);
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        } else if (config.whitelist === "ignore")
+          for (const key of diff)
+            delete params[key];
+      }
+    }
+    for (const key in config.rules) {
+      const rule = config.rules[key];
+      if (!rule)
+        continue;
+      let value = params[key];
+      if (rule.default) {
+        if (type === "cookie" || type === "session")
+          this.logger.warn("Cookie and Session not support default rule.");
+        else if (typeof value === "undefined" && rule.default) {
+          value = typeof rule.default === "function" ? rule.default(this.request) : rule.default;
+          params[key] = value;
+        }
+      }
+      if (rule.required) {
+        if (typeof value === "undefined" || value === null) {
+          const error = Error(`[${type}] ${baseKey}${key} is required.`);
+          if (config.onError) {
+            const res = config.onError(`${type}.rule.required`, `${baseKey}${key}`, value);
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        }
+      }
+      if (typeof value !== "undefined" && value !== null) {
+        if (rule.type)
+          if (type === "cookie")
+            this.logger.warn("Cookie not support type rule");
+          else {
+            let typed = true;
+            switch (rule.type) {
+              case "array":
+                typed = Array.isArray(value);
+                break;
+              case "object":
+                typed = Object.prototype.toString.call(value) === "[object Object]";
+                break;
+              default:
+                typed = typeof value === rule.type;
+                break;
+            }
+            if (!typed) {
+              const error = Error(`[${type}] ${baseKey}${key} must be a ${rule.type}.`);
+              if (config.onError) {
+                const res = config.onError(`${type}.rule.type`, `${baseKey}${key}`, value);
+                if (res)
+                  throw new HttpError(res);
+              }
+              throw error;
+            }
+          }
+        if (rule.in && !rule.in.includes(value)) {
+          const error = Error(`[${type}] ${baseKey}${key} must be in ${rule.in.join(", ")}.`);
+          if (config.onError) {
+            const res = config.onError(`${type}.rule.in`, `${baseKey}${key}`, value);
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        }
+        if (rule.config) {
+          if (type === "cookie")
+            this.logger.warn("Cookie not support nest rule.");
+          else if (Array.isArray(value))
+            for (const val of value)
+              this.validContent(type, val, baseKey ? `${baseKey}.${key}.` : `${key}.`, rule.config);
+          else if (typeof value === "object")
+            this.validContent(type, value, baseKey ? `${baseKey}.${key}.` : `${key}.`, rule.config);
+        }
+      }
+    }
+  }
+};
+
+// src/index.ts
+import {
+  gzipSync,
+  deflateSync,
+  brotliCompressSync
+} from "zlib";
+var ContentType = {
+  plain: "text/plain",
+  html: "text/html",
+  xml: "application/xml",
+  csv: "text/csv",
+  css: "text/css",
+  javascript: "application/javascript",
+  json: "application/json",
+  jsonp: "application/javascript"
+};
+var HttpError = class extends Error {
+  constructor({
+    statusCode,
+    message
+  }) {
+    super(message);
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, HttpError);
+    this.statusCode = statusCode || 500;
+    this.message = message;
+  }
+};
+var Name = "http";
+var Http = class {
+  constructor(config) {
+    this.type = Name;
+    this.name = Name;
+    this.name = (config == null ? void 0 : config.name) || this.type;
+    this.config = (config == null ? void 0 : config.config) || Object.create(null);
+    if (config == null ? void 0 : config.validator)
+      this.validatorOptions = config.validator;
+    this.logger = new Logger(this.name);
+    this.headers = Object.create(null);
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+  }
+  async onDeploy(data, next) {
+    var _a;
+    await next();
+    this.logger.debug("\u7EC4\u88C5\u7F51\u5173\u914D\u7F6E");
+    this.logger.debug("%j", data);
+    const config = data.config.plugins ? deepMerge2(data.config.plugins[this.name || this.type], { config: this.config }) : { config: this.config };
+    if (!config.config.path) {
+      config.config.path = "/" + ((_a = data.name) == null ? void 0 : _a.replace(/_/g, "/").replace(/\/index$/, ""));
+      if (config.config.path === "/index")
+        config.config.path = "/";
+      if (config.config.ignorePathPrefix) {
+        config.config.path = config.config.path.replace(new RegExp("^" + config.config.ignorePathPrefix), "");
+        if (config.config.path === "")
+          config.config.path = "/";
+      }
+    }
+    this.logger.debug("\u7EC4\u88C5\u5B8C\u6210 %j", config);
+    const Provider = __require(config.provider.type).Provider;
+    const provider = new Provider(config.provider.config);
+    await provider.deploy(this.type, data, config);
+  }
+  async onMount(data, next) {
+    this.logger.debug("[onMount] merge config");
+    if (data.config.plugins && data.config.plugins[this.name || this.type])
+      this.config = deepMerge2(this.config, data.config.plugins[this.name || this.type].config);
+    this.logger.debug("[onMount] prepare cookie & session");
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+    if (this.validatorOptions) {
+      this.logger.debug("[onMount] prepare validator");
+      this.validator = new Validator(this.validatorOptions, this.logger);
+    }
+    await next();
+  }
+  async onInvoke(data, next) {
+    var _a, _b;
+    this.headers = data.event.headers || Object.create(null);
+    this.body = data.event.body;
+    this.params = Object.create(null);
+    this.response = { headers: Object.create(null) };
+    if (data.event.body) {
+      if (data.event.headers && data.event.headers["content-type"] && data.event.headers["content-type"].includes("application/json")) {
+        this.logger.debug("[onInvoke] Parse params from json body");
+        this.params = JSON.parse(data.event.body);
+      } else {
+        this.logger.debug("[onInvoke] Parse params from raw body");
+        this.params = data.event.body;
+      }
+      this.logger.debug("[onInvoke] Params: %j", this.params);
+    } else if (data.event.queryString) {
+      this.logger.debug("[onInvoke] Parse params from queryString");
+      this.params = data.event.queryString;
+      this.logger.debug("[onInvoke] Params: %j", this.params);
+    }
+    this.cookie.invoke(this.headers.cookie);
+    if (this.headers.cookie) {
+      this.logger.debug("[onInvoke] Cookie: %j", this.cookie.content);
+      this.logger.debug("[onInvoke] Session: %j", this.session.content);
+    }
+    if (this.validator) {
+      this.logger.debug("[onInvoke] Valid request");
+      try {
+        await this.validator.valid({
+          headers: this.headers,
+          params: this.params,
+          cookie: this.cookie,
+          session: this.session
+        });
+      } catch (error) {
+        this.logger.error(error);
+        data.response = {
+          statusCode: error.statusCode || 500,
+          headers: { "Content-Type": "application/json; charset=utf-8" },
+          body: JSON.stringify({ error: { message: error.message } })
+        };
+        return;
+      }
+    }
+    try {
+      await next();
+    } catch (error) {
+      data.response = error;
+    }
+    this.session.update();
+    if (data.response)
+      if (data.response instanceof Error || ((_a = data.response.constructor) == null ? void 0 : _a.name) === "Error") {
+        this.logger.error(data.response);
+        this.response.body = JSON.stringify({ error: { message: data.response.message } });
+        try {
+          this.response.statusCode = data.response.statusCode || 500;
+        } catch (error) {
+          this.response.statusCode = 500;
+        }
+      } else if (Object.prototype.toString.call(data.response) === "[object Object]" && data.response.statusCode && data.response.headers)
+        this.response = data.response;
+      else
+        this.response.body = JSON.stringify({ data: data.response });
+    if (!this.response.statusCode)
+      this.response.statusCode = this.response.body ? 200 : 201;
+    this.response.headers = Object.assign({
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-cache, no-store"
+    }, this.cookie.headers(), this.response.headers);
+    data.response = this.response;
+    if (process.env.FaasMode === "local") {
+      this.logger.debug("[onInvoke] Response: %j", data.response);
+      return;
+    }
+    if (data.response.isBase64Encoded || typeof data.response.body !== "string" || !((_b = data.response.headers["Content-Type"]) == null ? void 0 : _b.includes("json")) || data.response.body.length < 100)
+      return;
+    const acceptEncoding = this.headers["accept-encoding"] || this.headers["Accept-Encoding"];
+    if (!acceptEncoding || !/(br|gzip|deflate)/.test(acceptEncoding))
+      return;
+    const originBody = data.response.body;
+    try {
+      if (acceptEncoding.includes("br")) {
+        data.response.headers["Content-Encoding"] = "br";
+        data.response.body = brotliCompressSync(originBody).toString("base64");
+      } else if (acceptEncoding.includes("gzip")) {
+        data.response.headers["Content-Encoding"] = "gzip";
+        data.response.body = gzipSync(originBody).toString("base64");
+      } else if (acceptEncoding.includes("deflate")) {
+        data.response.headers["Content-Encoding"] = "deflate";
+        data.response.body = deflateSync(originBody).toString("base64");
+      } else
+        throw Error("No matched compression.");
+      data.response.isBase64Encoded = true;
+      data.response.originBody = originBody;
+    } catch (error) {
+      console.error(error);
+      data.response.body = originBody;
+      delete data.response.headers["Content-Encoding"];
+    }
+  }
+  setHeader(key, value) {
+    this.response.headers[key] = value;
+    return this;
+  }
+  setContentType(type, charset = "utf-8") {
+    if (ContentType[type])
+      this.setHeader("Content-Type", `${ContentType[type]}; charset=${charset}`);
+    else
+      this.setHeader("Content-Type", `${type}; charset=${charset}`);
+    return this;
+  }
+  setStatusCode(code) {
+    this.response.statusCode = code;
+    return this;
+  }
+  setBody(body) {
+    this.response.body = body;
+    return this;
+  }
+};
+function useHttp(config) {
+  return usePlugin(new Http(config));
+}
+export {
+  ContentType,
+  Cookie,
+  Http,
+  HttpError,
+  Session,
+  Validator,
+  useHttp
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@faasjs/http",
-  "version": "0.0.2-beta.302",
+  "version": "0.0.2-beta.314",
   "license": "MIT",
-  "main": "lib/index.js",
-  "module": "lib/index.es.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.mjs",
   "homepage": "https://faasjs.com/docs/http",
   "repository": {
     "type": "git",
@@ -16,22 +16,21 @@
   },
   "funding": "https://github.com/sponsors/faasjs",
   "scripts": {
-    "prepack": "rm -rf ./lib && rollup -c && mv lib/*/src/* lib/"
+    "build": "rm -rf ./dist && tsup-node src/index.ts --format esm,cjs --dts"
   },
   "files": [
-    "lib"
+    "dist"
   ],
-  "devDependencies": {
+  "peerDependencies": {
     "@faasjs/func": "^0.0.2-beta.302",
-    "@types/debug": "*",
-    "@types/jest": "*",
-    "@types/node": "*",
-    "rollup": "*",
-    "rollup-plugin-typescript2": "*",
+    "@faasjs/logger": "^0.0.2-beta.302"
+  },
+  "devDependencies": {
+    "tsup": "*",
     "typescript": "*"
   },
   "engines": {
     "npm": ">=8.0.0"
   },
-  "gitHead": "b53fb35a91369afd0185fb555d98e5c9d90b54bd"
+  "gitHead": "60be0e54eb369177b416d109a3f9a5a12dedbf24"
 }

package/lib/cookie.d.ts

@@ -1,39 +0,0 @@
-import { Session, SessionOptions } from './session';
-export declare type CookieOptions = {
-    domain?: string;
-    path?: string;
-    expires?: number;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: 'Strict' | 'Lax' | 'None';
-    session?: SessionOptions;
-    [key: string]: any;
-};
-export declare class Cookie<C extends Record<string, string> = any, S extends Record<string, string> = any> {
-    session: Session<S, C>;
-    content: Record<string, string>;
-    readonly config: {
-        domain?: string;
-        path: string;
-        expires: number;
-        secure: boolean;
-        httpOnly: boolean;
-        sameSite?: 'Strict' | 'Lax' | 'None';
-        session: SessionOptions;
-    };
-    private setCookie;
-    constructor(config: CookieOptions);
-    invoke(cookie: string | undefined): Cookie<C, S>;
-    read(key: string): any;
-    write(key: string, value: string, opts?: {
-        domain?: string;
-        path?: string;
-        expires?: number | string;
-        secure?: boolean;
-        httpOnly?: boolean;
-        sameSite?: 'Strict' | 'Lax' | 'None';
-    }): Cookie<C, S>;
-    headers(): {
-        'Set-Cookie'?: string[];
-    };
-}

package/lib/index.d.ts

@@ -1,105 +0,0 @@
-import { Plugin, InvokeData, MountData, DeployData, Next, UseifyPlugin } from '@faasjs/func';
-import { Cookie, CookieOptions } from './cookie';
-import { Session, SessionOptions } from './session';
-import { Validator, ValidatorOptions, ValidatorRuleOptions, ValidatorConfig } from './validator';
-export { Cookie, CookieOptions, Session, SessionOptions, Validator, ValidatorConfig, ValidatorOptions, ValidatorRuleOptions };
-export declare const ContentType: {
-    [key: string]: string;
-};
-export declare type HttpConfig<TParams extends Record<string, any> = any, TCookie extends Record<string, string> = any, TSession extends Record<string, string> = any> = {
-    [key: string]: any;
-    name?: string;
-    config?: {
-        [key: string]: any;
-        method?: 'BEGIN' | 'GET' | 'POST' | 'DELETE' | 'HEAD' | 'PUT' | 'OPTIONS' | 'TRACE' | 'PATCH' | 'ANY';
-        timeout?: number;
-        path?: string;
-        ignorePathPrefix?: string;
-        functionName?: string;
-        cookie?: CookieOptions;
-    };
-    validator?: ValidatorConfig<TParams, TCookie, TSession>;
-};
-export declare type Response = {
-    statusCode?: number;
-    headers?: {
-        [key: string]: string;
-    };
-    body?: string;
-    message?: string;
-};
-export declare class HttpError extends Error {
-    readonly statusCode: number;
-    readonly message: string;
-    constructor({ statusCode, message }: {
-        statusCode?: number;
-        message: string;
-    });
-}
-export declare class Http<TParams extends Record<string, any> = any, TCookie extends Record<string, string> = any, TSession extends Record<string, string> = any> implements Plugin {
-    readonly type: string;
-    readonly name: string;
-    headers: {
-        [key: string]: string;
-    };
-    body: any;
-    params: TParams;
-    cookie: Cookie<TCookie, TSession>;
-    session: Session<TSession, TCookie>;
-    config: HttpConfig<TParams, TCookie, TSession>;
-    private readonly validatorOptions?;
-    private response?;
-    private validator?;
-    private readonly logger;
-    /**
-     * 创建 Http 插件实例
-     * @param config {object} 配置项
-     * @param config.name {string} 配置名
-     * @param config.config {object} 网关配置
-     * @param config.config.method {string} 请求方法，默认为 POST
-     * @param config.config.path {string} 请求路径，默认为云函数文件路径
-     * @param config.config.ignorePathPrefix {string} 排除的路径前缀，当设置 path 时无效
-     * @param config.config.cookie {object} Cookie 配置
-     * @param config.validator {object} 入参校验配置
-     * @param config.validator.params {object} params 校验配置
-     * @param config.validator.params.whitelist {string} 白名单配置
-     * @param config.validator.params.onError {function} 自定义报错
-     * @param config.validator.params.rules {object} 参数校验规则
-     * @param config.validator.cookie {object} cookie 校验配置
-     * @param config.validator.cookie.whitelist {string} 白名单配置
-     * @param config.validator.cookie.onError {function} 自定义报错
-     * @param config.validator.cookie.rules {object} 参数校验规则
-     * @param config.validator.session {object} session 校验配置
-     * @param config.validator.session.whitelist {string} 白名单配置
-     * @param config.validator.session.onError {function} 自定义报错
-     * @param config.validator.session.rules {object} 参数校验规则
-     * @param config.validator.before {function} 参数校验前自定义函数
-     */
-    constructor(config?: HttpConfig<TParams, TCookie, TSession>);
-    onDeploy(data: DeployData, next: Next): Promise<void>;
-    onMount(data: MountData, next: Next): Promise<void>;
-    onInvoke(data: InvokeData, next: Next): Promise<void>;
-    /**
-     * 设置 header
-     * @param key {string} key
-     * @param value {*} value
-     */
-    setHeader(key: string, value: string): Http<TParams, TCookie, TSession>;
-    /**
-     * 设置 Content-Type
-     * @param type {string} 类型
-     * @param charset {string} 编码
-     */
-    setContentType(type: string, charset?: string): Http<TParams, TCookie, TSession>;
-    /**
-     * 设置状态码
-     * @param code {number} 状态码
-     */
-    setStatusCode(code: number): Http<TParams, TCookie, TSession>;
-    /**
-     * 设置 body
-     * @param body {*} 内容
-     */
-    setBody(body: string): Http<TParams, TCookie, TSession>;
-}
-export declare function useHttp<TParams extends Record<string, any> = any, TCookie extends Record<string, string> = any, TSession extends Record<string, string> = any>(config?: HttpConfig<TParams, TCookie, TSession>): Http<TParams, TCookie, TSession> & UseifyPlugin;