@mittwald/api-client-commons 4.3.1 → 4.4.0-alpha.1

package/dist/axios.d.ts

@@ -0,0 +1 @@
+export * from "axios";

package/dist/axios.js

@@ -0,0 +1 @@
+export * from "axios";

package/dist/core/ApiClientBase.d.ts

@@ -0,0 +1,9 @@
+import { AxiosInstance, CreateAxiosDefaults } from "axios";
+import { RequestFunction } from "../types/index.js";
+import { OpenAPIOperation } from "../types/index.js";
+export declare abstract class ApiClientBase {
+    axios: AxiosInstance;
+    constructor(axiosConfig?: AxiosInstance | CreateAxiosDefaults);
+    protected requestFunctionFactory<TOp extends OpenAPIOperation>(operation: TOp): RequestFunction<TOp>;
+}
+export default ApiClientBase;

package/dist/core/ApiClientBase.js

@@ -0,0 +1,13 @@
+import axios, { Axios } from "axios";
+import Request from "./Request.js";
+export class ApiClientBase {
+    axios;
+    constructor(axiosConfig = axios) {
+        this.axios =
+            axiosConfig instanceof Axios ? axiosConfig : axios.create(axiosConfig);
+    }
+    requestFunctionFactory(operation) {
+        return (conf) => new Request(operation, conf).execute(this.axios);
+    }
+}
+export default ApiClientBase;

package/dist/core/ApiClientError.d.ts

@@ -0,0 +1,7 @@
+import { AxiosError, AxiosResponse, InternalAxiosRequestConfig } from "axios";
+import { AnyResponse } from "../types/Response.js";
+export declare class ApiClientError<T = unknown, D = unknown> extends AxiosError<T, D> {
+    constructor(message?: string, code?: string, config?: InternalAxiosRequestConfig<D>, request?: unknown, response?: AxiosResponse<T, D>);
+    static fromResponse(message: string, response: AnyResponse): ApiClientError;
+}
+export default ApiClientError;

package/dist/core/ApiClientError.js

@@ -0,0 +1,12 @@
+import { AxiosError } from "axios";
+export class ApiClientError extends AxiosError {
+    constructor(message, code, config, request, response) {
+        super(message, code, config, request, response);
+        Object.setPrototypeOf(this, ApiClientError.prototype);
+        this.name = "ApiClientError";
+    }
+    static fromResponse(message, response) {
+        return new ApiClientError(message, undefined, response.config, response.request, response);
+    }
+}
+export default ApiClientError;

package/dist/core/OpenAPIPath.d.ts

@@ -0,0 +1,9 @@
+import { PathParameters } from "../types/http.js";
+export declare class OpenAPIPath {
+    private readonly rawPath;
+    private readonly params?;
+    constructor(rawPath: string, params?: PathParameters);
+    buildUrl(): string;
+    private static setPathParams;
+}
+export default OpenAPIPath;

package/dist/core/OpenAPIPath.js

@@ -0,0 +1,20 @@
+export class OpenAPIPath {
+    rawPath;
+    params;
+    constructor(rawPath, params) {
+        this.rawPath = rawPath;
+        this.params = params;
+    }
+    buildUrl() {
+        return OpenAPIPath.setPathParams(this.rawPath, this.params);
+    }
+    static setPathParams(path, params) {
+        const asEntries = Object.entries(params ?? {});
+        const finalPath = asEntries.reduce((path, entry) => {
+            const [key, value] = entry;
+            return path.replace(`{${key}}`, encodeURIComponent(value));
+        }, path);
+        return finalPath.startsWith("/") ? finalPath.substring(1) : finalPath;
+    }
+}
+export default OpenAPIPath;

package/dist/core/Request.d.ts

@@ -0,0 +1,13 @@
+import { OpenAPIOperation, RequestObject, ResponsePromise } from "../types/index.js";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+export declare class Request<TOp extends OpenAPIOperation> {
+    private readonly operationDescriptor;
+    private readonly requestObject?;
+    readonly requestConfig: AxiosRequestConfig;
+    constructor(operationDescriptor: TOp, requestObject?: RequestObject<TOp>);
+    execute(axios: AxiosInstance): ResponsePromise<TOp>;
+    private buildAxiosConfig;
+    private makeAxiosHeaders;
+    private convertQueryToUrlSearchParams;
+}
+export default Request;

