@autometa/http 1.4.20 → 2.0.0-rc.1

package/dist/index.d.ts

@@ -1,1116 +1,15 @@
-import { StatusCodes } from '@autometa/status-codes';
-import { AxiosRequestConfig } from 'axios';
-import { Class } from '@autometa/types';
-
-declare class HTTPResponse<T = unknown> {
-    status: StatusCode;
-    statusText: string;
-    data: T;
-    headers: Record<string, string>;
-    request: HTTPRequest<unknown>;
-    constructor();
-    static fromRaw<T>(response: HTTPResponse<T>): HTTPResponse<T>;
-    /**
-     * Decomposes a response, creating an exact copy of the current response,
-     * but with a new data value. The data can be provided directly as is, or it
-     * can be generated through a callback function which receives the current
-     * response data as an argument.
-     *
-     * ```ts
-     * const response = await http.get("/products");
-     *
-     * // direct value
-     * const products = response.data;
-     * const firstProduct = response.decompose(products[0]);
-     * // callback transformer
-     * const secondProduct = response.decompose((products) => products[1]);
-     * // callback transformer with destructuring
-     * const secondProduct = response.decompose(([product]) => product);
-     * ```
-     * @param value
-     */
-    decompose<K>(value: K): HTTPResponse<K>;
-    decompose<K>(transformFn: (response: T) => K): HTTPResponse<K>;
-}
-declare class HTTPResponseBuilder {
-    #private;
-    static create(): HTTPResponseBuilder;
-    derive(): HTTPResponseBuilder;
-    status(code: StatusCode): this;
-    statusText(text: string): this;
-    data<T>(data: T): this;
-    headers(dict: Record<string, string>): this;
-    header(name: string, value: string): this;
-    request(request: HTTPRequest<unknown>): this;
-    build(): HTTPResponse<unknown>;
-}
-
-type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "get" | "post" | "put" | "delete" | "patch" | "head" | "options" | "trace" | "connect";
-type HTTPAdditionalOptions<T> = {
-    [P in keyof T]: T[P];
-};
-type SchemaParser = {
-    parse: (data: unknown) => unknown;
-} | {
-    validate: (data: unknown) => unknown;
-} | ((data: unknown) => unknown);
-type StatusCode<T extends typeof StatusCodes = typeof StatusCodes> = {
-    [P in keyof T]: T[P] extends {
-        status: infer U;
-    } ? U : never;
-}[keyof T];
-type RequestHook = <T = unknown>(state: HTTPRequest<T>) => unknown;
-type ResponseHook<T> = (state: HTTPResponse<T>) => unknown;
-
-interface RequestBaseConfig {
-    headers?: Record<string, string>;
-    params?: Record<string, string | string[] | Record<string, unknown>>;
-    baseUrl?: string;
-    route?: string[];
-    method: HTTPMethod;
-    /**
-     * 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.
-     * @returns The full url of the request
-     */
-    get fullUrl(): string;
-}
-interface RequestData<T = unknown> {
-    data: T;
-}
-type RequestConfig<T> = RequestBaseConfig & RequestData<T>;
-type RequestConfigBasic = RequestConfig<Record<string, unknown>>;
-
-declare class HTTPRequest<T = unknown> implements RequestConfig<T> {
-    headers: Record<string, string>;
-    params: Record<string, string | string[] | Record<string, unknown>>;
-    baseUrl?: string;
-    route: string[];
-    method: HTTPMethod;
-    data: T;
-    constructor(config?: RequestConfigBasic);
-    /**
-     * 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 getter 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.
-     */
-    get fullUrl(): string;
-    /**
-     * Returns a new independent copy of the request.
-     */
-    static derive(original: HTTPRequest<unknown>): HTTPRequest<unknown>;
-}
-declare class HTTPRequestBuilder<T extends HTTPRequest<unknown>> {
-    #private;
-    constructor(request?: T | (() => T));
-    static create<T extends HTTPRequest<unknown>>(): HTTPRequestBuilder<T>;
-    get request(): T;
-    resolveDynamicHeaders(request?: HTTPRequest<T>): Promise<this>;
-    url(url: string): this;
-    route(...route: string[]): this;
-    param(name: string, value: string | number | boolean | (string | number | boolean)[] | Record<string, string | number | boolean>): this;
-    params(dict: Record<string, unknown>): this;
-    data<T>(data: T): this;
-    header(name: string, value: string | number | boolean | null | (string | number | boolean)[] | (() => string | number | boolean | null) | (() => Promise<string | number | boolean | null>), onArray?: (value: (string | number | boolean)[]) => string): this;
-    headers(dict: Record<string, string>): this;
-    get(): T;
-    method(method: HTTPMethod): this;
-    derive(): HTTPRequestBuilder<T>;
-    build(): HTTPRequest<T>;
-    buildAsync(): Promise<HTTPRequest<T>>;
-}
-
-declare let defaultClient: Class<HTTPClient>;
-declare abstract class HTTPClient {
-    static Use(): (target: Class<HTTPClient>) => void;
-    abstract request<TRequestType, TResponseType>(request: HTTPRequest<TRequestType>, options?: HTTPAdditionalOptions<unknown>): Promise<HTTPResponse<TResponseType>>;
-}
-
-declare class AxiosClient extends HTTPClient {
-    request<TRequestType, TResponseType>(request: HTTPRequest<TRequestType>, options: HTTPAdditionalOptions<AxiosRequestConfig>): Promise<HTTPResponse<TResponseType>>;
-}
-
-declare class SchemaMap {
-    #private;
-    constructor(map?: Map<StatusCode, SchemaParser> | SchemaMap);
-    derive(): SchemaMap;
-    registerStatus(parser: SchemaParser, ...codes: StatusCode[]): void;
-    registerRange(parser: SchemaParser, from: StatusCode, to: StatusCode): void;
-    validate(status: StatusCode, data: unknown, requireSchema: boolean): unknown;
-    getParser(status: StatusCode, requireSchema: boolean): SchemaParser;
-    toObject(): Record<StatusCode<{
-        readonly CONTINUE: {
-            readonly status: 100;
-            readonly statusText: "Continue";
-        };
-        readonly SWITCHING_PROTOCOLS: {
-            readonly status: 101;
-            readonly statusText: "Switching Protocols";
-        };
-        readonly PROCESSING: {
-            readonly status: 102;
-            readonly statusText: "Processing";
-        };
-        readonly OK: {
-            readonly status: 200;
-            readonly statusText: "OK";
-        };
-        readonly CREATED: {
-            readonly status: 201;
-            readonly statusText: "Created";
-        };
-        readonly ACCEPTED: {
-            readonly status: 202;
-            readonly statusText: "Accepted";
-        };
-        readonly NON_AUTHORITATIVE_INFORMATION: {
-            readonly status: 203;
-            readonly statusText: "Non Authoritative Information";
-        };
-        readonly NO_CONTENT: {
-            readonly status: 204;
-            readonly statusText: "No Content";
-        };
-        readonly RESET_CONTENT: {
-            readonly status: 205;
-            readonly statusText: "Reset Content";
-        };
-        readonly PARTIAL_CONTENT: {
-            readonly status: 206;
-            readonly statusText: "Partial Content";
-        };
-        readonly MULTI_STATUS: {
-            readonly status: 207;
-            readonly statusText: "Multi-Status";
-        };
-        readonly MULTIPLE_CHOICES: {
-            readonly status: 300;
-            readonly statusText: "Multiple Choices";
-        };
-        readonly MOVED_PERMANENTLY: {
-            readonly status: 301;
-            readonly statusText: "Moved Permanently";
-        };
-        readonly MOVED_TEMPORARILY: {
-            readonly status: 302;
-            readonly statusText: "Moved Temporarily";
-        };
-        readonly SEE_OTHER: {
-            readonly status: 303;
-            readonly statusText: "See Other";
-        };
-        readonly NOT_MODIFIED: {
-            readonly status: 304;
-            readonly statusText: "Not Modified";
-        };
-        readonly USE_PROXY: {
-            readonly status: 305;
-            readonly statusText: "Use Proxy";
-        };
-        readonly TEMPORARY_REDIRECT: {
-            readonly status: 307;
-            readonly statusText: "Temporary Redirect";
-        };
-        readonly PERMANENT_REDIRECT: {
-            readonly status: 308;
-            readonly statusText: "Permanent Redirect";
-        };
-        readonly BAD_REQUEST: {
-            readonly status: 400;
-            readonly statusText: "Bad Request";
-        };
-        readonly UNAUTHORIZED: {
-            readonly status: 401;
-            readonly statusText: "Unauthorized";
-        };
-        readonly PAYMENT_REQUIRED: {
-            readonly status: 402;
-            readonly statusText: "Unauthorized";
-        };
-        readonly FORBIDDEN: {
-            readonly status: 403;
-            readonly statusText: "Forbidden";
-        };
-        readonly NOT_FOUND: {
-            readonly status: 404;
-            readonly statusText: "Not Found";
-        };
-        readonly METHOD_NOT_ALLOWED: {
-            readonly status: 405;
-            readonly statusText: "Method Not Allowed";
-        };
-        readonly NOT_ACCEPTABLE: {
-            readonly status: 406;
-            readonly statusText: "Not Acceptable";
-        };
-        readonly PROXY_AUTHENTICATION_REQUIRED: {
-            readonly status: 407;
-            readonly statusText: "Proxy Authentication Required";
-        };
-        readonly REQUEST_TIMEOUT: {
-            readonly status: 408;
-            readonly statusText: "Request Timeout";
-        };
-        readonly CONFLICT: {
-            readonly status: 409;
-            readonly statusText: "Conflict";
-        };
-        readonly GONE: {
-            readonly status: 410;
-            readonly statusText: "Gone";
-        };
-        readonly LENGTH_REQUIRED: {
-            readonly status: 411;
-            readonly statusText: "Length Required";
-        };
-        readonly PRECONDITION_FAILED: {
-            readonly status: 412;
-            readonly statusText: "Precondition Failed";
-        };
-        readonly REQUEST_TOO_LONG: {
-            readonly status: 413;
-            readonly statusText: "Request Entity Too Large";
-        };
-        readonly REQUEST_URI_TOO_LONG: {
-            readonly status: 414;
-            readonly statusText: "Request-URI Too Long";
-        };
-        readonly UNSUPPORTED_MEDIA_TYPE: {
-            readonly status: 415;
-            readonly statusText: "Unsupported Media Type";
-        };
-        readonly REQUESTED_RANGE_NOT_SATISFIABLE: {
-            readonly status: 416;
-            readonly statusText: "Requested Range Not Satisfiable";
-        };
-        readonly EXPECTATION_FAILED: {
-            readonly status: 417;
-            readonly statusText: "Expectation Failed";
-        };
-        readonly IM_A_TEAPOT: {
-            readonly status: 418;
-            readonly statusText: "I'm a teapot";
-        };
-        readonly INSUFFICIENT_SPACE_ON_RESOURCE: {
-            readonly status: 419;
-            readonly statusText: "Insufficient Space on Resource";
-        };
-        readonly METHOD_FAILURE: {
-            readonly status: 420;
-            readonly statusText: "Method Failure";
-        };
-        readonly MISDIRECTED_REQUEST: {
-            readonly status: 421;
-            readonly statusText: "Misdirected Request";
-        };
-        readonly UNPROCESSABLE_ENTITY: {
-            readonly status: 422;
-            readonly statusText: "Unprocessable Entity";
-        };
-        readonly LOCKED: {
-            readonly status: 423;
-            readonly statusText: "Unprocessable Entity";
-        };
-        readonly FAILED_DEPENDENCY: {
-            readonly status: 424;
-            readonly statusText: "Failed Dependency";
-        };
-        readonly PRECONDITION_REQUIRED: {
-            readonly status: 428;
-            readonly statusText: "Precondition Failed";
-        };
-        readonly TOO_MANY_REQUESTS: {
-            readonly status: 429;
-            readonly statusText: "Too Many Requests";
-        };
-        readonly REQUEST_HEADER_FIELDS_TOO_LARGE: {
-            readonly status: 431;
-            readonly statusText: "Request Header Fields Too Large";
-        };
-        readonly UNAVAILABLE_FOR_LEGAL_REASONS: {
-            readonly status: 451;
-            readonly statusText: "Unavailable For Legal Reasons";
-        };
-        readonly INTERNAL_SERVER_ERROR: {
-            readonly status: 500;
-            readonly statusText: "Internal Server Error";
-        };
-        readonly NOT_IMPLEMENTED: {
-            readonly status: 501;
-            readonly statusText: "Not Implemented";
-        };
-        readonly BAD_GATEWAY: {
-            readonly status: 502;
-            readonly statusText: "Bad Gateway";
-        };
-        readonly SERVICE_UNAVAILABLE: {
-            readonly status: 503;
-            readonly statusText: "Service Unavailable";
-        };
-        readonly GATEWAY_TIMEOUT: {
-            readonly status: 504;
-            readonly statusText: "Bad Gateway";
-        };
-        readonly HTTP_VERSION_NOT_SUPPORTED: {
-            readonly status: 505;
-            readonly statusText: "HTTP Version Not Supported";
-        };
-        readonly INSUFFICIENT_STORAGE: {
-            readonly status: 507;
-            readonly statusText: "Insufficient Storage";
-        };
-        readonly NETWORK_AUTHENTICATION_REQUIRED: {
-            readonly status: 511;
-            readonly statusText: "Network Authentication Required";
-        };
-    }>, SchemaParser>;
-}
-
-interface SchemaConfig {
-    schemas: SchemaMap;
-    requireSchema: boolean;
-    allowPlainText: boolean;
-}
-interface HTTPHooks {
-    onSend: [string, RequestHook][];
-    onReceive: [string, ResponseHook<unknown>][];
-}
-declare class MetaConfig implements SchemaConfig, HTTPHooks {
-    schemas: SchemaMap;
-    requireSchema: boolean;
-    allowPlainText: boolean;
-    onSend: [string, RequestHook][];
-    onReceive: [string, ResponseHook<unknown>][];
-    throwOnServerError: boolean;
-    options: HTTPAdditionalOptions<unknown>;
-}
-declare class MetaConfigBuilder {
-    #private;
-    options(options: HTTPAdditionalOptions<unknown>): this;
-    schemaMap(map: SchemaMap): this;
-    schema(parser: SchemaParser, ...codes: StatusCode[]): MetaConfigBuilder;
-    schema(parser: SchemaParser, ...range: {
-        from: StatusCode;
-        to: StatusCode;
-    }[]): MetaConfigBuilder;
-    schema(parser: SchemaParser, ...args: (StatusCode | {
-        from: StatusCode;
-        to: StatusCode;
-    })[]): MetaConfigBuilder;
-    requireSchema(value: boolean): this;
-    allowPlainText(value: boolean): this;
-    onBeforeSend(description: string, hook: RequestHook): this;
-    throwOnServerError(value: boolean): this;
-    onReceiveResponse(description: string, hook: ResponseHook<unknown>): this;
-    build(): MetaConfig;
-    derive(): MetaConfigBuilder;
-}
-
-/**
- * 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();
- *  }
- * }
- * ```
- */
-declare class HTTP {
-    #private;
-    private readonly client;
-    constructor(client?: HTTPClient, builder?: HTTPRequestBuilder<HTTPRequest<unknown>>, metaConfig?: MetaConfigBuilder);
-    static create(client?: HTTPClient, builder?: HTTPRequestBuilder<HTTPRequest<unknown>>, metaConfig?: MetaConfigBuilder): HTTP;
-    /**
-     * 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;
-    sharedOptions(options: HTTPAdditionalOptions<unknown>): 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;
-    /**
-     * 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;
-    /**
-     * 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): HTTP;
-    /**
-     * 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;
-    /**
-     * 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)[]): HTTP;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * `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;
-    /**
-     * `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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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>): HTTP;
-    /**
-     * 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;
-    /**
-     * 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;
-    header(name: string, value: string | number | boolean | null | (string | number | boolean)[] | (() => string | number | boolean | null) | (() => Promise<string | number | boolean | null>)): HTTP;
-    /**
-     * 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): HTTP;
-    /**
-     * `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): HTTP;
-    /**
-     * `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>): HTTP;
-    /**
-     * 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>): 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>): 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>): 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>): 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>): Promise<HTTPResponse<TResponseType>>;
-    head<TResponseType>(options?: HTTPAdditionalOptions<unknown>): Promise<HTTPResponse<TResponseType>>;
-    options<TResponseType>(options?: HTTPAdditionalOptions<unknown>): Promise<HTTPResponse<TResponseType>>;
-    trace<TResponseType>(options?: HTTPAdditionalOptions<unknown>): Promise<HTTPResponse<TResponseType>>;
-    connect<TResponseType>(options?: HTTPAdditionalOptions<unknown>): Promise<HTTPResponse<TResponseType>>;
-    private runOnSendHooks;
-    private runOnReceiveHooks;
-}
-
-/**
- * Schema which does not care about data validation.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response does not matter.
- * @param data
- * @returns
- */
-declare function AnySchema(data: unknown): unknown;
-/**
- * Schema which validates that a response is empty. This can mean
- * the data payload was `null`, `undefined` or the string `'null'`.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be null or not defined.
- * @param data
- * @returns
- */
-declare function EmptySchema(data: unknown): null | undefined;
-/**
- * Schema which validates a response was null.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be null.
- * @param data
- * @returns
- */
-declare function NullSchema(data: unknown): null;
-/**
- * Schema which validates a response was undefined.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be undefined.
- *
- * @param data
- * @returns
- */
-declare function UndefinedSchema(data: unknown): undefined;
-/**
- * Schema which validates a response was a boolean, or a string of value
- * `'true'` or `'false'`.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a boolean.
- *
- * @param data
- * @returns
- */
-declare function BooleanSchema(data: unknown): any;
-/**
- * Schema which validates a response was a number, or a string of value
- * of a number.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a number.
- *
- * @param data
- * @returns
- */
-declare function NumberSchema(data: unknown): any;
-/**
- * Schema which validates a response was a string.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a string.
- *
- * @param data
- * @returns
- */
-declare function StringSchema(data: unknown): string;
-declare function JSONSchema<T = unknown>(data: unknown): any;
-
-export { AnySchema, AxiosClient, BooleanSchema, EmptySchema, HTTP, HTTPAdditionalOptions, HTTPClient, HTTPMethod, HTTPRequest, HTTPRequestBuilder, HTTPResponse, HTTPResponseBuilder, JSONSchema, NullSchema, NumberSchema, RequestHook, ResponseHook, SchemaParser, StringSchema, UndefinedSchema, defaultClient };
+export { HTTP, type HTTPCreateOptions, HTTPError, HTTPTransportError, HTTPSchemaValidationError, } from "./http";
+export { HTTPRequest, HTTPRequestBuilder, type HeaderPrimitive, type HeaderFactory, type ParamValue, type ParamDictionary, type RequestConfigBasic, } from "./http-request";
+export { HTTPResponse, HTTPResponseBuilder } from "./http-response";
+export { SchemaMap } from "./schema.map";
+export { AnySchema, EmptySchema, NullSchema, UndefinedSchema, BooleanSchema, NumberSchema, StringSchema, JSONSchema, } from "./default-schema";
+export { type HTTPPlugin, type HTTPRequestContext, type HTTPResponseContext, type HTTPErrorContext, type HTTPLogEvent, type HTTPLogSink, createLoggingPlugin, } from "./plugins";
+export { MetaConfig, MetaConfigBuilder } from "./request-meta.config";
+export { createFetchTransport, type FetchLike, type FetchRequestOptions, } from "./fetch-transport";
+export { createAxiosTransport, type AxiosLike, type AxiosRequestConfigLike, type AxiosResponseLike, } from "./axios-transport";
+export { transformResponse } from "./transform-response";
+export { type HTTPTransport, type HTTPTransportResponse, } from "./transport";
+export { httpAssertionsPlugin, type HttpAssertionsFacet, } from "./assertions/http-assertions-plugin";
+export { ensureHttp, type HttpEnsureChain, type HttpResponseLike, type StatusExpectation, type HeaderExpectation, type CacheControlExpectation, } from "./assertions/http-ensure";
+export { fromFetchResponse, fromHttpResponse, } from "./assertions/http-adapters";
+export type { HTTPAdditionalOptions, HTTPMethod, SchemaParser, RequestHook, ResponseHook, StatusCode, HTTPRetryOptions, HTTPRetryPredicate, HTTPRetryContext, } from "./types";