@duplojs/http 0.1.0 → 0.4.0

package/dist/client/kind.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+
+const createClientKind = utils.createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpClient");
+
+exports.createClientKind = createClientKind;

package/dist/client/kind.d.ts

@@ -0,0 +1,6 @@
+declare module "@duplojs/utils" {
+    interface ReservedKindNamespace {
+        DuplojsHttpClient: true;
+    }
+}
+export declare const createClientKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import("@duplojs/utils/string").ForbiddenString<GenericName, "@" | "/">) => import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<`@DuplojsHttpClient/${GenericName}`, GenericKindValue>>;

package/dist/client/kind.mjs

@@ -0,0 +1,7 @@
+import { createKindNamespace } from '@duplojs/utils';
+
+const createClientKind = createKindNamespace(
+// @ts-expect-error reserved kind namespace
+"DuplojsHttpClient");
+
+export { createClientKind };

package/dist/client/promiseRequest.cjs

@@ -0,0 +1,355 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var getBody = require('./getBody.cjs');
+var insertParamsInPath = require('./insertParamsInPath.cjs');
+var queryToString = require('./queryToString.cjs');
+var hooks = require('./hooks.cjs');
+var EE = require('@duplojs/utils/either');
+var SS = require('@duplojs/utils/string');
+var AA = require('@duplojs/utils/array');
+var unexpectedResponseError = require('./unexpectedResponseError.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var EE__namespace = /*#__PURE__*/_interopNamespaceDefault(EE);
+var SS__namespace = /*#__PURE__*/_interopNamespaceDefault(SS);
+var AA__namespace = /*#__PURE__*/_interopNamespaceDefault(AA);
+
+class PromiseRequest extends Promise {
+    params;
+    hooks = {};
+    constructor(params) {
+        super((resolve) => void EE__namespace
+            .rightAsyncPipe(Promise.resolve(params), (params) => hooks.launchRequestHook(params.hooks.request, this.hooks.request ?? [], params), PromiseRequest.fetch, (response) => hooks.launchResponseHook(params.hooks.response, this.hooks.response ?? [], response), async (response) => {
+            if (params.disabledPredicateMode === false && response.predicted === false) {
+                await hooks.launchNotPredictedHook(params.hooks.notPredictedResponse, this.hooks.notPredictedResponse ?? [], response);
+                return EE__namespace.right("response", response);
+            }
+            if (SS__namespace.startsWith(response.code, "1")) {
+                await hooks.launchResponseTypeHook(params.hooks.informationalResponseType, this.hooks.informationalResponseType ?? [], response);
+            }
+            else if (SS__namespace.startsWith(response.code, "2")) {
+                await hooks.launchResponseTypeHook(params.hooks.successfulResponseType, this.hooks.successfulResponseType ?? [], response);
+                await hooks.launchExpectedResponseHook(params.hooks.expectedResponse, this.hooks.expectedResponse ?? [], response);
+            }
+            else if (SS__namespace.startsWith(response.code, "3")) {
+                await hooks.launchResponseTypeHook(params.hooks.redirectionResponseType, this.hooks.redirectionResponseType ?? [], response);
+            }
+            else if (SS__namespace.startsWith(response.code, "4")) {
+                await hooks.launchResponseTypeHook(params.hooks.clientErrorResponseType, this.hooks.clientErrorResponseType ?? [], response);
+                await hooks.launchExpectedResponseHook(params.hooks.expectedResponse, this.hooks.expectedResponse ?? [], response);
+            }
+            else if (SS__namespace.startsWith(response.code, "5")) {
+                await hooks.launchResponseTypeHook(params.hooks.serverErrorResponseType, this.hooks.serverErrorResponseType ?? [], response);
+            }
+            if (response.information !== undefined) {
+                await hooks.launchInformationHook(params.hooks.information[response.information] ?? [], this.hooks.information?.[response.information] ?? [], response);
+            }
+            await hooks.launchCodeHook(params.hooks.code[response.code] ?? [], this.hooks.code?.[response.code] ?? [], response);
+            return EE__namespace.right("response", response);
+        })
+            .then(async (result) => {
+            if (EE__namespace.eitherFutureErrorKind.has(result)) {
+                const error = utils.unwrap(result);
+                await hooks.launchErrorHook(params.hooks.error, this.hooks.error ?? [], error, params);
+                return EE__namespace.left("request-error", {
+                    error,
+                    requestParams: params,
+                });
+            }
+            return result;
+        })
+            .then(resolve));
+        this.params = params;
+    }
+    addRequestInterceptor(callback) {
+        this.hooks.request ??= [];
+        this.hooks.request.push(callback);
+        return this;
+    }
+    addResponseInterceptor(callback) {
+        this.hooks.response ??= [];
+        this.hooks.response.push(callback);
+        return this;
+    }
+    whenNotPredictedResponse(callback) {
+        this.hooks.notPredictedResponse ??= [];
+        this.hooks.notPredictedResponse.push(callback);
+        return this;
+    }
+    whenInformation(information, callback) {
+        const formattedInformation = AA__namespace.coalescing(information);
+        formattedInformation.forEach((information) => {
+            this.hooks.information ??= {};
+            this.hooks.information[information] ??= [];
+            this.hooks.information[information].push(callback);
+        });
+        return this;
+    }
+    whenCode(code, callback) {
+        const formattedCode = AA__namespace.coalescing(code);
+        formattedCode.forEach((code) => {
+            this.hooks.code ??= {};
+            this.hooks.code[code] ??= [];
+            this.hooks.code[code].push(callback);
+        });
+        return this;
+    }
+    whenInformationalResponse(callback) {
+        this.hooks.informationalResponseType ??= [];
+        this.hooks.informationalResponseType.push(callback);
+        return this;
+    }
+    whenSuccessfulResponse(callback) {
+        this.hooks.successfulResponseType ??= [];
+        this.hooks.successfulResponseType.push(callback);
+        return this;
+    }
+    whenRedirectionResponse(callback) {
+        this.hooks.redirectionResponseType ??= [];
+        this.hooks.redirectionResponseType.push(callback);
+        return this;
+    }
+    whenClientErrorResponse(callback) {
+        this.hooks.clientErrorResponseType ??= [];
+        this.hooks.clientErrorResponseType.push(callback);
+        return this;
+    }
+    whenServerErrorResponse(callback) {
+        this.hooks.serverErrorResponseType ??= [];
+        this.hooks.serverErrorResponseType.push(callback);
+        return this;
+    }
+    whenExpectedResponse(callback) {
+        this.hooks.expectedResponse ??= [];
+        this.hooks.expectedResponse.push(callback);
+        return this;
+    }
+    whenError(callback) {
+        this.hooks.error ??= [];
+        this.hooks.error.push(callback);
+        return this;
+    }
+    iWantInformation(information) {
+        const formattedInformation = AA__namespace.coalescing(information);
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (response.information !== undefined
+                && AA__namespace.includes(formattedInformation, response.information)) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantCode(code) {
+        const formattedCode = AA__namespace.coalescing(code);
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (AA__namespace.includes(formattedCode, response.code)) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantInformationalResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "1")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantSuccessfulResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "2")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantRedirectionResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "3")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantClientErrorResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "4")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantServerErrorResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "5")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantExpectedResponse() {
+        return this.then(EE__namespace.whenIsRight((response) => {
+            if (SS__namespace.startsWith(response.code, "2") || SS__namespace.startsWith(response.code, "4")) {
+                return EE__namespace.right("response", response);
+            }
+            return EE__namespace.left("unexpect-response", response);
+        }));
+    }
+    iWantInformationOrThrow(information) {
+        return this
+            .iWantInformation(information)
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedInformationResponseError(information, utils.unwrap(maybeResponse));
+        });
+    }
+    iWantCodeOrThrow(code) {
+        return this
+            .iWantCode(code)
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedCodeResponseError(code, utils.unwrap(maybeResponse));
+        });
+    }
+    iWantInformationalResponseOrThrow() {
+        return this
+            .iWantInformationalResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("informational", utils.unwrap(maybeResponse));
+        });
+    }
+    iWantSuccessfulResponseOrThrow() {
+        return this
+            .iWantSuccessfulResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("successful", utils.unwrap(maybeResponse));
+        });
+    }
+    iWantRedirectionResponseOrThrow() {
+        return this
+            .iWantRedirectionResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("redirection", utils.unwrap(maybeResponse));
+        });
+    }
+    iWantClientErrorResponseOrThrow() {
+        return this
+            .iWantClientErrorResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("clientError", utils.unwrap(maybeResponse));
+        });
+    }
+    iWantServerErrorResponseOrThrow() {
+        return this
+            .iWantServerErrorResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseTypeError("informational", utils.unwrap(maybeResponse));
+        });
+    }
+    iWantExpectedResponseOrThrow() {
+        return this
+            .iWantExpectedResponse()
+            .then((maybeResponse) => {
+            if (EE__namespace.isRight(maybeResponse)) {
+                return utils.unwrap(maybeResponse);
+            }
+            throw new unexpectedResponseError.UnexpectedResponseError(utils.unwrap(maybeResponse));
+        });
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    static fetch(requestParams) {
+        const path = insertParamsInPath.insertParamsInPath(requestParams.path, requestParams.params);
+        const query = queryToString.queryToString(requestParams.query);
+        const url = query
+            ? `${path}?${query}`
+            : path;
+        const headers = { ...requestParams.headers };
+        let body = requestParams.body;
+        if (body) {
+            if (!headers["content-type"]) {
+                if (typeof body === "string") {
+                    headers["content-type"] = "text/plain; charset=utf-8";
+                    body = body.toString();
+                }
+                else if ((body
+                    && typeof body === "object"
+                    && body?.constructor?.name === "Object")
+                    || (body instanceof Array
+                        && body?.constructor?.name === "Array")
+                    || body === null
+                    || typeof body === "boolean"
+                    || typeof body === "number") {
+                    headers["content-type"] = "application/json; charset=utf-8";
+                    body = JSON.stringify(body);
+                }
+            }
+        }
+        return fetch(`${requestParams.baseUrl}${url}`, {
+            ...requestParams.initParams,
+            headers: headers,
+            method: requestParams.method,
+            body: body,
+        })
+            .then((response) => getBody.getBody(response)
+            .then((body) => EE__namespace.right("response", {
+            body,
+            information: response.headers.get(requestParams.informationHeaderKey) || undefined,
+            code: response.status.toString(),
+            ok: (response.status < 500)
+                ? response.ok
+                : null,
+            headers: response.headers,
+            type: response.type,
+            url: response.url,
+            redirected: response.redirected,
+            raw: response,
+            requestParams,
+            predicted: response.headers.get(requestParams.predictedHeaderKey) !== null,
+        })))
+            .catch((error) => EE__namespace.left("request-error", {
+            error,
+            requestParams,
+        }));
+    }
+}
+
+exports.PromiseRequest = PromiseRequest;