package/dist/core/Request.js

@@ -0,0 +1,76 @@
+import OpenAPIPath from "./OpenAPIPath.js";
+export class Request {
+    operationDescriptor;
+    requestObject;
+    requestConfig;
+    constructor(operationDescriptor, requestObject) {
+        this.operationDescriptor = operationDescriptor;
+        this.requestObject = requestObject;
+        this.requestConfig = Object.freeze(this.buildAxiosConfig());
+    }
+    execute(axios) {
+        return axios.request(this.requestConfig);
+    }
+    buildAxiosConfig() {
+        const { method, path } = this.operationDescriptor;
+        const pathParameters = this.requestObject;
+        const openApiPath = new OpenAPIPath(path, pathParameters);
+        const url = openApiPath.buildUrl();
+        const data = this.requestObject && "data" in this.requestObject
+            ? this.requestObject.data
+            : undefined;
+        const headersConfig = this.requestObject && "headers" in this.requestObject
+            ? this.requestObject.headers
+            : undefined;
+        const headers = headersConfig
+            ? this.makeAxiosHeaders(headersConfig)
+            : undefined;
+        const queryParametersConfig = this.requestObject && "queryParameters" in this.requestObject
+            ? this.requestObject.queryParameters
+            : undefined;
+        const params = this.convertQueryToUrlSearchParams(queryParametersConfig);
+        return {
+            url,
+            method,
+            headers,
+            // Must be a plain object or an URLSearchParams object
+            params,
+            data,
+            validateStatus: () => true,
+        };
+    }
+    makeAxiosHeaders(headers) {
+        return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, value?.toString()]));
+    }
+    convertQueryToUrlSearchParams(query) {
+        if (query === undefined || query === null) {
+            return undefined;
+        }
+        if (query instanceof URLSearchParams) {
+            return query;
+        }
+        if (typeof query === "string") {
+            return new URLSearchParams(query);
+        }
+        if (typeof query === "object") {
+            const searchParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(query)) {
+                if (Array.isArray(value)) {
+                    for (const arrayItem of value) {
+                        searchParams.append(key, arrayItem);
+                    }
+                }
+                else {
+                    searchParams.append(key, typeof value === "string" ||
+                        typeof value === "number" ||
+                        typeof value === "boolean"
+                        ? value.toString()
+                        : JSON.stringify(value));
+                }
+            }
+            return searchParams;
+        }
+        throw new Error(`Unexpected query parameter type (${typeof query})`);
+    }
+}
+export default Request;

package/dist/core/Request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/Request.test.js

@@ -0,0 +1,53 @@
+import Request from "./Request.js";
+import { jest } from "@jest/globals";
+const requestFn = jest.fn();
+const mockedAxios = {
+    request: requestFn,
+};
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+describe("query parameters", () => {
+    const op = {
+        path: "/",
+        operationId: "test",
+        method: "GET",
+    };
+    const executeRequest = (query) => {
+        const request = new Request(op, { queryParameters: query });
+        request.execute(mockedAxios);
+        const requestConfig = requestFn.mock.calls[0][0];
+        return requestConfig.params.toString();
+    };
+    test("Empty query", () => {
+        const query = executeRequest({});
+        expect(query).toBe("");
+    });
+    test("Simple parameter", () => {
+        const query = executeRequest({
+            foo: "bar",
+        });
+        expect(query).toBe("foo=bar");
+    });
+    test("Two parameters", () => {
+        const query = executeRequest({
+            foo: "bar",
+            bam: "baz",
+        });
+        expect(query).toBe("foo=bar&bam=baz");
+    });
+    test("Array parameters", () => {
+        const query = executeRequest({
+            foo: ["bar", "bam"],
+        });
+        expect(query).toBe("foo=bar&foo=bam");
+    });
+    test("Number, boolean, JSON", () => {
+        const query = executeRequest({
+            foo: 1,
+            bar: true,
+            baz: { some: "value" },
+        });
+        expect(query).toBe("foo=1&bar=true&baz=%7B%22some%22%3A%22value%22%7D");
+    });
+});

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./ApiClientBase.js";
+export * from "./ApiClientError.js";
+export * from "./OpenAPIPath.js";
+export * from "./Request.js";

