@autometa/http 1.2.0 → 1.3.0

package/dist/index.js

@@ -53,133 +53,425 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DerivedHTTPResponse: () => DerivedHTTPResponse,
+  AnySchema: () => AnySchema,
+  AxiosClient: () => AxiosClient,
+  BooleanSchema: () => BooleanSchema,
+  EmptySchema: () => EmptySchema,
   HTTP: () => HTTP,
-  HTTPResponse: () => HTTPResponse
+  HTTPClient: () => HTTPClient,
+  HTTPRequest: () => HTTPRequest,
+  HTTPRequestBuilder: () => HTTPRequestBuilder,
+  HTTPResponse: () => HTTPResponse,
+  HTTPResponseBuilder: () => HTTPResponseBuilder,
+  JSONSchema: () => JSONSchema,
+  NullSchema: () => NullSchema,
+  NumberSchema: () => NumberSchema,
+  StringSchema: () => StringSchema,
+  UndefinedSchema: () => UndefinedSchema,
+  defaultClient: () => defaultClient
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/http.response.ts
-var HTTPResponse = class {
-  static derive(original, data) {
-    const response = new DerivedHTTPResponse();
-    if (typeof data === "function") {
-      const fn = data;
-      response.data = fn(original.data);
-    } else {
-      response.data = data;
-    }
-    response.status = original.status;
-    response.statusText = original.statusText;
-    response.headers = original.headers;
-    response.request = original.request;
-    response.actual = original;
+// src/http-response.ts
+var HTTPResponse = class _HTTPResponse {
+  constructor() {
+    this.headers = {};
+  }
+  static fromRaw(response) {
+    const newResponse = new _HTTPResponse();
+    Object.assign(newResponse, response);
     return response;
   }
+  decompose(transformFn) {
+    const value = getDecompositionValue(this.data, transformFn);
+    return new HTTPResponseBuilder().status(this.status).statusText(this.statusText).headers(this.headers).request(this.request).data(value).build();
+  }
 };
-var DerivedHTTPResponse = class extends HTTPResponse {
+function getDecompositionValue(data, transformFn) {
+  return typeof transformFn === "function" ? transformFn(data) : transformFn;
+}
+var _response;
+var _HTTPResponseBuilder = class _HTTPResponseBuilder {
+  constructor() {
+    __privateAdd(this, _response, new HTTPResponse());
+  }
+  static create() {
+    return new _HTTPResponseBuilder();
+  }
+  derive() {
+    return _HTTPResponseBuilder.create().data(__privateGet(this, _response).data).headers(__privateGet(this, _response).headers).request(__privateGet(this, _response).request).status(__privateGet(this, _response).status).statusText(__privateGet(this, _response).statusText);
+  }
+  status(code) {
+    __privateGet(this, _response).status = code;
+    return this;
+  }
+  statusText(text) {
+    __privateGet(this, _response).statusText = text;
+    return this;
+  }
+  data(data) {
+    __privateGet(this, _response).data = data;
+    return this;
+  }
+  headers(dict) {
+    __privateGet(this, _response).headers = dict;
+    return this;
+  }
+  header(name, value) {
+    __privateGet(this, _response).headers[name] = value;
+    return this;
+  }
+  request(request) {
+    __privateGet(this, _response).request = request;
+    return this;
+  }
+  build() {
+    return __privateGet(this, _response);
+  }
+};
+_response = new WeakMap();
+var HTTPResponseBuilder = _HTTPResponseBuilder;
+
+// src/axios-client.ts
+var import_axios = __toESM(require("axios"), 1);
+
+// src/http-client.ts
+var defaultClient;
+var HTTPClient = class {
+  static Use(client) {
+    if (client) {
+      defaultClient = client;
+    }
+    return function(target) {
+      defaultClient = target;
+    };
+  }
 };
 
+// src/axios-client.ts
+var AxiosClient = class extends HTTPClient {
+  async request(request, options) {
+    const { baseUrl, route, params, headers, method, data } = request;
+    const url = [baseUrl, ...route].join("/");
+    const axiosRequest = {
+      url,
+      params,
+      headers,
+      method,
+      data,
+      validateStatus: function(status) {
+        return status >= 0 && status < 600;
+      },
+      ...options
+    };
+    const response = await (0, import_axios.default)(axiosRequest);
+    return HTTPResponseBuilder.create().status(response.status).statusText(response.statusText).data(response.data).headers(response.headers).request(request).build();
+  }
+};
+AxiosClient = __decorateClass([
+  HTTPClient.Use()
+], AxiosClient);
+
 // src/http.ts
-var import_injection2 = require("@autometa/injection");
+var import_injection = require("@autometa/injection");
+
+// src/default-client-factory.ts
+function defaultClientFactory() {
+  const type = defaultClient;
+  return new type();
+}
 
-// src/http.builder.ts
-var import_errors4 = require("@autometa/errors");
+// src/http-request.ts
 var import_url_join_ts = require("url-join-ts");
+var HTTPRequest = class _HTTPRequest {
+  constructor(config) {
+    this.headers = {};
+    this.params = {};
+    this.route = [];
+    Object.assign(this, config);
+  }
+  /**
+   * Returns the full URL of the request, including the base url,
+   * routes, and query parameters.
+   *
+   * ```ts
+   *  console.log(request.fullUrl())// https://example.com/foo?bar=baz?array=1,2,3
+   * ```
+   *
+   * Note characters may be converted to escape codes. I.e (space => %20) and (comma => %2C)
+   *
+   * N.B this method estimates what the url will be. The actual value
+   * might be different depending on your underlying HTTPClient and
+   * configuration. For example, query parameters might
+   * use different array formats.
+   */
+  fullUrl() {
+    return (0, import_url_join_ts.urlJoinP)(this.baseUrl, this.route, this.params);
+  }
+  /**
+   * Returns a new independent copy of the request.
+   */
+  static derive(original) {
+    const request = new _HTTPRequest();
+    request.headers = { ...original.headers };
+    request.params = { ...original.params };
+    request.baseUrl = original.baseUrl;
+    request.route = [...original.route];
+    request.method = original.method;
+    request.data = original.data;
+    return request;
+  }
+};
+var _request, _dynamicHeaders;
+var _HTTPRequestBuilder = class _HTTPRequestBuilder {
+  constructor(request = () => new HTTPRequest()) {
+    __privateAdd(this, _request, void 0);
+    __privateAdd(this, _dynamicHeaders, /* @__PURE__ */ new Map());
+    if (typeof request === "function") {
+      __privateSet(this, _request, request());
+      return;
+    }
+    __privateSet(this, _request, request);
+  }
+  static create() {
+    return new _HTTPRequestBuilder();
+  }
+  get request() {
+    return __privateGet(this, _request);
+  }
+  resolveDynamicHeaders() {
+    for (const [name, value] of __privateGet(this, _dynamicHeaders)) {
+      try {
+        __privateGet(this, _request).headers[name] = String(value());
+      } catch (e) {
+        const cause = e;
+        const msg = `Failed to resolve dynamic header "${name}": 
+${cause}`;
+        throw new Error(msg);
+      }
+    }
+    return this;
+  }
+  url(url) {
+    __privateGet(this, _request).baseUrl = url;
+    return this;
+  }
+  route(...route) {
+    __privateGet(this, _request).route.push(...route);
+    return this;
+  }
+  param(name, value) {
+    if (Array.isArray(value)) {
+      const asStr = value.map(String);
+      __privateGet(this, _request).params[name] = asStr;
+      return this;
+    }
+    if (!Array.isArray(value) && typeof value === "object") {
+      __privateGet(this, _request).params[name] = value;
+      return this;
+    }
+    __privateGet(this, _request).params[name] = String(value);
+    return this;
+  }
+  params(dict) {
+    Object.assign(__privateGet(this, _request).params, dict);
+    return this;
+  }
+  data(data) {
+    __privateGet(this, _request).data = data;
+    return this;
+  }
+  header(name, value) {
+    if (typeof value === "function") {
+      value = value();
+    }
+    __privateGet(this, _request).headers[name] = String(value);
+    return this;
+  }
+  headers(dict) {
+    Object.assign(__privateGet(this, _request).headers, dict);
+    return this;
+  }
+  get() {
+    return __privateGet(this, _request);
+  }
+  method(method) {
+    __privateGet(this, _request).method = method;
+    return this;
+  }
+  derive() {
+    const request = HTTPRequest.derive(__privateGet(this, _request));
+    return new _HTTPRequestBuilder(request);
+  }
+  build() {
+    return __privateGet(this, _request);
+  }
+};
+_request = new WeakMap();
+_dynamicHeaders = new WeakMap();
+var HTTPRequestBuilder = _HTTPRequestBuilder;
 
 // src/schema.map.ts
-var import_errors = require("@autometa/errors");
-var import_status_codes = require("@autometa/status-codes");
-var _children, _map;
-var SchemaMap = class {
-  constructor() {
-    __privateAdd(this, _children, []);
-    __privateAdd(this, _map, /* @__PURE__ */ new Map());
+var _map;
+var _SchemaMap = class _SchemaMap {
+  constructor(map) {
+    __privateAdd(this, _map, void 0);
+    if (map instanceof _SchemaMap) {
+      __privateSet(this, _map, new Map(__privateGet(map, _map)));
+      return;
+    }
+    __privateSet(this, _map, new Map(map));
   }
-  register(parser, ...args) {
-    args.forEach((arg) => {
-      if (typeof arg === "number") {
-        this.registerSingle(parser, arg);
-      } else {
-        this.registerRange(parser, arg);
-      }
-    });
-    return parser.parse;
+  derive() {
+    return new _SchemaMap(__privateGet(this, _map));
   }
-  registerSingle(parser, ...codes) {
+  registerStatus(parser, ...codes) {
     codes.forEach((code) => {
       if (__privateGet(this, _map).has(code)) {
-        throw new import_errors.AutomationError(
-          `Status code ${code} is already registered with a parser`
-        );
+        const msg = `Status code ${code} is already registered with a parser`;
+        throw new Error(msg);
       }
-      assertIsStatusCode(code);
       __privateGet(this, _map).set(code, parser);
     });
   }
-  including(map) {
-    __privateGet(this, _children).includes(map);
-    return this;
-  }
-  registerRange(parser, ...range) {
-    range.forEach(({ from, to }) => {
-      assertIsStatusCode(from);
-      assertIsStatusCode(to);
-      for (let i = from; i <= to; i++) {
-        if (!IsStatusCode(i)) {
-          continue;
-        }
-        if (__privateGet(this, _map).has(i)) {
-          throw new import_errors.AutomationError(
-            `Status code ${i} is already registered with a parser`
-          );
-        }
-        __privateGet(this, _map).set(i, parser);
+  registerRange(parser, from, to) {
+    for (let i = from; i <= to; i++) {
+      if (__privateGet(this, _map).has(i)) {
+        throw new Error(`Status code ${i} is already registered with a parser`);
       }
-    });
+      __privateGet(this, _map).set(i, parser);
+    }
   }
-  get(status) {
-    assertIsStatusCode(status);
-    const local = __privateGet(this, _map).get(status);
-    if (local) {
-      return local;
+  validate(status, data, requireSchema) {
+    const parser = this.getParser(status, requireSchema);
+    if ("parse" in parser) {
+      return parser.parse(data);
     }
-    const nested = __privateGet(this, _children).find((it) => __privateGet(it, _map).has(status));
-    return nested?.get(status);
-  }
-  validate(status, response, strict) {
-    const parser = this.get(status);
-    if (!parser) {
-      if (!strict) {
-        return response;
-      }
-      throw new import_errors.AutomationError(
-        `No schema parser registered for status code ${status} and 'requireSchema' is set to true`
-      );
+    if ("validate" in parser) {
+      return parser.validate(data);
+    }
+    try {
+      return parser(data);
+    } catch (e) {
+      const msg = `Failed to schema parse response data for status code ${status} with data:
+      
+${JSON.stringify(data, null, 2)}}`;
+      throw new Error(msg);
+    }
+  }
+  getParser(status, requireSchema) {
+    const parser = __privateGet(this, _map).get(status);
+    if (!parser && requireSchema) {
+      const msg = `No parser registered for status code ${status} but 'requireSchema' is true`;
+      throw new Error(msg);
+    }
+    if (parser) {
+      return parser;
     }
-    return parser.parse(response);
+    return (data) => data;
+  }
+  toObject() {
+    return Object.fromEntries(__privateGet(this, _map));
   }
 };
-_children = new WeakMap();
 _map = new WeakMap();
-function assertIsStatusCode(value) {
-  const result = Object.values(import_status_codes.StatusCodes).map((it) => it.status).includes(value);
-  if (!result) {
-    throw new import_errors.AutomationError(
-      `Expected status code ${value} to be a valid status code, but it is not a known HTTP codeF`
-    );
+var SchemaMap = _SchemaMap;
+
+// src/request-meta.config.ts
+var MetaConfig = class {
+  constructor() {
+    this.onSend = [];
+    this.onReceive = [];
   }
-}
-function IsStatusCode(value) {
-  return Object.values(import_status_codes.StatusCodes).map((it) => it.status).includes(value);
-}
+};
+var _schemaMap, _requireSchema, _allowPlainText, _onBeforeSend, _onAfterSend, _throwOnServerError, _setOnSend, setOnSend_fn, _setOnReceive, setOnReceive_fn;
+var _MetaConfigBuilder = class _MetaConfigBuilder {
+  constructor() {
+    __privateAdd(this, _setOnSend);
+    __privateAdd(this, _setOnReceive);
+    __privateAdd(this, _schemaMap, new SchemaMap());
+    __privateAdd(this, _requireSchema, false);
+    __privateAdd(this, _allowPlainText, false);
+    __privateAdd(this, _onBeforeSend, []);
+    __privateAdd(this, _onAfterSend, []);
+    __privateAdd(this, _throwOnServerError, false);
+  }
+  schemaMap(map) {
+    __privateSet(this, _schemaMap, map);
+    return this;
+  }
+  schema(parser, ...args) {
+    args.forEach((arg) => {
+      if (typeof arg === "number") {
+        __privateGet(this, _schemaMap).registerStatus(parser, arg);
+      } else {
+        __privateGet(this, _schemaMap).registerRange(parser, arg.from, arg.to);
+      }
+    });
+    return this;
+  }
+  requireSchema(value) {
+    __privateSet(this, _requireSchema, value);
+    return this;
+  }
+  allowPlainText(value) {
+    __privateSet(this, _allowPlainText, value);
+    return this;
+  }
+  onBeforeSend(description, hook) {
+    __privateGet(this, _onBeforeSend).push([description, hook]);
+    return this;
+  }
+  throwOnServerError(value) {
+    __privateSet(this, _throwOnServerError, value);
+    return this;
+  }
+  onReceiveResponse(description, hook) {
+    __privateGet(this, _onAfterSend).push([description, hook]);
+    return this;
+  }
+  build() {
+    const config = new MetaConfig();
+    config.schemas = __privateGet(this, _schemaMap).derive();
+    config.requireSchema = __privateGet(this, _requireSchema);
+    config.allowPlainText = __privateGet(this, _allowPlainText);
+    config.onSend = __privateGet(this, _onBeforeSend);
+    config.onReceive = __privateGet(this, _onAfterSend);
+    return config;
+  }
+  derive() {
+    var _a, _b;
+    return __privateMethod(_b = __privateMethod(_a = new _MetaConfigBuilder().schemaMap(__privateGet(this, _schemaMap).derive()).requireSchema(__privateGet(this, _requireSchema)).allowPlainText(__privateGet(this, _allowPlainText)).throwOnServerError(__privateGet(this, _throwOnServerError)), _setOnSend, setOnSend_fn).call(_a, __privateGet(this, _onBeforeSend)), _setOnReceive, setOnReceive_fn).call(_b, __privateGet(this, _onAfterSend));
+  }
+};
+_schemaMap = new WeakMap();
+_requireSchema = new WeakMap();
+_allowPlainText = new WeakMap();
+_onBeforeSend = new WeakMap();
+_onAfterSend = new WeakMap();
+_throwOnServerError = new WeakMap();
+_setOnSend = new WeakSet();
+setOnSend_fn = function(hooks) {
+  __privateSet(this, _onBeforeSend, hooks);
+  return this;
+};
+_setOnReceive = new WeakSet();
+setOnReceive_fn = function(hooks) {
+  __privateSet(this, _onAfterSend, hooks);
+  return this;
+};
+var MetaConfigBuilder = _MetaConfigBuilder;
 
 // src/transform-response.ts
-var import_errors2 = require("@autometa/errors");
+var import_errors = require("@autometa/errors");
 var import_assert_is_json = __toESM(require("@stdlib/assert-is-json"), 1);
 var import_cli_highlight = require("cli-highlight");
 function transformResponse(allowPlainText, data) {
@@ -195,12 +487,15 @@ function transformResponse(allowPlainText, data) {
   if ((0, import_assert_is_json.default)(data)) {
     return JSON.parse(data);
   }
-  if (["true", "false"].includes(data)) {
+  if (typeof data === "string" && ["true", "false"].includes(data)) {
     return JSON.parse(data);
   }
-  if (/^\d*\.?\d+$/.test(data)) {
+  if (typeof data === "string" && /^\d*\.?\d+$/.test(data)) {
     return JSON.parse(data);
   }
+  if (typeof data === "object") {
+    return data;
+  }
   if (allowPlainText) {
     return data;
   }
@@ -208,394 +503,606 @@ function transformResponse(allowPlainText, data) {
   const message = [
     `Could not parse a response as json, and this request was not configured to allow plain text responses.`,
     `To allow plain text responses, use the 'allowPlainText' method on the HTTP client.`,
-    " ",
+    "",
     response
   ];
-  throw new import_errors2.AutomationError(message.join("\n"));
+  throw new import_errors.AutomationError(message.join("\n"));
 }
 
-// src/axios-executor.ts
-var import_axios = __toESM(require("axios"), 1);
-var import_class_transformer = require("class-transformer");
-var import_errors3 = require("@autometa/errors");
-var _result;
-var AxiosExecutor = class {
-  constructor(options, schemaMap, requestState, requireSchema) {
-    this.options = options;
-    this.schemaMap = schemaMap;
-    this.requestState = requestState;
-    this.requireSchema = requireSchema;
-    __privateAdd(this, _result, {});
-  }
-  get error() {
-    return __privateGet(this, _result).error;
-  }
-  get requestSucceeded() {
-    return __privateGet(this, _result).response !== void 0;
-  }
-  get validationFailed() {
-    return __privateGet(this, _result).validated === void 0;
-  }
-  async tryRequest() {
-    try {
-      __privateGet(this, _result).response = await (0, import_axios.default)(this.options);
-      this.tryValidate();
-    } catch (e) {
-      if (__privateGet(this, _result).error) {
-        return;
-      }
-      const { method, fullUrl, data, headers } = this.requestState;
-      const body = JSON.stringify(data, null, 2);
-      const headersString = JSON.stringify(headers, null, 2);
-      const message = `Failed to send request to ${method}:${fullUrl}.
-headers:
-${headersString}
-       
-body: 
-${body}`;
-      __privateGet(this, _result).error = new import_errors3.AutomationError(message, { cause: e });
-    }
+// src/http.ts
+var import_errors2 = require("@autometa/errors");
+var _request2, _metaConfig, _makeRequest, makeRequest_fn, _validateResponse, validateResponse_fn;
+var HTTP = class {
+  constructor(client = defaultClientFactory(), builder = new HTTPRequestBuilder(), metaConfig = new MetaConfigBuilder()) {
+    this.client = client;
+    __privateAdd(this, _makeRequest);
+    __privateAdd(this, _validateResponse);
+    __privateAdd(this, _request2, void 0);
+    __privateAdd(this, _metaConfig, void 0);
+    __privateSet(this, _request2, builder.derive());
+    __privateSet(this, _metaConfig, metaConfig.derive());
+  }
+  static create(client = new AxiosClient(), builder = new HTTPRequestBuilder(), metaConfig = new MetaConfigBuilder()) {
+    return new HTTP(client, builder, metaConfig);
+  }
+  /**
+   * Sets the base url of the request for this client, such as
+   * `https://api.example.com`, and could include always-used routes like
+   * the api version, such as `/v1` or `/api/v1` at the end.
+   *
+   * ```ts
+   *
+   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
+   * export abstract class BaseClient {
+   *   constructor(protected readonly http: HTTP) {
+   *      this.http.url("https://api.example.com");
+   *   }
+   * }
+   * ```
+   * @param url
+   * @returns
+   */
+  url(url) {
+    __privateGet(this, _request2).url(url);
+    return this;
   }
-  async tryValidate() {
-    const { status, data } = __privateGet(this, _result).response;
-    const { method, fullUrl } = this.requestState;
-    try {
-      __privateGet(this, _result).validated = this.schemaMap.validate(
-        status,
-        data,
-        this.requireSchema
-      );
-    } catch (e) {
-      const error = e;
-      const message = `Failed to validate response from ${method}:${fullUrl}.
-      
-Provided body was:
-${JSON.stringify(data, null, 2)}`;
-      __privateGet(this, _result).error = new import_errors3.AutomationError(message, { cause: error });
-    }
+  /**
+   * If set to true, all requests derived from this client will require a schema be defined
+   * matching any response status code. If set to false, a schema will still be used for validation
+   * if defined, or the unadulterated original body will be returned if no schema matches.
+   *
+   * @param required Whether or not a schema is required for all responses.
+   * @returns This instance of HTTP.
+   */
+  requireSchema(required) {
+    __privateGet(this, _metaConfig).requireSchema(required);
+    return this;
   }
-  getValidatedResponse() {
-    const { status, statusText, headers } = __privateGet(this, _result).response;
-    const { validated: data } = __privateGet(this, _result);
-    const { fullUrl: url, method } = this.requestState;
-    return (0, import_class_transformer.plainToInstance)(HTTPResponse, {
-      status,
-      statusText,
-      headers,
-      data,
-      request: {
-        url,
-        method
-      }
-    });
+  /**
+   * If set to true, all requests derived from this client will allow plain text
+   * responses. If set to false, plain text responses will throw an serialization error.
+   *
+   * Useful when an endpoint returns a HTML or plain text response. If the plain text
+   * is the value of `true` or `false`, or a number, it will be parsed into the
+   * appropriate type.
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP.
+   *
+   * @param allow Whether or not plain text responses are allowed.
+   * @returns This instance of HTTP.
+   */
+  sharedAllowPlainText(allow) {
+    __privateGet(this, _metaConfig).allowPlainText(allow);
+    return this;
   }
-  getResponse() {
-    const { status, statusText, headers, data } = __privateGet(this, _result).response;
-    const { fullUrl: url, method } = this.requestState;
-    return (0, import_class_transformer.plainToInstance)(
-      HTTPResponse,
-      {
-        status,
-        statusText,
-        headers,
-        data,
-        request: {
-          url,
-          method
-        }
-      },
-      { excludeExtraneousValues: true }
+  /**
+   * If set to true, all requests derived from this client will allow plain text
+   * responses. If set to false, plain text responses will throw an serialization error.
+   *
+   * Useful when an endpoint returns a HTML or plain text response. If the plain text
+   * is the value of `true` or `false`, or a number, it will be parsed into the
+   * appropriate type.
+   *
+   * This method is a request chain method, and will return a new instance of HTTP.
+   *
+   * @param allow Whether or not plain text responses are allowed.
+   * @returns A new child instance of HTTP derived from this one.
+   */
+  allowPlainText(allow) {
+    return HTTP.create(
+      this.client,
+      __privateGet(this, _request2).derive(),
+      __privateGet(this, _metaConfig).derive().allowPlainText(allow)
     );
   }
-};
-_result = new WeakMap();
-
-// src/http.builder.ts
-var import_injection = require("@autometa/injection");
-var _headers, _params, _url, _route, _method, _schemaMap, _responseType, _data, _requireSchema, _allowPlainText, _onBeforeSend, _onAfterSend;
-var HTTPRequestBuilder = class {
-  constructor(map) {
-    __privateAdd(this, _headers, /* @__PURE__ */ new Map());
-    __privateAdd(this, _params, /* @__PURE__ */ new Map());
-    __privateAdd(this, _url, void 0);
-    __privateAdd(this, _route, []);
-    __privateAdd(this, _method, void 0);
-    __privateAdd(this, _schemaMap, new SchemaMap());
-    __privateAdd(this, _responseType, "json");
-    __privateAdd(this, _data, void 0);
-    __privateAdd(this, _requireSchema, false);
-    __privateAdd(this, _allowPlainText, false);
-    __privateAdd(this, _onBeforeSend, []);
-    __privateAdd(this, _onAfterSend, []);
-    __privateSet(this, _schemaMap, new SchemaMap().including(map));
-  }
-  requireSchema(value) {
-    __privateSet(this, _requireSchema, value);
+  /**
+   * Attaches a route to the request, such as `/product` or `/user`. Subsequent calls
+   * to this method will append the route to the existing route, such as `/product/1`.
+   *
+   * Numbers will be converted to strings automatically. Routes can be defined one
+   * at a time or as a spread argument.
+   *
+   * ```ts
+   * constructor(http: HTTP) {
+   *   super(http);
+   *   this.http.sharedRoute("user", id).get();
+   * }
+   *
+   * // or
+   *
+   * constructor(http: HTTP) {
+   *   super(http);
+   *   this.http
+   *       .sharedRoute("user")
+   *       .sharedRoute(id)
+   *       .get();
+   * }
+   * ```
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the routes defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * @param route A route or spread list of routes to append to the request.
+   * @returns This instance of HTTP.
+   */
+  sharedRoute(...route) {
+    __privateGet(this, _request2).route(...route.map((r) => r.toString()));
     return this;
   }
-  get currentState() {
-    const fullUrl = this.currentUrl;
-    return {
-      headers: Object.fromEntries(__privateGet(this, _headers)),
-      params: Object.fromEntries(__privateGet(this, _params)),
-      url: __privateGet(this, _url),
-      route: __privateGet(this, _route),
-      responseType: __privateGet(this, _responseType),
-      data: __privateGet(this, _data),
-      method: __privateGet(this, _method),
-      fullUrl
-    };
-  }
-  get currentUrl() {
-    const params = Object.fromEntries(__privateGet(this, _params));
-    return (0, import_url_join_ts.urlJoinP)(__privateGet(this, _url), __privateGet(this, _route), params);
-  }
-  url(url) {
-    __privateSet(this, _url, url);
-    return this;
+  /**
+   * Attaches a route to the request, such as `/product` or `/user`. Subsequent calls
+   * to this method will append the route to the existing route, such as `/product/1`.
+   *
+   * Numbers will be converted to strings automatically. Routes can be defined one
+   * at a time or as a spread argument.
+   *
+   * ```ts
+   * getUser(id: number) {
+   *   return this.http.route("user", id).get();
+   * }
+   *
+   * // or
+   *
+   * getUser(id: number) {
+   *  return this.http
+   *            .route("user")
+   *            .route(id)
+   *            .get();
+   * }
+   * ```
+   *
+   * This method is a request chain method, and will return a new instance of HTTP, inheriting
+   * any routes previously defined and appending the new route. Useful to configure
+   * in class methods as part of finalizing a request.
+   *
+   * @param route A route or spread list of routes to append to the request.
+   * @returns A new child instance of HTTP derived from this one.
+   */
+  route(...route) {
+    const mapped = route.map((r) => String(r));
+    return HTTP.create(this.client, __privateGet(this, _request2).derive().route(...mapped));
   }
-  allowPlainText(value) {
-    __privateSet(this, _allowPlainText, value);
+  sharedSchema(parser, ...args) {
+    __privateGet(this, _metaConfig).schema(parser, ...args);
     return this;
   }
   schema(parser, ...args) {
-    __privateGet(this, _schemaMap).register(parser, ...args);
-    return this;
-  }
-  onBeforeSend(...hook) {
-    __privateGet(this, _onBeforeSend).push(...hook);
-    return this;
+    return HTTP.create(
+      this.client,
+      __privateGet(this, _request2).derive(),
+      __privateGet(this, _metaConfig).derive().schema(parser, ...args)
+    );
   }
-  onReceivedResponse(...hook) {
-    __privateGet(this, _onAfterSend).push(...hook);
+  sharedParam(name, value) {
+    __privateGet(this, _request2).param(name, value);
     return this;
   }
-  route(...route) {
-    __privateGet(this, _route).push(...route.map((it) => `${it}`));
+  /**
+   * `onSend` is a pre-request hook which will be executed in order of definition
+   * immediately before the request is sent. This hook can be used to analyze or
+   * log the request state.
+   *
+   * ```ts
+   *
+   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
+   * export class UserController extends BaseController {
+   *  constructor(private readonly http: HTTP) {
+   *     super(http);
+   *     this.http
+   *         .sharedRoute("user")
+   *         .sharedOnSend("log request",
+   *                       (request) => console.log(JSON.stringify(request, null, 2))
+   *     );
+   *  }
+   * }
+   * ```
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the onSend hooks defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * @param description A description of the hook, used for debugging.
+   * @param hook The hook to execute.
+   * @returns This instance of HTTP.
+   */
+  sharedOnSend(description, hook) {
+    __privateGet(this, _metaConfig).onBeforeSend(description, hook);
     return this;
   }
-  header(name, value) {
-    const val = Array.isArray(value) ? value.join(",") : `${value}`;
-    __privateGet(this, _headers).set(name, val);
+  /**
+   * `onReceive` is a post-request hook which will be executed in order of definition
+   * immediately after the response is received. This hook can be used to analyze or
+   * log the response state.
+   *
+   * ```ts
+   *
+   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
+   * export class UserController extends BaseController {
+   *  constructor(private readonly http: HTTP) {
+   *     super(http);
+   *     this.http
+   *         .sharedRoute("user")
+   *         .sharedOnReceive("log response",
+   *                          (response) => console.log(JSON.stringify(response, null, 2))
+   *     );
+   *  }
+   * }
+   * ```
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the onReceive hooks defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * @param description A description of the hook, used for debugging.
+   * @param hook The hook to execute.
+   * @returns This instance of HTTP.
+   */
+  sharedOnReceive(description, hook) {
+    __privateGet(this, _metaConfig).onReceiveResponse(description, hook);
     return this;
   }
-  headers(dict) {
-    Object.entries(dict).forEach(
-      ([name, value]) => __privateGet(this, _headers).set(name, value)
-    );
+  /**
+   * Attaches a query string parameter object to the request. Query string
+   * parameters are key-value pairs which are appended to the request url, such as
+   * `https://api.example.com?name=John&age=30`.
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the query string parameters defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * ```ts
+   * constructor(http: HTTP) {
+   *    super(http);
+   *    this.http
+   *        .sharedParams({ 'is-test': "true" })
+   * ```
+   * @param name The name of the query string parameter.
+   * @param value The value of the query string parameter.
+   * @returns This instance of HTTP.
+   */
+  sharedParams(dict) {
+    __privateGet(this, _request2).params(dict);
     return this;
   }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   param(name, value) {
-    __privateGet(this, _params).set(name, value);
-    return this;
-  }
+    return HTTP.create(this.client, __privateGet(this, _request2).derive().param(name, value));
+  }
+  /**
+   * Attaches a query string parameter object to the request. Query string
+   * parameters are key-value pairs which are appended to the request url, such as
+   * `https://api.example.com?name=John&age=30`.
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the query string parameters defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * ```ts
+   * getUser(id: number) {
+   *   return this.http
+   *             .route(id)
+   *             .param({ name: "John", age: "30" })
+   *
+   * @param name The name of the query string parameter.
+   * @param value The value of the query string parameter.
+   * @returns This instance of HTTP.
+   */
   params(dict) {
-    Object.entries(dict).forEach(([name, value]) => this.param(name, value));
+    __privateGet(this, _request2).params(dict);
+    return HTTP.create(this.client, __privateGet(this, _request2).derive().params(dict));
+  }
+  /**
+   * Attaches a shared data payload to this client. The data payload is the body of the request,
+   * and can be any type. If the data payload is an object, it will be serialized to JSON.
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the data payload defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * @param data The data payload to attach to the request.
+   * @returns This instance of HTTP.
+   */
+  sharedData(data) {
+    __privateGet(this, _request2).data(data);
     return this;
   }
-  data(data) {
-    __privateSet(this, _data, data);
+  /**
+   * Attaches a shared header to this client. Headers are string:string key-value pairs which are
+   * sent with the request, such as `Content-Type: application/json`.
+   *
+   * Numbers, Booleans and Null will be converted to string values automatically.
+   *
+   * A Factory function can also be provided to generate the header value at the time of request.
+   *
+   * This method is a shared chain method, and will return the same instance of HTTP. All
+   * child clients will inherit the header defined by this method. Useful to configure
+   * in the constructor body.
+   *
+   * @param name The name of the header.
+   * @param value The value of the header.
+   */
+  sharedHeader(name, value) {
+    __privateGet(this, _request2).header(name, value);
     return this;
   }
-  async post() {
-    return this._request("POST");
-  }
-  async get() {
-    return this._request("GET");
-  }
-  async delete() {
-    return this._request("DELETE");
-  }
-  async put() {
-    return this._request("PUT");
-  }
-  async patch() {
-    return this._request("PATCH");
+  header(name, value) {
+    return HTTP.create(this.client, __privateGet(this, _request2).derive().header(name, value));
+  }
+  /**
+   * Attaches a data payload to this request. The data payload is the body of the request,
+   * and can be any type. If the data payload is an object, it will be serialized to JSON.
+   *
+   * This method is a request chain method, and will return a new instance of HTTP, inheriting
+   * any data payload previously defined and appending the new payload. Useful to configure
+   * in class methods as part of finalizing a request.
+   *
+   * @param data The data payload to attach to the request.
+   * @returns A new child instance of HTTP derived from this one.
+   */
+  data(data) {
+    __privateGet(this, _request2).data(data);
+    return HTTP.create(this.client, __privateGet(this, _request2).derive().data(data));
+  }
+  /**
+   * `onSend` is a pre-request hook which will be executed in order of definition
+   * immediately before the request is sent. This hook can be used to modify the request,
+   * or to log the state of a request before final send-off.
+   *
+   * ```ts
+   *
+   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
+   * export class UserController extends BaseController {
+   *  constructor(private readonly http: HTTP) {
+   *   super(http);
+   *  }
+   *
+   *  getUser(id: number) {
+   *   return this.http
+   *              .route(id)
+   *              .onSend("log request",
+   *                (request) => console.log(JSON.stringify(request, null, 2)
+   *              )
+   *              .get();
+   * }
+   * ```
+   *
+   * This method is a request chain method, and will return a new instance of HTTP, inheriting
+   * any onSend hooks previously defined and appending the new hook. Useful to configure
+   * in class methods as part of finalizing a request.
+   *
+   * @param description A description of the hook, used for debugging.
+   * @param hook The hook to execute.
+   * @returns A new child instance of HTTP derived from this one.
+   */
+  onSend(description, hook) {
+    return HTTP.create(
+      this.client,
+      __privateGet(this, _request2).derive(),
+      __privateGet(this, _metaConfig).derive().onBeforeSend(description, hook)
+    );
   }
-  async _request(method) {
-    __privateSet(this, _method, method);
-    const options = this.constructOptions(method);
-    this.tryRunBeforeHooks();
-    const executor = new AxiosExecutor(
-      options,
-      __privateGet(this, _schemaMap),
-      this.currentState,
-      __privateGet(this, _requireSchema)
+  /**
+   * `onReceive` is a post-request hook which will be executed in order of definition
+   * immediately after the response is received. This hook can be used to modify the response,
+   * or to log the state of a response after it is received.
+   *
+   * ```ts
+   *
+   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
+   * export class UserController extends BaseController {
+   *  constructor(private readonly http: HTTP) {
+   *   super(http);
+   *  }
+   *
+   *  getUser(id: number) {
+   *   return this.http
+   *              .route(id)
+   *              .onReceive("log response",
+   *                (response) => console.log(JSON.stringify(response, null, 2)
+   *              )
+   *              .get();
+   * }
+   * ```
+   *
+   * This method is a request chain method, and will return a new instance of HTTP, inheriting
+   * any onReceive hooks previously defined and appending the new hook. Useful to configure
+   * in class methods as part of finalizing a request.
+   *
+   * @param description A description of the hook, used for debugging.
+   * @param hook The hook to execute.
+   * @returns A new child instance of HTTP derived from this one.
+   */
+  onReceive(description, hook) {
+    return HTTP.create(
+      this.client,
+      __privateGet(this, _request2).derive(),
+      __privateGet(this, _metaConfig).derive().onReceiveResponse(description, hook)
     );
-    await executor.tryRequest();
-    if (executor.requestSucceeded && !executor.validationFailed) {
-      const response = executor.getValidatedResponse();
-      this.tryRunAfterHooks(response);
-      return response;
-    }
-    if (executor.requestSucceeded) {
-      const response = executor.getResponse();
-      this.tryRunAfterHooks(response);
-    }
-    throw executor.error;
-  }
-  constructOptions(method) {
-    const url = this.currentUrl;
-    const headers = __privateGet(this, _headers) && Object.fromEntries(__privateGet(this, _headers));
-    const responseType = __privateGet(this, _responseType);
-    const data = __privateGet(this, _data);
-    return {
-      method,
-      url,
-      headers,
-      data,
-      responseType,
-      validateStatus: function(status) {
-        return status >= 100 && status < 500;
-      },
-      transformResponse: transformResponse.bind(null, __privateGet(this, _allowPlainText))
-    };
   }
-  tryRunBeforeHooks() {
-    let index = 0;
-    try {
-      for (const hook of __privateGet(this, _onBeforeSend)) {
-        hook(this.currentState);
-        index++;
+  /**
+   * Executes the current request state as a GET request.
+   *
+   * @param options Additional options to pass to the underlying http client, such
+   *                as e.g Axios configuration values.
+   * @returns A promise which resolves to the response.
+   */
+  get(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("GET"), options);
+  }
+  /**
+   * Executes the current request state as a POST request.
+   *
+   * @param data The data payload to attach to the request.
+   * @param options Additional options to pass to the underlying http client, such
+   *                as e.g Axios configuration values.
+   * @returns A promise which resolves to the response.
+   */
+  post(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("POST"), options);
+  }
+  /**
+   * Executes the current request state as a DELETE request.
+   *
+   * @param options Additional options to pass to the underlying http client, such
+   *                as e.g Axios configuration values.
+   * @returns A promise which resolves to the response.
+   *               as e.g Axios configuration values.
+   */
+  delete(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("DELETE"), options);
+  }
+  /**
+   * Executes the current request state as a PUT request.
+   *
+   * @param options Additional options to pass to the underlying http client, such
+   *                as e.g Axios configuration values.
+   * @returns A promise which resolves to the response.
+   */
+  put(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("PUT"), options);
+  }
+  /**
+   * Executes the current request state as a PATCH request.
+   *
+   * @param options Additional options to pass to the underlying http client, such
+   *                as e.g Axios configuration values.
+   * @returns A promise which resolves to the response.
+   */
+  patch(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("PATCH"), options);
+  }
+  head(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("HEAD"), options);
+  }
+  options(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("OPTIONS"), options);
+  }
+  trace(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("TRACE"), options);
+  }
+  connect(options) {
+    return __privateMethod(this, _makeRequest, makeRequest_fn).call(this, __privateGet(this, _request2).derive().method("CONNECT"), options);
+  }
+  async runOnSendHooks(meta, request) {
+    for (const [description, hook] of meta.onSend) {
+      try {
+        await hook(request);
+      } catch (e) {
+        const cause = e;
+        const msg = `An error occurred while sending a request in hook: '${description}'`;
+        throw new import_errors2.AutomationError(msg, { cause });
       }
-    } catch (e) {
-      const error = e;
-      const message = `HTTP Client 'onBeforeRequest' experienced an error at listener count ${index}`;
-      throw new import_errors4.AutomationError(message, { cause: error });
     }
   }
-  tryRunAfterHooks(response) {
-    let index = 0;
-    try {
-      for (const hook of __privateGet(this, _onAfterSend)) {
-        hook(response);
-        index++;
+  async runOnReceiveHooks(meta, response) {
+    for (const [description, hook] of meta.onReceive) {
+      try {
+        await hook(response);
+      } catch (e) {
+        const cause = e;
+        const msg = `An error occurred while receiving a response in hook: '${description}'`;
+        throw new import_errors2.AutomationError(msg, { cause });
       }
-    } catch (e) {
-      const error = e;
-      const message = `HTTP Client 'onRequestReceived' experienced an error at listener count ${index}`;
-      throw new import_errors4.AutomationError(message, { cause: error });
     }
   }
 };
-_headers = new WeakMap();
-_params = new WeakMap();
-_url = new WeakMap();
-_route = new WeakMap();
-_method = new WeakMap();
-_schemaMap = new WeakMap();
-_responseType = new WeakMap();
-_data = new WeakMap();
-_requireSchema = new WeakMap();
-_allowPlainText = new WeakMap();
-_onBeforeSend = new WeakMap();
-_onAfterSend = new WeakMap();
-HTTPRequestBuilder = __decorateClass([
+_request2 = new WeakMap();
+_metaConfig = new WeakMap();
+_makeRequest = new WeakSet();
+makeRequest_fn = async function(builder, options) {
+  const request = builder.resolveDynamicHeaders().build();
+  const meta = __privateGet(this, _metaConfig).derive().build();
+  await this.runOnSendHooks(meta, request);
+  const result = await this.client.request(request, options);
+  result.data = transformResponse(meta.allowPlainText, result.data);
+  await this.runOnReceiveHooks(meta, result);
+  const validated = __privateMethod(this, _validateResponse, validateResponse_fn).call(this, result, meta);
+  return validated;
+};
+_validateResponse = new WeakSet();
+validateResponse_fn = function(response, meta) {
+  const { status, data } = response;
+  const validated = meta.schemas.validate(
+    status,
+    data,
+    meta.requireSchema
+  );
+  response.data = validated;
+  return response;
+};
+HTTP = __decorateClass([
   (0, import_injection.Fixture)(import_injection.INJECTION_SCOPE.TRANSIENT)
-], HTTPRequestBuilder);
+], HTTP);
 
-// src/http.ts
-var _url2, _route2, _headers2, _requireSchema2, _schemaMap2, _onBeforeSend2, _onAfterSend2, _allowPlainText2;
-var HTTP = class {
-  constructor() {
-    __privateAdd(this, _url2, void 0);
-    __privateAdd(this, _route2, []);
-    __privateAdd(this, _headers2, /* @__PURE__ */ new Map());
-    __privateAdd(this, _requireSchema2, false);
-    __privateAdd(this, _schemaMap2, new SchemaMap());
-    __privateAdd(this, _onBeforeSend2, []);
-    __privateAdd(this, _onAfterSend2, []);
-    __privateAdd(this, _allowPlainText2, false);
-  }
-  allowPlainText(value) {
-    __privateSet(this, _allowPlainText2, value);
-    return this;
-  }
-  requireSchema(value) {
-    __privateSet(this, _requireSchema2, value);
-    return this;
-  }
-  url(url) {
-    __privateSet(this, _url2, url);
-    return this;
-  }
-  sharedOnBeforeSend(hook) {
-    __privateGet(this, _onBeforeSend2).push(hook);
-    return this;
-  }
-  sharedOnReceiveResponse(hook) {
-    __privateGet(this, _onAfterSend2).push(hook);
-    return this;
-  }
-  onBeforeSend(hook) {
-    return this.builder().onBeforeSend(hook);
-  }
-  onReceiveResponse(hook) {
-    return this.builder().onReceivedResponse(hook);
-  }
-  sharedSchema(parser, ...args) {
-    __privateGet(this, _schemaMap2).register(parser, ...args);
-    return this;
-  }
-  schema(parser, ...args) {
-    return this.builder().schema(parser, ...args);
-  }
-  sharedRoute(...route) {
-    __privateGet(this, _route2).push(...route);
-    return this;
-  }
-  param(name, value) {
-    return this.builder().param(name, value);
-  }
-  params(dict) {
-    return this.builder().params(dict);
-  }
-  data(data) {
-    return this.builder().data(data);
+// src/default-schema.ts
+var import_assert_is_json2 = __toESM(require("@stdlib/assert-is-json"), 1);
+function AnySchema(data) {
+  return data;
+}
+function EmptySchema(data) {
+  if (data !== null && data !== void 0 && data !== "null") {
+    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
   }
-  sharedHeader(name, value) {
-    __privateGet(this, _headers2).set(name, value);
-    return this;
+  return data === "null" ? null : data;
+}
+function NullSchema(data) {
+  if (data !== null && data !== "null") {
+    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
   }
-  route(...route) {
-    return this.builder().route(...route);
+  return null;
+}
+function UndefinedSchema(data) {
+  if (data !== void 0) {
+    throw new Error(`Expected undefined but got <${typeof data}> for ${data}`);
   }
-  header(name, value) {
-    return this.builder().header(name, value);
+  return void 0;
+}
+function BooleanSchema(data) {
+  if (!(typeof data === "boolean") && ["true", "false"].includes(String(data)) === false) {
+    throw new Error(`Expected boolean but got <${typeof data}> for ${data}`);
   }
-  headers(dict) {
-    return this.builder().headers(dict);
+  return JSON.parse(data);
+}
+function NumberSchema(data) {
+  if (!(typeof data === "number") && /^\d*\.?\d+$/.test(String(data)) === false) {
+    throw new Error(`Expected number but got <${typeof data}> for ${data}`);
   }
-  get() {
-    return this.builder().get();
+  return JSON.parse(data);
+}
+function StringSchema(data) {
+  if (typeof data !== "string") {
+    throw new Error(`Expected string but got <${typeof data}> for ${data}`);
   }
-  builder() {
-    const headers = this.convertFactoriesToString();
-    return new HTTPRequestBuilder(__privateGet(this, _schemaMap2)).url(__privateGet(this, _url2)).route(...__privateGet(this, _route2)).allowPlainText(__privateGet(this, _allowPlainText2)).headers(headers).requireSchema(__privateGet(this, _requireSchema2)).onBeforeSend(...__privateGet(this, _onBeforeSend2)).onReceivedResponse(...__privateGet(this, _onAfterSend2));
+  return data;
+}
+function JSONSchema(data) {
+  if (typeof data === "object") {
+    return data;
   }
-  convertFactoriesToString() {
-    const dict = {};
-    for (const [key, value] of __privateGet(this, _headers2).entries()) {
-      dict[key] = typeof value === "string" ? value : value();
-    }
-    return dict;
+  if (!(0, import_assert_is_json2.default)(data)) {
+    throw new Error(`Expected JSON but got <${typeof data}> for ${data}`);
   }
-};
-_url2 = new WeakMap();
-_route2 = new WeakMap();
-_headers2 = new WeakMap();
-_requireSchema2 = new WeakMap();
-_schemaMap2 = new WeakMap();
-_onBeforeSend2 = new WeakMap();
-_onAfterSend2 = new WeakMap();
-_allowPlainText2 = new WeakMap();
-HTTP = __decorateClass([
-  (0, import_injection2.Fixture)(import_injection2.INJECTION_SCOPE.TRANSIENT)
-], HTTP);
+  const result = JSON.parse(data);
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DerivedHTTPResponse,
+  AnySchema,
+  AxiosClient,
+  BooleanSchema,
+  EmptySchema,
   HTTP,
-  HTTPResponse
+  HTTPClient,
+  HTTPRequest,
+  HTTPRequestBuilder,
+  HTTPResponse,
+  HTTPResponseBuilder,
+  JSONSchema,
+  NullSchema,
+  NumberSchema,
+  StringSchema,
+  UndefinedSchema,
+  defaultClient
 });
 //# sourceMappingURL=index.js.map