package/dist/client/promiseRequest.d.ts

@@ -0,0 +1,98 @@
+import { type NeverCoalescing, type MaybePromise } from "@duplojs/utils";
+import { type Hooks, type ErrorHook, type NotPredictedResponseHook } from "./hooks";
+import * as EE from "@duplojs/utils/either";
+import { type RequestErrorContent } from "./unexpectedResponseError";
+import { type NotPredictedClientResponse, type ClientRequestParams, type ClientResponse } from "./types";
+type MaybeResponse<GenericClientResponse extends ClientResponse = ClientResponse> = (EE.EitherRight<"response", GenericClientResponse> | EE.EitherLeft<"request-error", RequestErrorContent>);
+type MaybeWantedResponse<GenericWantedClientResponse extends ClientResponse = ClientResponse, GenericUnexpectClientResponse extends ClientResponse = ClientResponse> = (EE.EitherRight<"response", GenericWantedClientResponse> | EE.EitherLeft<"unexpect-response", GenericUnexpectClientResponse> | EE.EitherLeft<"request-error", RequestErrorContent>);
+export interface PromiseRequestParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientRequestParams<GenericHookParams> {
+    baseUrl: string;
+    hooks: Hooks;
+    informationHeaderKey: string;
+    predictedHeaderKey: string;
+    disabledPredicateMode: boolean;
+}
+export declare class PromiseRequest<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams, GenericClientResponse extends ClientResponse = ClientResponse> extends Promise<MaybeResponse<GenericClientResponse | NotPredictedClientResponse<GenericPromiseRequestParams>>> {
+    params: PromiseRequestParams;
+    readonly hooks: Partial<Hooks>;
+    constructor(params: PromiseRequestParams);
+    addRequestInterceptor(callback: (requestParams: GenericPromiseRequestParams) => MaybePromise<GenericPromiseRequestParams>): this;
+    addResponseInterceptor(callback: (response: GenericClientResponse) => MaybePromise<GenericClientResponse>): this;
+    whenNotPredictedResponse(callback: NotPredictedResponseHook<GenericPromiseRequestParams>): this;
+    whenInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
+        information: GenericInformation;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenCode<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
+        code: GenericCode;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenInformationalResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `1${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenSuccessfulResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenRedirectionResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `3${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenClientErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenServerErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `5${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenExpectedResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}` | `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    whenError(callback: ErrorHook<GenericPromiseRequestParams>): this;
+    iWantInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>, GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
+        information: GenericInformation;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantCode<GenericCode extends GenericClientResponse["code"], GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
+        code: GenericCode;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>>(code: GenericCode | GenericCode[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantInformationalResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `1${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantSuccessfulResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantRedirectionResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `3${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantClientErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantServerErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `5${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantExpectedResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}` | `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    iWantInformationOrThrow<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
+        information: GenericInformation;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantCodeOrThrow<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
+        code: GenericCode;
+    } : never>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantInformationalResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `1${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantSuccessfulResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantRedirectionResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `3${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantClientErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantServerErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `5${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    iWantExpectedResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
+        code: `2${number}` | `4${number}`;
+    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    static get [Symbol.species](): PromiseConstructor;
+    static fetch<GenericPromiseRequestParams extends PromiseRequestParams>(requestParams: GenericPromiseRequestParams): Promise<MaybeResponse>;
+}
+export {};