package/dist/core/index.js

@@ -0,0 +1,4 @@
+export * from "./ApiClientBase.js";
+export * from "./ApiClientError.js";
+export * from "./OpenAPIPath.js";
+export * from "./Request.js";

package/dist/index.d.ts

@@ -1,45 +1,3 @@
-import { AxiosInstance, CreateAxiosDefaults, AxiosError, InternalAxiosRequestConfig, AxiosResponse, AxiosRequestConfig } from 'axios';
-export * from 'axios';
-import { R as Response, O as OpenAPIOperation, a as RequestFunction, A as AnyResponse, P as PathParameters, b as RequestObject, c as ResponsePromise } from './shared/api-client-commons.8b686095.js';
-export { e as AnyRequest, n as HttpHeaders, l as HttpMediaType, m as HttpMethod, H as HttpPayload, k as HttpStatus, h as InferredRequestData, I as InferredRequestType, g as InferredResponseData, f as InferredResponseType, Q as QueryParameters, j as RequestData, d as RequestType, i as ResponseData } from './shared/api-client-commons.8b686095.js';
-import 'type-fest';
-
-type Simplify<T> = {
-    [KeyType in keyof T]: T[KeyType];
-} & {};
-
-declare function assertStatus<T extends Response, S extends T["status"]>(response: T, expectedStatus: S): asserts response is T & {
-    status: S;
-};
-
-declare abstract class ApiClientBase {
-    axios: AxiosInstance;
-    constructor(axiosConfig?: AxiosInstance | CreateAxiosDefaults);
-    protected requestFunctionFactory<TOp extends OpenAPIOperation>(operation: TOp): RequestFunction<TOp>;
-}
-
-declare class ApiClientError<T = unknown, D = unknown> extends AxiosError<T, D> {
-    constructor(message?: string, code?: string, config?: InternalAxiosRequestConfig<D>, request?: unknown, response?: AxiosResponse<T, D>);
-    static fromResponse(message: string, response: AnyResponse): ApiClientError;
-}
-
-declare class OpenAPIPath {
-    private readonly rawPath;
-    private readonly params?;
-    constructor(rawPath: string, params?: PathParameters);
-    buildUrl(): string;
-    private static setPathParams;
-}
-
-declare class Request<TOp extends OpenAPIOperation> {
-    private readonly operationDescriptor;
-    private readonly requestObject?;
-    readonly requestConfig: AxiosRequestConfig;
-    constructor(operationDescriptor: TOp, requestObject?: RequestObject<TOp>);
-    execute(axios: AxiosInstance): ResponsePromise<TOp>;
-    private buildAxiosConfig;
-    private makeAxiosHeaders;
-    private convertQueryToUrlSearchParams;
-}
-
-export { AnyResponse, ApiClientBase, ApiClientError, OpenAPIOperation, OpenAPIPath, PathParameters, Request, RequestFunction, RequestObject, Response, ResponsePromise, type Simplify, assertStatus };
+export * from "./core/index.js";
+export * from "./types/index.js";
+export * from "./axios.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./core/index.js";
+export * from "./types/index.js";
+export * from "./axios.js";

package/dist/react/ApiCallAsyncResourceFactory.d.ts

@@ -0,0 +1,12 @@
+import { OpenAPIOperation, RequestFunction } from "../types/index.js";
+import { GetApiResourceFn } from "./types.js";
+export declare class ApiCallAsyncResourceFactory<TOp extends OpenAPIOperation> {
+    private static namespace;
+    private readonly operation;
+    private readonly requestFn;
+    constructor(operation: TOp, requestFn: RequestFunction<TOp>);
+    private getAsyncResourceId;
+    private getAsyncResourceTags;
+    private executeRequest;
+    getApiResource: GetApiResourceFn<TOp>;
+}

