@autometa/http 1.4.20 → 2.0.0-rc.0

package/src/http.ts

@@ -1,907 +0,0 @@
-import { Fixture, INJECTION_SCOPE } from "@autometa/injection";
-import { AxiosClient } from "./axios-client";
-import { HTTPClient } from "./http-client";
-import { defaultClientFactory } from "./default-client-factory";
-import { HTTPRequest, HTTPRequestBuilder } from "./http-request";
-import { HTTPResponse } from "./http-response";
-import { MetaConfig, MetaConfigBuilder } from "./request-meta.config";
-import {
-  HTTPAdditionalOptions,
-  RequestHook,
-  ResponseHook,
-  SchemaParser,
-  StatusCode,
-} from "./types";
-import { transformResponse } from "./transform-response";
-import { AutomationError } from "@autometa/errors";
-
-/**
- * The HTTP fixture allows requests to be built and sent to a server. In general,
- * there are 2 modes of operation:
- *
- * * Shared Chain: The shared chain is used to configure the client for all requests, such as
- * routes this instance will always be used. When a shared chain method is called, it returns
- * the same instance of HTTP which can be further chained to configure the client.
- * * Request Chain: The request chain is used to configure a single request, inheriting values
- * set by the shared chain. When called, a new HTTP client instance is created and inherits the values
- * set by it's parent.
- *
- * The 2 modes are intended to simplify configuring an object through an inheritance chain. For example,
- * assume we have an API with 2 controller routes, `/product` and `/seller`. We can set up a Base Client
- * which consumes the HTTP fixture and configures it with the base url of our API.
- *
- * Inheritors can further configure their HTTP instance's routes.
- *
- * ```ts
- * \@Constructor(HTTP)
- * export class BaseClient {
- *  constructor(protected readonly http: HTTP) {
- *    this.http.url("https://api.example.com");
- *   }
- * }
- *
- * export class ProductClient extends BaseClient {
- *  constructor(http: HTTP) {
- *   super(http);
- *   this.http.sharedRoute("product");
- *  }
- *  getProduct(id: number) {
- *   return this.http.route(id).get();
- * }
- *
- * export class SellerClient extends BaseClient {
- *  constructor(http: HTTP) {
- *   super(http);
- *   this.http.sharedRoute("seller");
- *  }
- *
- *  getSeller(id: number) {
- *    return this.http.route(id).get();
- *  }
- * }
- * ```
- *
- * 'Schemas' can also be configured. A Schema is a function or an object with a `parse` method, which
- * takes a response data payload and returns a validated object. Schemas are mapped to
- * HTTP Status Codes, and if configured to be required the request will fail if no schema is found
- * matching that code.
- *
- * Defining a schema function:
- *
- * ```
- * // user.schema.ts
- * export function UserSchema(data: unknown) {
- *   if(typeof data !== "object") {
- *    throw new Error("Expected an object");
- *   }
- *
- *   if(typeof data.name !== "string") {
- *    throw new Error("Expected a string");
- *   }
- *
- *  return data as { name: string };
- * }
- *
- * // user.controller.ts
- * \@Fixture(INJECTION_SCOPE.TRANSIENT)
- * export class UserController extends BaseController {
- *   constructor(private readonly http: HTTP) {
- *      super(http);
- *      this.http
- *          .sharedRoute("user")
- *          .sharedSchema(ErrorSchema, { from: 400, to: 499 });
- *   }
- *
- *   getUser(id: number) {
- *    return this.http.route(id).schema(UserSchema, 200).get();
- *    // or
- *    return this.http
- *               .route(id)
- *               .schema(UserSchema, { from: 200, to: 299 })
- *               .get();
- *    // or
- *    return this.http
- *               .route(id)
- *               .schema(UserSchema, 200, 201, 202)
- *               .get();
- *   }
- * }
- * ```
- *
- * Validation libraries which use a `.parse` or `.validation`,  method, such as Zod or MyZod, can also be used as schemas:
- *
- * ```ts
- * // user.schema.ts
- * import { z } from "myzod";
- *
- * export const UserSchema = z.object({
- *  name: z.string()
- * });
- *
- * // user.controller.ts
- * \@Fixture(INJECTION_SCOPE.TRANSIENT)
- * export class UserController extends BaseController {
- *  constructor(private readonly http: HTTP) {
- *   super(http);
- *   this.http
- *       .sharedRoute("user")
- *       .sharedSchema(ErrorSchema, { from: 400, to: 499 })
- *  }
- *
- *  getUser(id: number) {
- *   return this.http.route(id).schema(UserSchema, 200).get();
- *  }
- * }
- * ```
- */
-@Fixture(INJECTION_SCOPE.TRANSIENT)
-export class HTTP {
-  #request: HTTPRequestBuilder<HTTPRequest<unknown>>;
-  #metaConfig: MetaConfigBuilder;
-  constructor(
-    private readonly client: HTTPClient = defaultClientFactory(),
-    builder: HTTPRequestBuilder<
-      HTTPRequest<unknown>
-    > = new HTTPRequestBuilder(),
-    metaConfig: MetaConfigBuilder = new MetaConfigBuilder()
-  ) {
-    this.#request = builder;
-    this.#metaConfig = metaConfig.derive();
-  }
-
-  static create(
-    client: HTTPClient = new AxiosClient(),
-    builder: HTTPRequestBuilder<
-      HTTPRequest<unknown>
-    > = new HTTPRequestBuilder(),
-    metaConfig: MetaConfigBuilder = new MetaConfigBuilder()
-  ) {
-    const derived = new HTTP(client, builder, metaConfig);
-    return derived;
-  }
-
-  /**
-   * 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: string) {
-    this.#request.url(url);
-    return this;
-  }
-
-  sharedOptions(options: HTTPAdditionalOptions<unknown>) {
-    this.#metaConfig.options(options);
-    return this;
-  }
-
-  /**
-   * 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: boolean) {
-    this.#metaConfig.requireSchema(required);
-    return this;
-  }
-
-  /**
-   * 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: boolean) {
-    this.#metaConfig.allowPlainText(allow);
-    return this;
-  }
-
-  /**
-   * 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: boolean) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive(),
-      this.#metaConfig.derive().allowPlainText(allow)
-    );
-  }
-
-  /**
-   * 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: (string | number | boolean)[]) {
-    this.#request.route(...route.map((r) => r.toString()));
-    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: (string | number | boolean)[]) {
-    const mapped = route.map((r) => String(r));
-    return HTTP.create(
-      this.client,
-      this.#request.derive().route(...mapped),
-      this.#metaConfig.derive()
-    );
-  }
-
-  /**
-   * Attaches a shared schema mapping for all requests by this client. Schemas are
-   * mapped to HTTP Status Codes, and if configured to be required the request will fail
-   * if no schema is found matching that code.
-   *
-   * The status code mapping can be defined as a single code, a range of codes, or a spread list.
-   *
-   * ```ts
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *   super(http);
-   *   this.http
-   *       .sharedRoute("user")
-   *       .sharedSchema(UserSchema, 200)
-   *       .sharedSchema(EmptySchema, 201, 204)
-   *       .sharedSchema(ErrorSchema, { from: 400, to: 499 });
-   *  }
-   * }
-   * ```
-   *
-   * This method is a shared chain method, and will return the same instance of HTTP. All
-   * child clients will inherit the schemas defined by this method. Useful to configure
-   * in the constructor body.
-   *
-   * @param parser The schema parser to use for this mapping.
-   * @param codes A single status code, a range of status codes, or a spread list of status codes.
-   * @returns This instance of HTTP.
-   */
-  sharedSchema(parser: SchemaParser, ...codes: StatusCode[]): HTTP;
-  sharedSchema(
-    parser: SchemaParser,
-    ...range: { from: StatusCode; to: StatusCode }[]
-  ): HTTP;
-  sharedSchema(
-    parser: SchemaParser,
-    ...args: (StatusCode | { from: StatusCode; to: StatusCode })[]
-  ): HTTP {
-    this.#metaConfig.schema(parser, ...args);
-    return this;
-  }
-
-  /**
-   * Attaches a schema mapping for this request. Schemas are
-   * mapped to HTTP Status Codes, and if configured to be required the request will fail
-   * if no schema is found matching that code.
-   *
-   * The status code mapping can be defined as a single code, a range of codes, or a spread list.
-   *
-   * ```ts
-   * \@Fixture(INJECTION_SCOPE.TRANSIENT)
-   * export class UserController extends BaseController {
-   *  constructor(private readonly http: HTTP) {
-   *   super(http);
-   *   this.http
-   *       .sharedRoute("user")
-   *       .schema(ErrorSchema, { from: 400, to: 499 });
-   *  }
-   *
-   *  getUser(id: number) {
-   *   return this.http.route(id).schema(UserSchema, 200).get();
-   *  }
-   *
-   *  getUsers(...ids: number[]) {
-   *    return this.http
-   *               .route("users")
-   *               .schema(UserSchema, { from: 200, to: 299 })
-   *               .schema(UserSchema, 200)
-   *               .get();
-   * }
-   * ```
-   *
-   * This method is a request chain method, and will return a new instance of HTTP, inheriting
-   * any schemas previously defined and appending the new schema. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * @param parser The schema parser to use for this mapping.
-   * @param codes A single status code, a range of status codes, or a spread list of status codes.
-   * @returns A new child instance of HTTP derived from this one.
-   */
-  schema(parser: SchemaParser, ...codes: StatusCode[]): HTTP;
-  schema(
-    parser: SchemaParser,
-    ...range: { from: StatusCode; to: StatusCode }[]
-  ): HTTP;
-  schema(
-    parser: SchemaParser,
-    ...args: (StatusCode | { from: StatusCode; to: StatusCode })[]
-  ): HTTP {
-    return HTTP.create(
-      this.client,
-      this.#request.derive(),
-      this.#metaConfig.derive().schema(parser, ...args)
-    );
-  }
-
-  /**
-   * Attaches a shared query string parameter to all requests by this client. 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.
-   *
-   * @param name The name of the query string parameter.
-   * @param value The value of the query string parameter.
-   * @returns This instance of HTTP.
-   */
-  sharedParam(name: string, value: Record<string, unknown>): HTTP;
-  sharedParam(name: string, ...value: (string | number | boolean)[]): HTTP;
-  sharedParam(name: string, value: (string | number | boolean)[]): HTTP;
-  sharedParam(
-    name: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    value: any
-  ): HTTP {
-    this.#request.param(name, value);
-    return this;
-  }
-
-  /**
-   * `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: string, hook: RequestHook) {
-    this.#metaConfig.onBeforeSend(description, hook);
-    return this;
-  }
-
-  /**
-   * `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: string, hook: ResponseHook<unknown>) {
-    this.#metaConfig.onReceiveResponse(description, hook);
-    return this;
-  }
-
-  /**
-   * 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: Record<string, unknown>) {
-    this.#request.params(dict);
-    return this;
-  }
-
-  /**
-   * Attaches a query string parameter 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 request chain method, and will return a new instance of HTTP, inheriting
-   * any query string parameters previously defined and appending the new parameter. Useful to configure
-   * in class methods as part of finalizing a request.
-   *
-   * ```ts
-   * getUser(id: number) {
-   *   return this.http
-   *             .route(id)
-   *             .param("name", "John")
-   *             .param("age", 30)
-   * ```
-   *
-   * Note: Numbers and Booleans will be converted to strings automatically.
-   *
-   * @param name The name of the query string parameter.
-   * @param value The value of the query string parameter.
-   * @returns A new child instance of HTTP derived from this one.
-   */
-  param(name: string, value: Record<string, unknown>): HTTP;
-  param(name: string, ...value: (string | number | boolean)[]): HTTP;
-  param(name: string, value: (string | number | boolean)[]): HTTP;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  param(name: string, ...value: any) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive().param(name, value),
-      this.#metaConfig.derive()
-    );
-  }
-
-  /**
-   * 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: Record<string, unknown>) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive().params(dict),
-      this.#metaConfig.derive()
-    );
-  }
-
-  /**
-   * 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<T>(data: T) {
-    this.#request.data(data);
-    return this;
-  }
-
-  /**
-   * 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: string,
-    value:
-      | string
-      | number
-      | boolean
-      | null
-      | (string | number | boolean)[]
-      | (() => string | number | boolean | null)
-      | (() => Promise<string | number | boolean | null>)
-  ) {
-    this.#request.header(name, value);
-    return this;
-  }
-
-  header(
-    name: string,
-    value:
-      | string
-      | number
-      | boolean
-      | null
-      | (string | number | boolean)[]
-      | (() => string | number | boolean | null)
-      | (() => Promise<string | number | boolean | null>)
-  ) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive().header(name, value),
-      this.#metaConfig.derive()
-    );
-  }
-
-  /**
-   * 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<T>(data: T) {
-    this.#request.data(data);
-    return HTTP.create(
-      this.client,
-      this.#request.derive().data(data),
-      this.#metaConfig.derive()
-    );
-  }
-
-  /**
-   * `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: string, hook: RequestHook) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive(),
-      this.#metaConfig.derive().onBeforeSend(description, hook)
-    );
-  }
-
-  /**
-   * `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: string, hook: ResponseHook<unknown>) {
-    return HTTP.create(
-      this.client,
-      this.#request.derive(),
-      this.#metaConfig.derive().onReceiveResponse(description, hook)
-    );
-  }
-
-  /**
-   * 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<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("GET"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  /**
-   * 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<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("POST"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  /**
-   * 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<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("DELETE"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  /**
-   * 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<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("PUT"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-  /**
-   * 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<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("PATCH"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  head<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("HEAD"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  options<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("OPTIONS"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  trace<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("TRACE"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  connect<TResponseType>(options?: HTTPAdditionalOptions<unknown>) {
-    return this.#makeRequest(
-      this.#request.derive().method("CONNECT"),
-      options
-    ) as Promise<HTTPResponse<TResponseType>>;
-  }
-
-  async #makeRequest(
-    builder: HTTPRequestBuilder<HTTPRequest<unknown>>,
-    options?: HTTPAdditionalOptions<unknown>
-  ) {
-    const request = (await builder.resolveDynamicHeaders()).build();
-    const meta = this.#metaConfig.derive().build();
-    await this.runOnSendHooks(meta, request);
-    const opts = { ...meta.options, ...options };
-    const result = await this.client.request<unknown, string>(request, opts);
-    result.data = transformResponse(meta.allowPlainText, result.data);
-    await this.runOnReceiveHooks(meta, result);
-    const validated = this.#validateResponse(result, meta);
-    return validated;
-  }
-
-  private async runOnSendHooks(
-    meta: MetaConfig,
-    request: HTTPRequest<unknown>
-  ) {
-    for (const [description, hook] of meta.onSend) {
-      try {
-        await hook(request);
-      } catch (e) {
-        const cause = e as Error;
-        const msg = `An error occurred while sending a request in hook: '${description}'`;
-        throw new AutomationError(msg, { cause });
-      }
-    }
-  }
-  private async runOnReceiveHooks(
-    meta: MetaConfig,
-    response: HTTPResponse<unknown>
-  ) {
-    for (const [description, hook] of meta.onReceive) {
-      try {
-        await hook(response);
-      } catch (e) {
-        const cause = e as Error;
-        const msg = `An error occurred while receiving a response in hook: '${description}'`;
-        throw new AutomationError(msg, { cause });
-      }
-    }
-  }
-
-  #validateResponse<T>(
-    response: HTTPResponse<unknown>,
-    meta: MetaConfig
-  ): HTTPResponse<T> {
-    const { status, data } = response;
-    const validated = meta.schemas.validate(
-      status,
-      data,
-      meta.requireSchema
-    ) as T;
-    response.data = validated;
-    return response as HTTPResponse<T>;
-  }
-}