@koine/api 2.0.0-beta.7 → 2.0.0-beta.71

package/index.cjs.d.ts

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

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@koine/utils');
+
+class ApiError extends Error{constructor(e){super(`Request failed with ${e.status} ${e.msg}`),this.name="ApiError",Object.assign(this,e);}}let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});let createApiResultFail=(e={},t,r)=>({fail:!0,data:e,msg:t||"",status:r||404});let s=["get","post","put","patch","delete"];let createApi=(o,a,l)=>{let{headers:i={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:h}=l||{};return s.reduce((s,l)=>(s[l]=async(s,m)=>{let $,d;let{request:g=n,headers:w=i,timeout:E=c,processReq:y,processRes:A=f,processErr:b=h,throwErr:k=p}=m||{},{params:x,json:R,query:N}=m||{},O=`${a}/${s+"".replace(/^\/*/,"")}`,j={method:l.toUpperCase(),...g,headers:{"content-type":"application/json",...w}};if(u){let e=u(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(y){let e=y(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(utils.isFullObject(x))for(let e in x)O=O.replace(`{${e}}`,x[e].toString());let q=Number(E);R&&(j.body=JSON.stringify(R)),q>0&&($=new AbortController,d=setTimeout(()=>$.abort(),q),j.signal=$.signal),N&&(O+=utils.buildUrlQueryString(N));let C=null,v=null,S="";try{C=await fetch(O,j);}catch(e){S=utils.errorToString(e);}if(d&&clearTimeout(d),C)try{v=A?await A(C,m||{}):await C.json();}catch(e){S=utils.errorToString(e);}if(null===v&&(v=b?await b(S,m||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&v?.fail)throw v;if("development"===process.env.NODE_ENV){let e=`${v?.status}: api[${o}] ${l.toUpperCase()} ${O}`;v?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return v},s),{})};
+
+exports.ApiError = ApiError;
+exports.createApi = createApi;
+exports.createApiResultFail = createApiResultFail;
+exports.createApiResultOk = createApiResultOk;

package/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.d.ts

@@ -1,4 +1,8 @@
-export { ApiError } from "./ApiError";
-export { createApi } from "./createApi";
-export { createSwrApi } from "./createSwrApi";
-export { nextApiResponse } from "./nextApiResponse";
+import type { Api } from "./types";
+export declare class ApiError<TResponseFail extends Api.ResponseFail = unknown> extends Error {
+    constructor(result: Api.ResultFail<TResponseFail>);
+}
+export declare let createApiResultOk: <T>(data?: T, msg?: string) => Api.ResultOk<T>;
+export declare let createApiResultFail: <T>(data?: T, msg?: string, status?: number) => Api.ResultFail<T>;
+export declare let createApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions) => Api.Client<TEndpoints>;
+export type { Api } from "./types";

package/index.esm.js

@@ -0,0 +1,5 @@
+import { isFullObject, buildUrlQueryString, errorToString } from '@koine/utils';
+
+class ApiError extends Error{constructor(e){super(`Request failed with ${e.status} ${e.msg}`),this.name="ApiError",Object.assign(this,e);}}let createApiResultOk=(e={},t)=>({ok:!0,fail:!1,data:e,msg:t||"",status:200});let createApiResultFail=(e={},t,r)=>({fail:!0,data:e,msg:t||"",status:r||404});let s=["get","post","put","patch","delete"];let createApi=(o,a,l)=>{let{headers:i={},request:n={},throwErr:p,timeout:c=1e4,processReq:u,processRes:f,processErr:h}=l||{};return s.reduce((s,l)=>(s[l]=async(s,m)=>{let $,d;let{request:g=n,headers:w=i,timeout:E=c,processReq:y,processRes:A=f,processErr:b=h,throwErr:k=p}=m||{},{params:x,json:R,query:N}=m||{},O=`${a}/${s+"".replace(/^\/*/,"")}`,j={method:l.toUpperCase(),...g,headers:{"content-type":"application/json",...w}};if(u){let e=u(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(y){let e=y(l,O,N,R,x,j);O=e[0],N=e[1],R=e[2],x=e[3],j=e[4];}if(isFullObject(x))for(let e in x)O=O.replace(`{${e}}`,x[e].toString());let q=Number(E);R&&(j.body=JSON.stringify(R)),q>0&&($=new AbortController,d=setTimeout(()=>$.abort(),q),j.signal=$.signal),N&&(O+=buildUrlQueryString(N));let C=null,v=null,S="";try{C=await fetch(O,j);}catch(e){S=errorToString(e);}if(d&&clearTimeout(d),C)try{v=A?await A(C,m||{}):await C.json();}catch(e){S=errorToString(e);}if(null===v&&(v=b?await b(S,m||{}):{data:null,msg:S,status:100,fail:!0,ok:!1}),k&&v?.fail)throw v;if("development"===process.env.NODE_ENV){let e=`${v?.status}: api[${o}] ${l.toUpperCase()} ${O}`;v?.ok?console.info(`🟢 ${e}`):console.info(`🔴 ${e}`);}return v},s),{})};
+
+export { ApiError, createApi, createApiResultFail, createApiResultOk };

package/next.cjs.d.ts

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

package/next.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./next.cjs.js').default;

package/next.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('next/server');
+var index = require('./index.cjs.js');
+require('@koine/utils');
+
+let nextApiResponse={ok:(o,t)=>server.NextResponse.json(index.createApiResultOk(o,t)),fail:(s,t,n)=>server.NextResponse.json(index.createApiResultFail(s,t,n))};let nextApiResponse12=e=>({ok(o,t){e.status(200).json(index.createApiResultOk(o,t));},fail(s,t,n){e.status(n||404).json(index.createApiResultFail(s,t,n));}});
+
+exports.nextApiResponse = nextApiResponse;
+exports.nextApiResponse12 = nextApiResponse12;

package/next.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './next.cjs.js';
+export { _default as default } from './next.cjs.default.js';

package/next.d.ts

@@ -0,0 +1,10 @@
+import type { NextApiResponse } from "next";
+import { NextResponse } from "next/server";
+export declare let nextApiResponse: {
+    ok<T>(data: T, msg?: string): NextResponse<import("./types").Api.ResultOk<T>>;
+    fail<T_1>(data: T_1, msg?: string, status?: number): NextResponse<import("./types").Api.ResultFail<T_1>>;
+};
+export declare let nextApiResponse12: (nextRes: NextApiResponse) => {
+    ok<T>(data: T, msg?: string): void;
+    fail<T_1>(data: T_1, msg?: string, status?: number): void;
+};

package/next.esm.js

@@ -0,0 +1,7 @@
+import { NextResponse } from 'next/server';
+import { createApiResultOk, createApiResultFail } from './index.esm.js';
+import '@koine/utils';
+
+let nextApiResponse={ok:(o,t)=>NextResponse.json(createApiResultOk(o,t)),fail:(s,t,n)=>NextResponse.json(createApiResultFail(s,t,n))};let nextApiResponse12=e=>({ok(o,t){e.status(200).json(createApiResultOk(o,t));},fail(s,t,n){e.status(n||404).json(createApiResultFail(s,t,n));}});
+
+export { nextApiResponse, nextApiResponse12 };

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@koine/api",
   "sideEffects": false,
+  "dependencies": {
+    "@koine/utils": "2.0.0-beta.71"
+  },
+  "peerDependencies": {
+    "next": "^14.0.4",
+    "swr": "^2.2.4"
+  },
   "peerDependenciesMeta": {
     "next": {
       "optional": true
@@ -9,12 +16,30 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "@koine/utils": "2.0.0-beta.7"
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    },
+    "./next": {
+      "module": "./next.esm.js",
+      "import": "./next.cjs.mjs",
+      "default": "./next.cjs.js"
+    },
+    "./swr-mutation": {
+      "module": "./swr-mutation.esm.js",
+      "import": "./swr-mutation.cjs.mjs",
+      "default": "./swr-mutation.cjs.js"
+    },
+    "./swr": {
+      "module": "./swr.esm.js",
+      "import": "./swr.cjs.mjs",
+      "default": "./swr.cjs.js"
+    }
   },
-  "module": "./index.mjs",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "peerDependencies": {},
-  "version": "2.0.0-beta.7"
-}
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "version": "2.0.0-beta.71"
+}

package/swr-mutation.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./swr-mutation";

package/swr-mutation.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./swr-mutation.cjs.js').default;

package/swr-mutation.cjs.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var r = require('swr/mutation');
+var index = require('./index.cjs.js');
+var swr = require('./swr.cjs.js');
+require('@koine/utils');
+require('swr');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var r__default = /*#__PURE__*/_interopDefaultLegacy(r);
+
+let a=(t,e)=>(a,o,i)=>r__default["default"](o?[a,o]:a,async(r,a)=>{let o=Array.isArray(r)?r[0]:r,i=Array.isArray(r)?r[1]:{},{ok:p,data:s}=await t[e](o,{...i,...a.arg||{},throwErr:!0});return s},i);let createSwrMutationApi=(...r)=>{let o=index.createApi(...r);return o.use=swr.createUseApi(o),["post","put","patch","delete"].forEach(r=>{o[`use${r.charAt(0).toUpperCase()+r.slice(1)}`]=a(o,r);}),o};
+
+exports.createSwrMutationApi = createSwrMutationApi;

package/swr-mutation.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './swr-mutation.cjs.js';
+export { _default as default } from './swr-mutation.cjs.default.js';

package/swr-mutation.d.ts

@@ -0,0 +1,17 @@
+import { type SWRMutationConfiguration, type SWRMutationResponse } from "swr/mutation";
+import { createUseApi } from "./swr";
+import type { Api } from "./types";
+type MutationRequestMethod = Exclude<Api.RequestMethod, "get">;
+type MutationHookName = Exclude<keyof Api.HooksMapsByName, "use">;
+type KoineApiMethodHookSWR<THookName extends MutationHookName, TEndpoints extends Api.Endpoints> = <TEndpoint extends Api.EndpointUrl<TEndpoints>, TMethod extends MutationRequestMethod = Api.HooksMapsByName[THookName]>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>, config?: SWRMutationConfiguration<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>) => SWRMutationResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, Api.EndpointResponseFail<TEndpoints, TEndpoint, TMethod>, TEndpoint, Api.EndpointOptions<TEndpoints, TEndpoint, TMethod>>;
+export declare let createSwrMutationApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
+    usePost: KoineApiMethodHookSWR<"usePost", TEndpoints>;
+    usePut: KoineApiMethodHookSWR<"usePut", TEndpoints>;
+    usePatch: KoineApiMethodHookSWR<"usePatch", TEndpoints>;
+    useDelete: KoineApiMethodHookSWR<"useDelete", TEndpoints>;
+} & {
+    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: (Partial<import("swr/_internal").PublicConfiguration<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, import("swr/_internal").BareFetcher<any>>> & {
+        when?: boolean | (() => boolean) | undefined;
+    }) | undefined) => import("swr/_internal").SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
+};
+export {};

package/swr-mutation.esm.js

@@ -0,0 +1,9 @@
+import r from 'swr/mutation';
+import { createApi } from './index.esm.js';
+import { createUseApi } from './swr.esm.js';
+import '@koine/utils';
+import 'swr';
+
+let a=(t,e)=>(a,o,i)=>r(o?[a,o]:a,async(r,a)=>{let o=Array.isArray(r)?r[0]:r,i=Array.isArray(r)?r[1]:{},{ok:p,data:s}=await t[e](o,{...i,...a.arg||{},throwErr:!0});return s},i);let createSwrMutationApi=(...r)=>{let o=createApi(...r);return o.use=createUseApi(o),["post","put","patch","delete"].forEach(r=>{o[`use${r.charAt(0).toUpperCase()+r.slice(1)}`]=a(o,r);}),o};
+
+export { createSwrMutationApi };

package/swr.cjs.d.ts

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

package/swr.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./swr.cjs.js').default;

package/swr.cjs.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var e = require('swr');
+var utils = require('@koine/utils');
+var index = require('./index.cjs.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var e__default = /*#__PURE__*/_interopDefaultLegacy(e);
+
+let createUseApi=t=>(i,n,o)=>{let l=async()=>{let{data:e}=await t.get(i,{...n||{},throwErr:!0});return e};return e__default["default"](o?.when===!1||utils.isFunction(o?.when)&&o?.when()===!1?null:n?[i,n]:[i],l,o)};let createSwrApi=(...e)=>{let r=index.createApi(...e);return r.use=createUseApi(r),r};
+
+exports.createSwrApi = createSwrApi;
+exports.createUseApi = createUseApi;

package/swr.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './swr.cjs.js';
+export { _default as default } from './swr.cjs.default.js';

package/swr.d.ts

@@ -0,0 +1,10 @@
+import { type BareFetcher, type SWRConfiguration, type SWRResponse } from "swr";
+import type { Api } from "./types";
+type SWRConfigurationExtended<Data = any, Error = any, Fn extends BareFetcher<any> = BareFetcher<any>> = SWRConfiguration<Data, Error, Fn> & {
+    when?: boolean | (() => boolean);
+};
+export declare let createUseApi: <TEndpoints extends Api.Endpoints>(api: Api.Client<TEndpoints>) => <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
+export declare let createSwrApi: <TEndpoints extends Api.Endpoints>(apiName: string, baseUrl: string, options?: Api.ClientOptions | undefined) => Api.Client<TEndpoints> & {
+    use: <TEndpoint extends Extract<keyof TEndpoints, string>>(endpoint: TEndpoint, options?: Api.EndpointOptions<TEndpoints, TEndpoint, "get"> | undefined, config?: SWRConfigurationExtended<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, BareFetcher<any>> | undefined) => SWRResponse<Api.EndpointResponseOk<TEndpoints, TEndpoint, "get">, Api.EndpointResponseFail<TEndpoints, TEndpoint, "get">, any>;
+};
+export {};

package/swr.esm.js

@@ -0,0 +1,7 @@
+import e from 'swr';
+import { isFunction } from '@koine/utils';
+import { createApi } from './index.esm.js';
+
+let createUseApi=t=>(i,n,o)=>{let l=async()=>{let{data:e}=await t.get(i,{...n||{},throwErr:!0});return e};return e(o?.when===!1||isFunction(o?.when)&&o?.when()===!1?null:n?[i,n]:[i],l,o)};let createSwrApi=(...e)=>{let r=createApi(...e);return r.use=createUseApi(r),r};
+
+export { createSwrApi, createUseApi };

package/types.d.ts

@@ -0,0 +1,126 @@
+type _Response = Response;
+type ExtractEndpointParams<T extends string> = string extends T ? Record<string, string> : T extends `${infer _Start}{${infer Param}}${infer Rest}` ? {
+    [k in Param | keyof ExtractEndpointParams<Rest>]: string | number;
+} : T extends `${infer _Start}{${infer Param}}` ? {
+    [k in Param]: string | number;
+} : never;
+export declare namespace Api {
+    export type ClientOptions = {
+        headers?: RequestInit["headers"];
+        request?: Omit<RequestInit, "body" | "headers" | "method">;
+        throwErr?: boolean;
+        timeout?: number | false | null;
+        processReq?: RequestProcessor;
+        processRes?: ResponseProcessorRes;
+        processErr?: ResponseProcessorErr;
+    };
+    type ClientMethod<TMethod extends RequestMethod, TEndpoints extends Endpoints> = <TEndpoint extends EndpointUrl<TEndpoints>, TOptions extends EndpointOptions<TEndpoints, TEndpoint, TMethod>, TOk extends ResponseOk = EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, TFail extends ResponseFail = EndpointResponseFail<TEndpoints, TEndpoint, TMethod>>(endpoint: TEndpoint, options?: TOptions) => Promise<EndpointResult<TEndpoints, TEndpoint, TMethod>>;
+    export type Client<TEndpoints extends Endpoints> = {
+        [TMethod in RequestMethod]: ClientMethod<TMethod, TEndpoints>;
+    };
+    export type GetDataType<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod, TDataType extends keyof DataTypes<Uppercase<TMethod>>> = TEndpoints[TEndpoint][Uppercase<TMethod>] extends DataTypes<Uppercase<TMethod>> ? TEndpoints[TEndpoint][Uppercase<TMethod>][TDataType] : never;
+    export type EndpointOptions<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod> = RequestOptions<TEndpoints, TEndpoint, TMethod, GetDataType<TEndpoints, TEndpoint, TMethod, "json">, GetDataType<TEndpoints, TEndpoint, TMethod, "query">>;
+    export type EndpointResponseOk<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod> = GetDataType<TEndpoints, TEndpoint, TMethod, "ok">;
+    export type EndpointResponseFail<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod> = GetDataType<TEndpoints, TEndpoint, TMethod, "fail">;
+    type EndpointResult<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod> = Result<EndpointResponseOk<TEndpoints, TEndpoint, TMethod>, EndpointResponseFail<TEndpoints, TEndpoint, TMethod>>;
+    export type Endpoints = Record<string, Endpoint>;
+    type Endpoint = {
+        [TMethod in Uppercase<RequestMethod>]?: DataTypes<TMethod>;
+    };
+    export type EndpointUrl<TEndpoints extends Endpoints> = Extract<keyof TEndpoints, string>;
+    type DataTypes<TMethod extends Uppercase<RequestMethod>> = {
+        json?: RequestJson;
+        query?: RequestQuery;
+        ok?: null | unknown;
+        fail?: null | unknown;
+    };
+    export type RequestMethod = "get" | "post" | "put" | "patch" | "delete";
+    type RequestJson = unknown;
+    type RequestQuery = unknown;
+    type RequestParams = unknown;
+    type RequestOptions<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod, TJson extends RequestJson, TQuery extends RequestQuery> = Omit<ClientOptions, "processReq"> & {
+        processReq?: EndpointRequestProcessor<TEndpoints, TEndpoint, TMethod>;
+        params?: ExtractEndpointParams<TEndpoint>;
+        query?: TQuery;
+        json?: TJson;
+    };
+    export type ResponseOk = unknown;
+    export type ResponseFail = unknown;
+    export type ResultOk<TResponse extends ResponseOk = ResponseOk> = {
+        status: _Response["status"];
+        msg: _Response["statusText"];
+        ok: true;
+        fail?: false;
+        data: TResponse;
+    };
+    export type ResultFail<TResponse extends ResponseFail = ResponseFail> = {
+        status: _Response["status"];
+        msg: Error["message"] | _Response["statusText"];
+        ok?: false;
+        fail: true;
+        data: TResponse;
+    };
+    export type Result<TResponseOk extends ResponseOk, TResponseFail extends ResponseFail> = {
+        status: _Response["status"];
+        msg: _Response["statusText"];
+        ok: true;
+        fail?: false;
+        data: TResponseOk;
+    } | {
+        status: _Response["status"];
+        msg: Error["message"] | _Response["statusText"];
+        ok?: false;
+        fail: true;
+        data: TResponseFail;
+    };
+    export type RequestProcessor = (method: RequestMethod, url: string, query: any, json: any, params: any, requestInit: RequestInit) => [
+        string,
+        RequestQuery,
+        RequestJson,
+        RequestParams,
+        RequestInit
+    ];
+    export type EndpointRequestProcessor<TEndpoints extends Endpoints, TEndpoint extends EndpointUrl<TEndpoints>, TMethod extends RequestMethod> = (method: TMethod, url: string, query: EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"], json: EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"], params: EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"], requestInit: RequestInit) => [
+        string,
+        EndpointOptions<TEndpoints, TEndpoint, TMethod>["query"],
+        EndpointOptions<TEndpoints, TEndpoint, TMethod>["json"],
+        EndpointOptions<TEndpoints, TEndpoint, TMethod>["params"],
+        RequestInit
+    ];
+    type ResponseProcessorRes = <TResponseOk extends ResponseOk = ResponseOk, TResponseFail extends ResponseFail = ResponseFail>(response: _Response, options: any) => Promise<Result<TResponseOk, TResponseFail>>;
+    type ResponseProcessorErr = <TResponseOk extends ResponseOk = ResponseOk, TResponseFail extends ResponseFail = ResponseFail>(msg: string, options: any) => Promise<Result<TResponseOk, TResponseFail>>;
+    type HooksMaps = {
+        [TMethod in RequestMethod]: `use${TMethod extends "get" ? "" : Capitalize<TMethod>}`;
+    };
+    export type HooksMapsByName = {
+        [K in keyof HooksMaps as HooksMaps[K]]: K;
+    };
+    export {};
+}
+export declare namespace Api.Generate {
+    type ResultShortcuts<TEndpoints extends Endpoints> = {
+        [TMethod in RequestMethod]: {
+            [TEndpoint in Extract<keyof TEndpoints, string>]: {
+                ok: GetDataType<TEndpoints, TEndpoint, TMethod, "ok">;
+                fail: GetDataType<TEndpoints, TEndpoint, TMethod, "fail">;
+            };
+        };
+    };
+    type ResponseShortcuts<TEndpoints extends Endpoints> = {
+        [TMethod in RequestMethod]: {
+            [TEndpoint in Extract<keyof TEndpoints, string>]: GetDataType<TEndpoints, TEndpoint, TMethod, "ok">;
+        };
+    };
+    type RequestShortcuts<TEndpoints extends Endpoints> = {
+        [TMethod in RequestMethod]: {
+            [TEndpoint in Extract<keyof TEndpoints, string>]: TMethod extends "get" ? GetDataType<TEndpoints, TEndpoint, TMethod, "query"> : GetDataType<TEndpoints, TEndpoint, TMethod, "json">;
+        };
+    };
+    type GetShortcuts<TEndpoints extends Endpoints> = {
+        [TEndpoint in Extract<keyof TEndpoints, string>]: GetDataType<TEndpoints, TEndpoint, "get", "ok">;
+    };
+    type PostShortcuts<TEndpoints extends Endpoints> = {
+        [TEndpoint in Extract<keyof TEndpoints, string>]: GetDataType<TEndpoints, TEndpoint, "post", "ok">;
+    };
+}
+export {};