eve-esi-types 2.3.5 → 3.0.1

package/README.md

@@ -1,5 +1,5 @@
 # eve-esi-types
-Extracted the main type of ESI. Used for ESI request response types.
+Extracted main types of ESI. Used for ESI request response types.
 
 ## Usage
 
@@ -8,12 +8,12 @@ Extracted the main type of ESI. Used for ESI request response types.
   + If you need to use version 1, please refer to the following link:  
     [eve-esi-types v1](https://github.com/jeffy-g/eve-esi-types/tree/version-1.x)
 
-
 > Sample code is provided -> [`v2.mjs`](./v2.mjs)
 
 ```shell
 $ node v2.mjs
 ```
+
 ## API
 
 > The following function signature allows you to benefit from `eve-esi-types`.  
@@ -22,31 +22,32 @@ $ node v2.mjs
 > and whether OAuth authentication is necessary (`auth: true`).
 
 ```ts
-// function signature
-export declare function fire<
-    M extends TESIEntryMethod,
-    EP extends keyof TESIResponseOKMap[M],
-    P2 extends IfParameterizedPath<EP, Opt>,
-    Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ESIRequestOptions>,
-    R extends InferESIResponseResult<M, EP>
->(mthd: M, endp: EP, pathParams?: P2, opt?: Opt): Promise<R>;
+// This function signature has been removed in version 3.x
+// export declare function fire<
+//     M extends TESIEntryMethod,
+//     EP extends keyof TESIResponseOKMap[M],
+//     P2 extends IfParameterizedPath<EP, Opt>,
+//     Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ESIRequestOptions>,
+//     R extends InferESIResponseResult<M, EP>
+// >(mthd: M, endp: EP, pathParams?: P2, opt?: Opt): Promise<R>;
 ```
 
 ## New Features in v2.3.0
 
 ### ESI Tagged Types
 
-> Introduced intuitive ESI requests handling using "tags" from the EVE Swagger JSON.
+> Introduced intuitive ESI request handling using "tags" from the EVE Swagger JSON.
 
-### injectESIRequestBody
+### ~~injectESIRequestBody~~
 
-> Utilized `injectESIRequestBody` to generate ESI request API objects with narrowed endpoints by accessing camel-cased "tags".
+> Utilized ~~`injectESIRequestBody`~~ to generate ESI request API objects with narrowed endpoints by accessing camel-cased "tags".
 
 ```ts
 import * as taggedApi from "eve-esi-types/lib/tagged-request-api.mjs";
 
-const esiRequest = taggedApi.injectESIRequestBody(...);
-const ret = await esiRequest.universe.get("/universe/structures/", { query: { filter: "market" }});
+// `injectESIRequestBody` has been removed in version 3.x
+// const esiRequest = taggedApi.injectESIRequestBody(...);
+// const ret = await esiRequest.universe.get("/universe/structures/", { query: { filter: "market" }});
 ```
 
 + or
@@ -58,6 +59,45 @@ import { esi } from "eve-esi-types/lib/tagged-request-api.mjs";
 const ret = await esi.universe.get("/universe/structures/", { query: { filter: "market" }});
 ```
 
+## New Features in v3.0.0
+
+### `TESIRequestFunctionSignature` has been renamed to `TESIRequestFunctionSignature2` and the generic parameters have been changed.
+
+> `RealEP` and `EP` help maintain endpoint inference.  
+> With `RealEP`, TypeScript inference partially lists the possible endpoints while allowing for path parameter replacement.
+
+
+```ts
+type TESIRequestFunctionSignature2<ActualOpt> = <
+  M extends TESIEntryMethod,
+  RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M],
+  EP extends InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]> extends never ? RealEP : InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]>,
+  // If RealEP points to an endpoint origin (not a replaced endpoint), the path parameter is required
+  PathParams extends RealEP extends EP ? IfNeedPathParams<EP> : TPathParamsNever,
+  Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt & PathParams>,
+  R extends InferESIResponseResult<M, EP>
+>(method: M, endpoint: RealEP, options?: Opt) => Promise<R>;
+```
+
++ NOTE: Accordingly, the generic parameters for other request function signatures have also been changed, with "2" appended to their names.
+
+  + `IESIRequestFunction` -> `IESIRequestFunction2`
+  + `TESIRequestFunctionMethods` -> `TESIRequestFunctionMethods2`
+  + `TESIRequestFunctionEachMethod` -> `TESIRequestFunctionEachMethod2`
+  + etc. Also, `v2/esi-tagged-types.d.ts` too
+
+### decoreateESIRequestBody
+
+> Utilized `decoreateESIRequestBody` to generate ESI request API objects with narrowed endpoints by accessing camel-cased "tags".
+
+```ts
+import * as taggedApi from "eve-esi-types/lib/tagged-request-api.mjs";
+
+const esiRequest = taggedApi.decoreateESIRequestBody(...);
+const ret = await esiRequest.universe.get("/universe/structures/", { query: { filter: "market" }});
+```
+
+
 ## References
 
-- [`ESI Types Utility Definitions`](./esi-types-util.md)
+- [`ESI Types Utility Definitions`](./esi-types-util3.md)

package/esi-types-util3.md

@@ -0,0 +1,186 @@
+<!--!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+-->
+
+# ESI Types Utility Summary
+
+## TESICachedSeconds
+`TESICachedSeconds` is a type to get the cached seconds for a specific HTTP method.
+
+```typescript
+type TESICachedSeconds<
+  Method extends TESIEntryMethod, AsEndpoint = void
+> = {
+  [M in TESIEntryMethod]: {
+    [EP in keyof TESIResponseOKMap[M]]: TESIResponseOKMap[M][EP]["cachedSeconds"] extends number
+      ? AsEndpoint extends void
+        ? TESIResponseOKMap[M][EP]["cachedSeconds"]: EP
+      : never
+  }[keyof TESIResponseOKMap[M]];
+}[Method];
+```
+
+## TPathParamsNever
+`TPathParamsNever` is a type used when path parameters are not required.
+
+```typescript
+type TPathParamsNever = { pathParams?: never };
+```
+
+## TESIRequestFunctionSignature2
+`TESIRequestFunctionSignature2` is a type that defines the signature of an ESI request function.
+
+```typescript
+type TESIRequestFunctionSignature2<ActualOpt> = <
+  M extends TESIEntryMethod,
+  RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M],
+  EP extends InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]> extends never ? RealEP: InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]>,
+  PathParams extends RealEP extends EP ? IfNeedPathParams<EP>: TPathParamsNever,
+  Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt & PathParams>,
+  R extends InferESIResponseResult<M, EP>
+>(method: M, endpoint: RealEP, options?: Opt) => Promise<R>;
+```
+
+## TESIRequestFunctionEachMethod2
+`TESIRequestFunctionEachMethod2` is a type that defines functions to make ESI requests for a specific HTTP method.
+
+```typescript
+type TESIRequestFunctionEachMethod2<M extends TESIEntryMethod, ActualOpt = {}> = <
+  RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M],
+  EP extends InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]> extends never ? RealEP: InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]>,
+  PathParams extends RealEP extends EP ? IfNeedPathParams<EP>: TPathParamsNever,
+  Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt & PathParams>,
+  R extends InferESIResponseResult<M, EP>
+>(endpoint: RealEP, options?: Opt) => Promise<R>;
+```
+
+## ReplacePathParams
+`ReplacePathParams` is a type that replaces path parameters in a string with numbers.
+
+```typescript
+type ReplacePathParams<T extends string> = T extends `${infer Start}{${infer Param}}${infer End}`
+  ? `${Start}${number}${ReplacePathParams<End>}` : T;
+```
+
+## IfNeedPathParams
+`IfNeedPathParams` is a type that determines if the endpoint requires path parameters.
+
+```typescript
+type IfNeedPathParams<EP> = IfParameterizedPath<EP> extends never ? TPathParamsNever :
+  EP extends ReplacePathParams<EP> ? TPathParamsNever : { pathParams: IfParameterizedPath<EP> };
+```
+
+## InferEndpointOrigin
+`InferEndpointOrigin` is a type that infers the original endpoint path from a real endpoint path.
+
+```typescript
+type InferEndpointOrigin<RealEP extends unknown, Endpoints> = {
+  [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
+    ? EP : never;
+}[Endpoints];
+```
+
+## IfParameterizedPath
+`IfParameterizedPath` is a type that determines the required number of replacements if the endpoint is a parameterized path.
+
+```typescript
+type IfParameterizedPath<EP, Opt = never> = EP extends `${string}/{${string}}${string}`
+  ? PickPathParameters<EP> extends never
+    ? Opt : InferKeysLen<PickPathParameters<EP>> extends 1
+      ? number : [number, number]
+    : Opt;
+```
+
+## IdentifyParameters
+`IdentifyParameters` is a type that identifies the required parameters for a given entry type.
+
+```typescript
+type IdentifyParameters<
+  Entry, Opt,
+  Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+> = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
+```
+
+## InferESIResponseResult
+`InferESIResponseResult` is a type that infers the result type of an ESI response based on the method and endpoint.
+
+```typescript
+type InferESIResponseResult<
+  M extends TESIEntryMethod,
+  EP extends keyof TESIResponseOKMap[M]
+> = TESIResponseOKMap[M][EP] extends { result: infer U } ? U : never;
+```
+
+## NoContentResponse
+`NoContentResponse` is a type that represents a response with no content (HTTP status 204).
+
+```typescript
+type NoContentResponse = { /* status: 204 */ };
+```
+
+## TESIEntryMethod
+`TESIEntryMethod` is a type that represents the HTTP methods supported by ESI.
+
+```typescript
+type TESIEntryMethod = keyof TESIResponseOKMap;
+```
+
+## TEndPointGet
+`TEndPointGet` is a type that represents the endpoints for the "get" method.
+
+```typescript
+type TEndPointGet = keyof TESIResponseOKMap["get"];
+```
+
+## TEndPointPost
+`TEndPointPost` is a type that represents the endpoints for the "post" method.
+
+```typescript
+type TEndPointPost = keyof TESIResponseOKMap["post"];
+```
+
+## TEndPointPut
+`TEndPointPut` is a type that represents the endpoints for the "put" method.
+
+```typescript
+type TEndPointPut = keyof TESIResponseOKMap["put"];
+```
+
+## TEndPointDelete
+`TEndPointDelete` is a type that represents the endpoints for the "delete" method.
+
+```typescript
+type TEndPointDelete = keyof TESIResponseOKMap["delete"];
+```
+
+## TESIResponseGetEntry
+`TESIResponseGetEntry` is a type that represents the entry details for the "get" method.
+
+```typescript
+type TESIResponseGetEntry<K extends TEndPointGet> = TESIResponseOKMap["get"][K];
+```
+
+## TESIResponsePutEntry
+`TESIResponsePutEntry` is a type that represents the entry details for the "put" method.
+
+```typescript
+type TESIResponsePutEntry<K extends TEndPointPut> = TESIResponseOKMap["put"][K];
+```
+
+## TESIResponsePostEntry
+`TESIResponsePostEntry` is a type that represents the entry details for the "post" method.
+
+```typescript
+type TESIResponsePostEntry<K extends TEndPointPost> = TESIResponseOKMap["post"][K];
+```
+
+## TESIResponseDeleteEntry
+`TESIResponseDeleteEntry` is a type that represents the entry details for the "delete" method.
+
+```typescript
+type TESIResponseDeleteEntry<K extends TEndPointDelete> = TESIResponseOKMap["delete"][K];
+```

package/lib/request-api.d.mts

@@ -6,22 +6,21 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
 import * as util from "./rq-util.mjs";
-import type { IESIRequestFunction } from "../v2";
+import type { IESIRequestFunction2 } from "../v2";
 /**
- * @typedef {import("../v2").IESIRequestFunction<util.ESIRequestOptions>} IESIRequestFunction
- * @typedef {import("../v2").TESIRequestFunctionMethods<util.ESIRequestOptions>} TESIRequestFunctionMethods
+ * @typedef {import("../v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {import("../v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
  */
 /** #### Sample of `TESIRequestFunctionSignature`
  *
  * + This is a minimal implementation using `TESIRequestFunctionSignature`.
  *   If the response contains "page", only the first page can be retrieved.
  *
- * @type {IESIRequestFunction}
+ * @type {IESIRequestFunction2}
  * @param method - The HTTP method to use for the request
  * @param endpoint - The Path of the ESI endpoint to send the request to
- * @param pathParams - An object of parameters to include in the request
  * @param options - An object of options to include in the request
  * @returns A Promise object containing the response data
  * @throws {util.ESIRequestError}
  */
-export declare const request: IESIRequestFunction<util.ESIRequestOptions>;
+export declare const request2: IESIRequestFunction2<util.ESIRequestOptions>;

package/lib/request-api.mjs

@@ -17,8 +17,8 @@ import * as util from "./rq-util.mjs";
 const log = util.getUniversalLogger("[request-api]: ");
 const DEBUG = util.isDebug();
 /**
- * @typedef {import("../v2").IESIRequestFunction<util.ESIRequestOptions>} IESIRequestFunction
- * @typedef {import("../v2").TESIRequestFunctionMethods<util.ESIRequestOptions>} TESIRequestFunctionMethods
+ * @typedef {import("../v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {import("../v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
  */
 // - - - - - - - - - - - - - - - - - - - -
 //            main functions
@@ -28,23 +28,24 @@ const DEBUG = util.isDebug();
  * + This is a minimal implementation using `TESIRequestFunctionSignature`.
  *   If the response contains "page", only the first page can be retrieved.
  *
- * @type {IESIRequestFunction}
+ * @type {IESIRequestFunction2}
  * @param method - The HTTP method to use for the request
  * @param endpoint - The Path of the ESI endpoint to send the request to
- * @param pathParams - An object of parameters to include in the request
  * @param options - An object of options to include in the request
  * @returns A Promise object containing the response data
  * @throws {util.ESIRequestError}
  */
-export const request = /** @type {IESIRequestFunction} */ (async (method, endpoint, pathParams, opt) => {
-    if (typeof pathParams === "number") {
-        pathParams = /** @type {typeof pathParams} */ ([pathParams]);
+export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endpoint, opt) => {
+    /** @type {number[]=} */
+    let pathParams;
+    if (typeof opt?.pathParams === "number" || Array.isArray(opt?.pathParams)) {
+        pathParams = /** @type {number[]} */ (Array.isArray(opt.pathParams) ? opt.pathParams : [opt.pathParams]);
     }
     if (Array.isArray(pathParams)) {
         endpoint = util.replaceCbt(endpoint, pathParams);
     }
     // When only options are provided
-    const actualOpt = /** @type {NonNullable<typeof opt>} */ (opt || pathParams || {});
+    const actualOpt = /** @type {NonNullable<typeof opt>} */ (opt || {});
     const { rqopt, qss } = util.initOptions(method, actualOpt);
     const endpointUrl = util.curl(endpoint);
     const up = new URLSearchParams(qss);
@@ -65,10 +66,11 @@ export const request = /** @type {IESIRequestFunction} */ (async (method, endpoi
     }
 });
 //
-// implements rest methods of `request` (IESIRequestFunction)
+// implements rest methods of `request` (IESIRequestFunction2)
 //
 /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-    request[method] = /** @type {TESIRequestFunctionEachMethod<typeof method>} */ (function (endpoint, params, opt) {
-        return this(method, endpoint, params, opt);
+    request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method>} */ (function (endpoint, opt) {
+        // @ts-expect-error TODO: 2025/3/12
+        return this(method, endpoint, opt);
     });
 });

package/lib/rq-util.d.mts

@@ -16,7 +16,7 @@
 //  https://opensource.org/licenses/mit-license.php
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
-import type { TESIRequestFunctionMethods } from "../v2";
+import type { TESIResponseOKMap, TESIRequestFunctionMethods2, TPathParamsNever } from "../v2";
 import type { TESIErrorStats } from "./esi-error-types";
 export { isNode } from "./constants.mjs";
 /**
@@ -53,6 +53,11 @@ export type ESIRequestOptions = {
      * @date 2020/1/23
      */
     auth?: true;
+    /**
+     * @date 2025/3/13
+     * @since v3.0.0
+     */
+    pathParams?: number | number[];
 };
 /**
  * @typedef {string | number | boolean} Truthy
@@ -98,9 +103,10 @@ export declare const handleSuccessResponse: (response: Response, endpointUrl: st
  * @param {Response} res
  * @param {string} endpointUrl
  * @param {AbortController=} abortable
- * @returns {Promise<void>}
+ * @throws {ESIRequestError}
+ * @returns {Promise<never>}
  */
-export declare const handleESIError: (res: Response, endpointUrl: string, abortable?: AbortController) => Promise<void>;
+export declare const handleESIError: (res: Response, endpointUrl: string, abortable?: AbortController) => Promise<never>;
 /**
  * @param {number} stat
  * @returns {stat is 200 | 201 | 204}
@@ -175,10 +181,24 @@ export declare function getLogger(): {
     clog: (...args: any[]) => void;
     rlog: (...args: any[]) => void;
 };
+/**
+ * Need typescript v5.5 later
+ * @import * as ESI from "../v2";
+ * @typedef {ESI.TESIResponseOKMap} TESIResponseOKMap
+ * @typedef {ESI.TPathParamsNever} TPathParamsNever
+ * @typedef {ESI.IESIRequestFunction2<ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {ESI.TESIRequestFunctionMethods2<ESIRequestOptions>} TESIRequestFunctionMethods2
+ */
+/**
+ * #### Fire a request that does not require authentication.
+ *
+ * @type {import("./rq-util.d.mts").fireWithoutAuth}
+ */
+export declare function fireWithoutAuth<M extends TESIEntryMethod, RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M], EP extends InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]> extends never ? RealEP : InferEndpointOrigin<RealEP, keyof TESIResponseOKMap[M]>, PathParams extends RealEP extends EP ? IfNeedPathParams<EP> : TPathParamsNever, Opt extends IdentifyParameters<TESIResponseOKMap[M][Extract<EP, keyof TESIResponseOKMap[M]>], ESIRequestOptions & PathParams>, R extends InferESIResponseResult<M, Extract<EP, keyof TESIResponseOKMap[M]>>>(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>, method: M, endpoint: RealEP, opt?: Opt): Promise<R>;
 /**
  * #### Fire a request that does not require authentication.
  *
- * @param {TESIRequestFunctionSignature<ESIRequestOptions> | TESIRequestFunctionMethods} fn
+ * @param {TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2} fn
  * @returns {Promise<void>}
  */
-export declare function fireRequestsDoesNotRequireAuth(fn: TESIRequestFunctionSignature<ESIRequestOptions> | TESIRequestFunctionMethods<ESIRequestOptions>): Promise<void>;
+export declare function fireRequestsDoesNotRequireAuth(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>): Promise<void>;

package/lib/rq-util.mjs

@@ -101,7 +101,8 @@ export const handleSuccessResponse = async (response, endpointUrl, requestOpt, u
  * @param {Response} res
  * @param {string} endpointUrl
  * @param {AbortController=} abortable
- * @returns {Promise<void>}
+ * @throws {ESIRequestError}
+ * @returns {Promise<never>}
  */
 export const handleESIError = async (res, endpointUrl, abortable) => {
     const status = /** @type {TESIErrorStats} */ (res.status);
@@ -323,35 +324,29 @@ export function getLogger() {
  * Need typescript v5.5 later
  * @import * as ESI from "../v2";
  * @typedef {ESI.TESIResponseOKMap} TESIResponseOKMap
- * @typedef {ESI.IESIRequestFunction<ESIRequestOptions>} IESIRequestFunction
- * @typedef {ESI.TESIRequestFunctionMethods<ESIRequestOptions>} TESIRequestFunctionMethods
+ * @typedef {ESI.TPathParamsNever} TPathParamsNever
+ * @typedef {ESI.IESIRequestFunction2<ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {ESI.TESIRequestFunctionMethods2<ESIRequestOptions>} TESIRequestFunctionMethods2
  */
+// type ESIEndpointBrand<EP> = EP & { __esi: "x"; };
+// type EPPost = ESIEndpointBrand<keyof TESIResponseOKMap["post"]>;
 /**
  * #### Fire a request that does not require authentication.
  *
- * @template {TESIEntryMethod} M
- * @template {keyof TESIResponseOKMap[M]} EP
- * @template {IfParameterizedPath<EP, Opt>} P2
- * @template {IdentifyParameters<TESIResponseOKMap[M][EP], ESIRequestOptions>} Opt
- * @template {InferESIResponseResult<M, EP>} R
- *
- * @param {TESIRequestFunctionSignature<ESIRequestOptions> | TESIRequestFunctionMethods} fn
- * @param {M} method
- * @param {EP} endpoint
- * @param {P2} [pathParams]
- * @param {Opt} [opt]
- * @returns {Promise<R>}
+ * @type {import("./rq-util.d.mts").fireWithoutAuth}
  */
-function fireWithoutAuth(fn, method, endpoint, pathParams, opt) {
+export function fireWithoutAuth(fn, method, endpoint, opt) {
     if (typeof fn === "function") {
-        return fn(method, endpoint, pathParams, opt);
+        // @ts-expect-error TODO: ts(2345) The argument type does not match the type of the specified parameter
+        return fn(method, endpoint, opt);
     }
-    return fn[method](endpoint, pathParams, opt);
+    // @ts-expect-error TODO: ts(2345) The argument type does not match the type of the specified parameter
+    return fn[method](endpoint, opt);
 }
 /**
  * #### Fire a request that does not require authentication.
  *
- * @param {TESIRequestFunctionSignature<ESIRequestOptions> | TESIRequestFunctionMethods} fn
+ * @param {TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2} fn
  * @returns {Promise<void>}
  */
 export async function fireRequestsDoesNotRequireAuth(fn) {
@@ -363,16 +358,22 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
         // - - - - - - - - - - - -
         // Here, I borrow data from "CCP Zoetrope".
         clog();
-        await fireWithoutAuth(fn, "get", "/characters/{character_id}/", ID_CCP_Zoetrope).then(log);
-        clog('(portrait)');
-        await fireWithoutAuth(fn, "get", "/characters/{character_id}/portrait/", ID_CCP_Zoetrope).then(log);
-        clog('(affiliation)');
-        const affiliation = await fireWithoutAuth(fn, "post", "/characters/affiliation/", { body: [ID_CCP_Zoetrope] });
-        log(affiliation);
-        clog('(corporation)');
-        await fireWithoutAuth(fn, "get", "/corporations/{corporation_id}/", affiliation[0].corporation_id).then(log);
-        rlog("get:/incursions/".green);
-        await fireWithoutAuth(fn, "get", "/incursions/").then(log);
+        casefireWithoutAuth: {
+            await fireWithoutAuth(fn, "get", `/characters/${ID_CCP_Zoetrope}/`).then(log);
+            clog('(portrait)');
+            await fireWithoutAuth(fn, "get", `/characters/${ID_CCP_Zoetrope}/portrait/`).then(log);
+            clog('(affiliation)');
+            const affiliation = await fireWithoutAuth(fn, "post", "/characters/affiliation/", { body: [ID_CCP_Zoetrope] });
+            log(affiliation);
+            clog('(corporation)');
+            await fireWithoutAuth(fn, "get", `/corporations/${affiliation[0].corporation_id}/`).then(log);
+            rlog("get:/incursions/".green);
+            await fireWithoutAuth(fn, "get", "/incursions/").then(log);
+            fireWithoutAuth(fn, "delete", `/characters/${1234}/fittings/${56789}/`, {
+                // pathParams: [1234, 56789],
+                auth: true
+            }).catch(console.log);
+        }
         // - - - - - - - - - - - -
         //     Miscellaneous
         // - - - - - - - - - - - -
@@ -381,7 +382,8 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
         log(ids.inventory_types, ids.regions);
         rlog(`get:/markets/${ids?.regions?.[0].id}/orders/?type_id=${ids?.inventory_types?.[0].id}, item PLEX`.green);
         // in this case, "order_type" is required
-        const orders = await fireWithoutAuth(fn, "get", "/markets/{region_id}/orders/", ids?.regions?.[0].id, {
+        const orders = await fireWithoutAuth(fn, "get", "/markets/{region_id}/orders/", {
+            pathParams: ids?.regions?.[0].id || 0,
             query: {
                 // page: 1,
                 order_type: "sell",
@@ -401,13 +403,13 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
         //  The following is code to observe the behavior of completion by generics.
         //  Authentication is required, so an error will occur.
         // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
-        let willFailed = await fireWithoutAuth(fn, "get", "/characters/{character_id}/ship/", ID_CCP_Zoetrope, {
+        let willFailed = await fireWithoutAuth(fn, "get", `/characters/${ID_CCP_Zoetrope}/ship/`, {
             auth: true,
-            ignoreError: true,
             token: "token.token.token"
         });
         // in this case, "categories" and "search" is required
-        await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", ID_CCP_Zoetrope, {
+        await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", {
+            pathParams: ID_CCP_Zoetrope,
             query: {
                 categories: ["agent"],
                 search: "ok"

package/lib/tagged-request-api.d.mts

@@ -8,29 +8,26 @@
 /// <reference types="../v2/esi-tagged-types"/>
 import type { ESIRequestOptions } from "./rq-util.mjs";
 /**
- * `esi-tagged-types` and `injectESIRequestBody` allow for more intuitive use of ESI requests based on the "tags" defined in the EVE Swagger JSON.
- *
- * + The `ESI request API object` constructed by `injectESIRequestBody` lists narrowed endpoints by accessing the camel-cased "tags" members.
+ * Decorates the ESI request body into a tagged ESI request map.
  *
  * @example
  *    import * as taggedApi from "eve-esi-types/lib/tagged-request-api.mjs";
  *
- *    const esiRequest = taggedApi.injectESIRequestBody(...);
+ *    const esiRequest = taggedApi.decoreateESIRequestBody(...);
  *    const ret = await esiRequest.universe.get("/universe/structures/", { query: { filter: "market" }});
  *
  * @template {Record<string, unknown>} Opt - The options type for the request.
- * @param {TESIRequestFunctionSignature<Opt>} requestBody - The function signature for the ESI request.
- * @returns {XESI.TaggedESIRequestMap} - The tagged ESI request map.
- * @since 2.3
+ * @param {TESIRequestFunctionSignature2<Opt>} requestBody - The function signature for the ESI request.
+ * @returns {XESI.TaggedESIRequestMap2<Opt>} - The tagged ESI request map.
  */
-export declare function injectESIRequestBody<Opt extends Record<string, unknown>>(requestBody: TESIRequestFunctionSignature<Opt>): XESI.TaggedESIRequestMap<Opt>;
+export declare function decoreateESIRequestBody<Opt extends Record<string, unknown>>(requestBody: TESIRequestFunctionSignature2<Opt>): XESI.TaggedESIRequestMap2<Opt>;
 /**
  * @import { ESIRequestOptions } from "./rq-util.mjs";
  */
 /**
- * Injects the minimal implementation of ESI requests into `XESI.TaggedESIRequestMap`.
+ * Injects the minimal implementation of ESI requests into `XESI.TaggedESIRequestMap2`.
  *
- * @since 2.3
- * @type {XESI.TaggedESIRequestMap<ESIRequestOptions>}
+ * @since 2.x
+ * @type {XESI.TaggedESIRequestMap2<ESIRequestOptions>}
  */
-export declare const esi: import("../v2/esi-tagged-types").TaggedESIRequestMap<ESIRequestOptions>;
+export declare const esi: import("../v2/esi-tagged-types").TaggedESIRequestMap2<ESIRequestOptions>;