package/dist/react/ApiCallAsyncResourceFactory.js

@@ -0,0 +1,35 @@
+import { getAsyncResource } from "@mittwald/react-use-promise";
+import { assertStatus, } from "../types/index.js";
+import Request from "../core/Request.js";
+export class ApiCallAsyncResourceFactory {
+    static namespace = "@mittwald/api-client";
+    operation;
+    requestFn;
+    constructor(operation, requestFn) {
+        this.operation = operation;
+        this.requestFn = requestFn;
+    }
+    getAsyncResourceId() {
+        return `${ApiCallAsyncResourceFactory.namespace}/${this.operation.operationId}`;
+    }
+    getAsyncResourceTags(request) {
+        const url = request.requestConfig.url ?? "";
+        return [
+            this.getAsyncResourceId(),
+            `${ApiCallAsyncResourceFactory.namespace}/${this.operation.method}`,
+            `${ApiCallAsyncResourceFactory.namespace}/${url}`,
+        ];
+    }
+    async executeRequest(requestObj) {
+        const response = await this.requestFn(requestObj);
+        assertStatus(response, 200);
+        return response.data;
+    }
+    getApiResource = ((requestObj) => {
+        const request = new Request(this.operation, requestObj);
+        return getAsyncResource((requestObj) => this.executeRequest(requestObj), [requestObj], {
+            tags: this.getAsyncResourceTags(request),
+            loaderId: this.getAsyncResourceId(),
+        });
+    });
+}

package/dist/react/ApiCallAsyncResourceFactory.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react/ApiCallAsyncResourceFactory.test-types.js

@@ -0,0 +1,36 @@
+import { ApiCallAsyncResourceFactory } from "./ApiCallAsyncResourceFactory.js";
+const getStuff = new ApiCallAsyncResourceFactory({
+    operationId: "getStuff",
+    path: "/stuff",
+    method: "GET",
+}, {});
+function ignoredCheckRequestType() {
+    getStuff.getApiResource({
+        data: {
+            // @ts-expect-error Not matching request type
+            foo: "",
+        },
+    });
+    getStuff.getApiResource({
+        data: {
+            requestString: "",
+        },
+    });
+}
+function ignoredCheckResponseType() {
+    const stuff = getStuff
+        .getApiResource({
+        data: {
+            requestString: "",
+        },
+    })
+        .use();
+    // @ts-expect-error Accessing unknown prop
+    stuff.foo;
+    (function (ignored) {
+        // @ts-expect-error is a number
+    })(stuff.responseData);
+    (function (ignored) {
+        // is number
+    })(stuff.responseData);
+}

package/dist/react/ApiCallAsyncResourceFactory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react/ApiCallAsyncResourceFactory.test.js

@@ -0,0 +1,46 @@
+import { beforeEach, expect, jest } from "@jest/globals";
+import { ApiCallAsyncResourceFactory } from "./ApiCallAsyncResourceFactory.js";
+import { refresh } from "@mittwald/react-use-promise";
+beforeEach(() => {
+    refresh();
+    jest.resetAllMocks();
+});
+const requestMock = jest.fn();
+const getStuff = new ApiCallAsyncResourceFactory({
+    operationId: "getStuff",
+    path: "/stuff",
+    method: "GET",
+}, requestMock);
+const testRequest1 = {
+    data: {
+        foo: "bar",
+    },
+};
+const testRequest2 = {
+    data: {
+        foo: "baz",
+    },
+};
+test("Resource loader executes request", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    const firstRequestParams = requestMock.mock.calls[0][0];
+    expect(firstRequestParams).toMatchObject(testRequest1);
+});
+test("Resource is cached under URL", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    refresh({
+        tag: "@mittwald/api-client/stuff",
+    });
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(2);
+});
+test("Resources are different when request object changes", async () => {
+    await getStuff.getApiResource(testRequest1).load();
+    expect(requestMock).toHaveBeenCalledTimes(1);
+    await getStuff.getApiResource(testRequest2).load();
+    expect(requestMock).toHaveBeenCalledTimes(2);
+});

package/dist/react/index.d.ts

@@ -1,19 +1 @@
-import { O as OpenAPIOperation, b as RequestObject, g as InferredResponseData, a as RequestFunction } from '../shared/api-client-commons.8b686095.js';
-import { AsyncResource } from '@mittwald/react-use-promise';
-import 'axios';
-import 'type-fest';
-
-type GetApiResourceFn<TOp extends OpenAPIOperation> = null extends RequestObject<TOp> ? (conf?: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>> : (conf: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>>;
-
-declare class ApiCallAsyncResourceFactory<TOp extends OpenAPIOperation> {
-    private static namespace;
-    private readonly operation;
-    private readonly requestFn;
-    constructor(operation: TOp, requestFn: RequestFunction<TOp>);
-    private getAsyncResourceId;
-    private getAsyncResourceTags;
-    private executeRequest;
-    getApiResource: GetApiResourceFn<TOp>;
-}
-
-export { ApiCallAsyncResourceFactory };
+export * from "./ApiCallAsyncResourceFactory.js";

package/dist/react/index.js

@@ -0,0 +1 @@
+export * from "./ApiCallAsyncResourceFactory.js";

package/dist/react/types.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIOperation, RequestObject, InferredResponseData } from "../types/index.js";
+import { AsyncResource } from "@mittwald/react-use-promise";
+export type GetApiResourceFn<TOp extends OpenAPIOperation> = null extends RequestObject<TOp> ? (conf?: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>> : (conf: RequestObject<TOp>) => AsyncResource<InferredResponseData<TOp>>;

package/dist/react/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/NullableOnNoRequiredKeysDeep.d.ts

@@ -0,0 +1,6 @@
+import { HasRequiredKeys, OmitIndexSignature, PartialOnUndefinedDeep } from "type-fest";
+type PartialOnNoRequiredKeysDeep<T> = PartialOnUndefinedDeep<OmitIndexSignature<{
+    [TKey in keyof T]: HasRequiredKeys<PartialOnNoRequiredKeysDeep<T[TKey]>> extends true ? T[TKey] : T[TKey] | undefined;
+}>>;
+export type NullableOnNoRequiredKeysDeep<T> = HasRequiredKeys<PartialOnNoRequiredKeysDeep<T>> extends true ? PartialOnNoRequiredKeysDeep<T> : PartialOnNoRequiredKeysDeep<T> | null;
+export {};

package/dist/types/NullableOnNoRequiredKeysDeep.js

@@ -0,0 +1 @@
+export {};

package/dist/types/OpenAPIOperation.d.ts

@@ -0,0 +1,20 @@
+import { AnyResponse, Response } from "./Response.js";
+import { AnyRequest, RequestType } from "./RequestType.js";
+import { HttpMethod, HttpStatus } from "./http.js";
+export interface OpenAPIOperation<TIgnoredRequest extends AnyRequest = RequestType, IgnoredResponse extends AnyResponse = Response> {
+    operationId: string;
+    path: string;
+    method: HttpMethod;
+}
+export type InferredRequestType<TOp> = TOp extends OpenAPIOperation<infer TReq> ? TReq : never;
+export type InferredResponseType<TOp> = TOp extends OpenAPIOperation<RequestType, infer TRes> ? TRes : never;
+export type InferredResponseData<TOp, TStatus extends HttpStatus = 200> = Extract<InferredResponseType<TOp>, {
+    status: TStatus;
+}>["data"];
+export type InferredRequestData<TOp> = TOp extends OpenAPIOperation ? InferredRequestType<TOp> extends {
+    data: infer TData;
+} ? TData : never : never;
+/** @deprecated Use InferredResponseData */
+export type ResponseData<TOp> = InferredResponseData<TOp>;
+/** @deprecated Use InferredRequestData */
+export type RequestData<TOp> = InferredRequestData<TOp>;

package/dist/types/OpenAPIOperation.js

@@ -0,0 +1 @@
+export {};

package/dist/types/RequestFunction.d.ts

@@ -0,0 +1,11 @@
+import { InferredRequestType, InferredResponseType, OpenAPIOperation } from "./OpenAPIOperation.js";
+import { NullableOnNoRequiredKeysDeep } from "./NullableOnNoRequiredKeysDeep.js";
+type UnboxPathParameters<T> = T extends {
+    pathParameters: infer TPath;
+} ? Omit<T, "pathParameters"> & TPath : T;
+export type RequestObject<TOp extends OpenAPIOperation> = NullableOnNoRequiredKeysDeep<UnboxPathParameters<InferredRequestType<TOp>>>;
+export type ResponsePromise<TOp extends OpenAPIOperation> = Promise<InferredResponseType<TOp>>;
+type RequestFunctionWithOptionalRequest<TOp extends OpenAPIOperation> = (request?: RequestObject<TOp>) => ResponsePromise<TOp>;
+type RequestFunctionWithRequiredRequest<TOp extends OpenAPIOperation> = (request: RequestObject<TOp>) => ResponsePromise<TOp>;
+export type RequestFunction<TOp extends OpenAPIOperation> = null extends RequestObject<TOp> ? RequestFunctionWithOptionalRequest<TOp> : RequestFunctionWithRequiredRequest<TOp>;
+export {};

package/dist/types/RequestFunction.js

@@ -0,0 +1 @@
+export {};

package/dist/types/RequestFunction.test-types.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/RequestFunction.test-types.js

@@ -0,0 +1,29 @@
+function ignoredTestEmptyRequestTypes() {
+    const f = {};
+    void f();
+    void f({
+        headers: {},
+    });
+    void f({
+        headers: { extra: true },
+    });
+}
+function ignoredTestOptionalHeadersRequestTypes() {
+    const f = {};
+    void f();
+    void f({
+        headers: {},
+    });
+    void f({
+        headers: { extra: true },
+    });
+}
+function ignoredTestPathParametersAreInRootOfRequestConfig() {
+    const f = {};
+    void f({
+        foo: "",
+    });
+    // @ts-expect-error Missing parameter
+    void f({});
+}
+export {};

package/dist/types/RequestType.d.ts

@@ -0,0 +1,21 @@
+import { HttpHeaders, HttpPayload, PathParameters, QueryParameters } from "./http.js";
+type EmptyObject = Record<string, never>;
+type EmptyRequestComponent = EmptyObject | null;
+type RequestWithOptionalHeaders = {
+    headers?: HttpHeaders;
+};
+type RequestWithData<TData> = TData extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    data: TData;
+};
+type RequestWithPathParameters<TPathParameters> = TPathParameters extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    pathParameters: TPathParameters;
+};
+type RequestWithHeaders<THeaders> = THeaders extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    headers: THeaders & HttpHeaders;
+};
+type RequestWithQueryParameters<TQuery> = TQuery extends EmptyRequestComponent ? RequestWithOptionalHeaders : {
+    queryParameters: TQuery & HttpHeaders;
+};
+export type RequestType<TData extends HttpPayload = EmptyRequestComponent, TPathParameters extends PathParameters | EmptyRequestComponent = EmptyRequestComponent, TQueryParameters extends QueryParameters | EmptyRequestComponent = EmptyRequestComponent, THeader extends HttpHeaders | EmptyRequestComponent = EmptyRequestComponent> = TData | TPathParameters | THeader | TQueryParameters extends EmptyRequestComponent ? RequestWithOptionalHeaders : RequestWithData<TData> & RequestWithPathParameters<TPathParameters> & RequestWithQueryParameters<TQueryParameters> & RequestWithHeaders<THeader>;
+export type AnyRequest = RequestType<any, any, any, any>;
+export {};

package/dist/types/RequestType.js

@@ -0,0 +1 @@
+export {};

package/dist/types/RequestType.test-types.d.ts

@@ -0,0 +1 @@
+export {};