eve-esi-types 3.0.4 → 3.1.2

package/README.md

@@ -8,10 +8,10 @@ Extracted main types 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)
+> Sample code is provided -> [`request-v3.mjs`](./request-v3.mjs)
 
 ```shell
-$ node v2.mjs
+$ node request-v3.mjs
 ```
 
 ## API
@@ -100,4 +100,6 @@ const ret = await esiRequest.universe.get("/universe/structures/", { query: { fi
 
 ## References
 
-- [`ESI Types Utility Definitions`](./esi-types-util3.md)
+- [`ESI Types Utility Definitions`](./docs/esi-types-util3.md)
+
+- [`ESI Tagged Types Utility Definitions`](./docs/esi-tagged-types.md)

package/docs/esi-tagged-types.md

@@ -0,0 +1,120 @@
+# ESI Tagged Types
+
+This document provides an overview of the types defined in the `eve-esi-types/v2/esi-tagged-types.d.ts` file. These types are used to handle EVE Online ESI responses.
+
+## LCamelCase
+
+Converts a string to lower camel case.
+
+```typescript
+type LCamelCase<S extends string> = S extends `${infer P1} ${infer P2}`
+  ? `${Lowercase<P1>}${Capitalize<P2>}` : Lowercase<S>;
+```
+
+### Example
+
+```typescript
+// returns "assets"
+LCamelCase<"Assets">
+
+// returns "factionWarfare"
+LCamelCase<"Faction Warfare">
+```
+
+## InferSomethingBy
+
+Infers something by a brand.
+
+```typescript
+type InferSomethingByBrand<N = number> = N & { __enum: "InferSomethingBy" };
+type InferSomethingByMethod  = InferSomethingByBrand<0>;
+type InferSomethingByTags    = InferSomethingByBrand<1>;
+type InferSomethingBy<Tag, AsType extends InferSomethingByBrand = InferSomethingByMethod> = {
+  [M in TESIEntryMethod]: TESIResponseOKMap[M] extends Record<`/${string}/`, { tag: infer ActualTag }>
+    ? AsType extends InferSomethingByTags
+      ? ActualTag : ActualTag extends Tag
+        ? M
+      : never
+    : never;
+}[TESIEntryMethod];
+```
+
+## ESITags
+
+Maps HTTP methods to their corresponding tags.
+
+```typescript
+type ESITags = InferSomethingBy<never, InferSomethingByTags>;
+```
+
+## InferMethod
+
+Infers the HTTP method based on the provided tag.
+
+```typescript
+type InferMethod<Tag> = InferSomethingBy<Tag>;
+```
+
+## TaggedEndpointRequestFunction2
+
+Creates a function type for making requests to tagged endpoints.
+
+```typescript
+type TaggedEndpointRequestFunction2<
+  M extends TESIEntryMethod, Tag extends ESITags,
+  ActualOpt extends Record<string, unknown> = {},
+  EndPoints extends SelectEndpointByTag<Tag, M> = SelectEndpointByTag<Tag, M>,
+> = <
+    REP extends ReplacePathParams<EndPoints> | EndPoints,
+    EPX extends _InferEndpointOrigin<REP, EndPoints> extends never ? REP: _InferEndpointOrigin<REP, EndPoints>,
+    PPM extends InferPathParams<REP, EPX>,
+    Opt extends IdentifyParameters<M, EPX, ActualOpt & PPM>,
+    Ret extends InferESIResponseResult<M, EPX>,
+    HasOpt = HasRequireParams<M, EPX, PPM>,
+>(endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
+```
+
+## ESITaggedEndpointRequest2
+
+Maps tags to their corresponding endpoint request functions.
+
+```typescript
+type ESITaggedEndpointRequest2<Tag extends ESITags, ActualOpt extends Record<string, unknown> = {}> = {
+  [tag in Tag]: {
+    [method in InferMethod<Tag>]: TaggedEndpointRequestFunction2<method, tag, ActualOpt>;
+  };
+}[Tag];
+```
+
+## SelectEndpointByTag
+
+Selects an endpoint by tag and method.
+
+```typescript
+type SelectEndpointByTag<
+  Tag extends ESITags, M extends TESIEntryMethod
+> = {
+  [EP in keyof TESIResponseOKMap[M]]: TESIResponseOKMap[M][EP] extends { tag: infer ActualTag }
+    ? ActualTag extends Tag
+      ? EP : never
+    : never;
+}[keyof TESIResponseOKMap[M]];
+```
+
+## TaggedESIRequestMap2
+
+Maps lower camel case tags to their corresponding endpoint request functions.
+
+```typescript
+type TaggedESIRequestMap2<ActualOpt extends Record<string, unknown> = {}> = {
+  [tag in ESITags as LCamelCase<tag>]: ESITaggedEndpointRequest2<tag, ActualOpt>;
+};
+```
+
+## TaggedESIRequestMapPartial2
+
+Creates a partial map of lower camel case tags to their corresponding endpoint request functions.
+
+```typescript
+type TaggedESIRequestMapPartial2<Props extends LCamelCase<ESITags>> = RequireThese<Partial<TaggedESIRequestMap2>, Props>;
+```

package/docs/esi-types-util3.md

@@ -0,0 +1,319 @@
+<!--!
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
+  Released under the MIT license
+  https://opensource.org/licenses/mit-license.php
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+-->
+
+# ESI Types Utility 3.1 Summary
+
+This document provides detailed explanations of each type defined in the `eve-esi-types/v2/index.d.ts` file.
+
+> ## TESIRequestFunctionSignature2
+
+`TESIRequestFunctionSignature2` is a type that defines the signature of an ESI request function where the endpoint can be a real endpoint or a parameterized endpoint. This function sends a request to a specified endpoint and returns a response.
+
+#### Type Parameters
+
+- `ActualOpt`: The actual type of the options.
+- `M`: The HTTP method to use for the request.
+- `RealEP`: The real path of the ESI endpoint to send the request to.
+- `EPx`: The parameterized path of the ESI endpoint to send the request to.
+- `PathParams`: Parameters to include in the request if the endpoint is parameterized.
+- `Opt`: Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`.
+- `R`: The response type.
+- `HasOpt`: Determines if the options parameter is required.
+
+#### Parameters
+
+- `method`: The HTTP method to use for the request (e.g., "get", "post").
+- `endpoint`: The real path of the ESI endpoint to send the request to.
+- `options`: An optional object containing additional options for the request. If the endpoint has required parameters, this parameter must be provided.
+
+#### Returns
+
+A `Promise` object containing the response data, with the type inferred based on the method and endpoint.
+
+#### Remarks
+
+The `...options: HasOpt extends 1 ? [Opt] : [Opt?]` parameter is defined this way to enforce that if the endpoint has required parameters, the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
+
+
+> ## TESIRequestFunctionEachMethod2
+
+`TESIRequestFunctionEachMethod2` is a type that defines the signature of an ESI request function for a specific HTTP method. This function sends a request to a specified endpoint and returns a response.
+
+#### Type Parameters
+
+- `M`: The HTTP method to use for the request.
+- `ActualOpt`: The actual type of the options.
+- `RealEP`: The real path of the ESI endpoint to send the request to.
+- `EPx`: The parameterized path of the ESI endpoint to send the request to.
+- `PathParams`: Parameters to include in the request if the endpoint is parameterized.
+- `Opt`: Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`.
+- `R`: The response type.
+- `HasOpt`: Determines if the options parameter is required.
+
+#### Parameters
+
+- `endpoint`: The real path of the ESI endpoint to send the request to.
+- `options`: An optional object containing additional options for the request. If the endpoint has required parameters, this parameter must be provided.
+
+#### Returns
+
+A `Promise` object containing the response data, with the type inferred based on the method and endpoint.
+
+#### Remarks
+
+The `...options: HasOpt extends 1 ? [Opt] : [Opt?]` parameter is defined this way to enforce that if the endpoint has required parameters, the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
+
+
+
+## ReplacePathParams
+
+`ReplacePathParams` is a type that replaces path parameters in a string with numbers.
+
+```typescript
+type ReplacePathParams<T extends unknown> = T extends `${infer Start}{${infer Param}}${infer End}`
+  ? `${Start}${number}${ReplacePathParams<End>}` : T;
+```
+
+  <details>
+> Example
+
+  ```typescript
+  type Example = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
+  // Result: `/characters/${number}/fittings/${number}/`
+  ```
+  </details>
+
+## InferPathParams
+
+`InferPathParams` is a type that infers the path parameters based on the real endpoint and the resolved endpoint.
+
+```typescript
+type InferPathParams<
+  RealEP extends unknown, EPx extends unknown
+> = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
+```
+
+## InferEndpointOrigin
+
+`InferEndpointOrigin` is a type that infers the original endpoint based on the real endpoint and the HTTP method. This type maps the real endpoint to its corresponding parameterized endpoint by checking if the real endpoint matches the pattern of any parameterized endpoint.
+
+```typescript
+type InferEndpointOrigin<
+  RealEP extends unknown, M extends TESIEntryMethod,
+  Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>
+> = {
+  [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
+    ? EP : never;
+}[Endpoints];
+```
+
+  <details>
+> Example
+
+  ```typescript
+type Original = InferEndpointOrigin<"/characters/123/fittings/456/", "delete">;
+// Result: "/characters/{character_id}/fittings/{fitting_id}/"
+  ```
+  </details>
+
+
+## ResolvedEndpoint
+
+`ResolvedEndpoint` is a type that determines the resolved endpoint based on the real endpoint and the method.
+
+```typescript
+type ResolvedEndpoint<
+  RealEP extends unknown, M extends TESIEntryMethod,
+> = InferEndpointOrigin<RealEP, M> extends never ? RealEP: InferEndpointOrigin<RealEP, M>;
+```
+
+  <details>
+> Example
+
+  ```typescript
+type Resolved = ResolvedEndpoint<"/characters/123/fittings/456/", "delete">;
+// Result: "/characters/{character_id}/fittings/{fitting_id}/"
+  ```
+  </details>
+
+## PickRequireParams
+
+`PickRequireParams` is a type that picks the required parameters from an entry type, including additional parameters. This type excludes the keys "result", "tag", and "cachedSeconds" from the entry type and the additional parameters, and returns the remaining keys as the required parameters.
+
+```typescript
+type PickRequireParams<
+  M extends TESIEntryMethod,
+  EPx extends ESIEndpointOf<M> | string,
+  AdditionalParams,
+  Entry = _ESIResponseType<M, EPx>
+> = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">;
+```
+
+  <details>
+> Example
+
+  ```typescript
+type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
+type RequiredParams = PickRequireParams<"get", "/example/endpoint", { auth: string }>;
+// Result: "auth"
+  ```
+  </details>
+
+## HasRequireParams
+
+`HasRequireParams` is a type that determines if the given entry has required parameters, including additional options. This type checks if an entry has any required parameters by excluding the keys "result", "tag", and "cachedSeconds". If any keys remain after this exclusion, it means the entry has required parameters.
+
+```typescript
+type HasRequireParams<
+  M extends TESIEntryMethod,
+  EPx extends ESIEndpointOf<M> | string,
+  AdditionalParams,
+> = PickRequireParams<M, EPx, AdditionalParams> extends never ? 0 : 1;
+```
+
+  <details>
+> Example
+
+  ```typescript
+type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
+type HasRequired = HasRequireParams<"get", "/example/endpoint", { auth: string }>;
+// Result: 1
+  ```
+  </details>
+
+## IfParameterizedPath
+
+`IfParameterizedPath` is a type that determines the required number of replacements if `EP` (endpoint) is a parameterized path.
+
+```typescript
+type IfParameterizedPath<EP extends unknown, 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, including additional options. This type combines the required parameters from the entry type and the additional options, ensuring that all required parameters are marked as required.
+
+```typescript
+type IdentifyParameters<
+  M extends TESIEntryMethod,
+  EPx extends ESIEndpointOf<M> | string,
+  Opt extends Record<string, unknown>,
+  Entry = _ESIResponseType<M, EPx>,
+  Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+> = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
+```
+
+  <details>
+> Example
+
+  ```typescript
+type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
+type ExampleOpt = { auth: string };
+type IdentifiedParams = IdentifyParameters<"get", "/example/endpoint", ExampleOpt, ExampleEntry>;
+// Result: { auth: string } & { auth: string }
+  ```
+  </details>
+
+## 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,
+  EPx extends ESIEndpointOf<M> | string
+> = _ESIResponseType<M, EPx> extends { result: infer U } ? U : never;
+```
+
+  <details>
+> Example
+
+  ```typescript
+type Result = InferESIResponseResult<"get", "/characters/{character_id}/">;
+// Result: The inferred type of the response for the given method and endpoint.
+  ```
+  </details>
+
+## 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;
+```
+
+  <details>
+> Example
+
+  ```typescript
+  "get" | "post" | "put" | "delete"
+  ```
+  </details>
+
+## ESIEndpointOf
+
+`ESIEndpointOf` is a type that represents the endpoints for the specified HTTP method.
+
+```typescript
+type ESIEndpointOf<M extends TESIEntryMethod> = keyof TESIResponseOKMap[M];
+```
+
+  <details>
+> Example
+
+  ```typescript
+type TEndPointGet = ESIEndpointOf<"get">;
+type TEndPointPost = ESIEndpointOf<"post">;
+type TEndPointPut = ESIEndpointOf<"put">;
+type TEndPointDelete = ESIEndpointOf<"delete">;
+  ```
+  </details>
+
+## 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/rq-util.d.mts

@@ -16,7 +16,7 @@
 //  https://opensource.org/licenses/mit-license.php
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
-import type { TESIResponseOKMap, TESIRequestFunctionMethods2, TPathParamsNever } from "../v2";
+import type { TESIRequestFunctionMethods2 } from "../v2";
 import type { TESIErrorStats } from "./esi-error-types";
 export { isNode } from "./constants.mjs";
 /**
@@ -181,9 +181,10 @@ export declare function getLogger(): {
     clog: (...args: any[]) => void;
     rlog: (...args: any[]) => void;
 };
-export type TFireWithoutAuth = {
-    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]>>, HasOpt = HasRequireParams<TESIResponseOKMap[M][Extract<EP, keyof TESIResponseOKMap[M]>]> extends never ? 0 : 1>(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>, method: M, endpoint: RealEP, ...opt: HasOpt extends 1 ? [Opt] : [Opt?]): Promise<R>;
-}["fireWithoutAuth"];
+export type TFireWithoutAuth<ActualOpt = ESIRequestOptions> = <Mtd extends TESIEntryMethod, REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>, EPX extends ResolvedEndpoint<REP, Mtd>, PPM extends InferPathParams<REP, EPX>, Opt extends IdentifyParameters<Mtd, EPX, ActualOpt & PPM>, Ret extends InferESIResponseResult<Mtd, EPX>, HasOpt = HasRequireParams<Mtd, EPX, PPM>, XX = PickRequireParams<Mtd, EPX, PPM>>(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>, method: Mtd, endpoint: REP, ...opt: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
+export interface IFireWithoutAuth<ActualOpt = ESIRequestOptions> {
+    <Mtd extends TESIEntryMethod, REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>, EPX extends ResolvedEndpoint<REP, Mtd>, PPM extends InferPathParams<REP, EPX>, Opt extends IdentifyParameters<Mtd, EPX, ActualOpt & PPM>, Ret extends InferESIResponseResult<Mtd, EPX>, HasOpt = HasRequireParams<Mtd, EPX, PPM>, XX = PickRequireParams<Mtd, EPX, PPM>>(fn: TESIRequestFunctionSignature2<ActualOpt> | TESIRequestFunctionMethods2<ActualOpt>, method: Mtd, endpoint: REP, ...opt: HasOpt extends 1 ? [Opt] : [Opt?]): Promise<Ret>;
+}
 /**
  * Need typescript v5.5 later
  * @import * as ESI from "../v2";

package/lib/rq-util.mjs

@@ -320,19 +320,38 @@ export function getLogger() {
     const rlog = consoleUtil.getLogger("- - -> Run ESI request".cyan);
     return { clog, rlog };
 }
+/* ctt
+// Result: `/characters/${number}/fittings/${number}/`
+type Example = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
+
+// Result: "/characters/{character_id}/fittings/{fitting_id}/"
+type ResovedEP = ResolvedEndpoint<"/characters/123/fittings/456/", "delete">;
+// Result: "/characters/{character_id}/fittings/{fitting_id}/"
+type ResovedEP2 = ResolvedEndpoint<"/characters/{character_id}/fittings/{fitting_id}/", "delete">;
+type IncompleteEP = ResolvedEndpoint<"/characters/1234/fittings/{fitting_id}/", "delete">;
+
+// Result: "/characters/{character_id}/fittings/{fitting_id}/"
+type EPOriginOK = InferEndpointOrigin<"/characters/123/fittings/456/", "delete">;
+// result: never
+type EPOriginNever = InferEndpointOrigin<"/characters/123/fittings/{fitting_id}/", "delete">;
+// result: never
+type EPOriginNever2 = InferEndpointOrigin<"/characters/{character_id}/fittings/456/", "delete">;
+/*/
+//*/
 /**
  * #### Fire a request that does not require authentication.
  *
  * @type {import("./rq-util.d.mts").TFireWithoutAuth}
  */
-// @ts-expect-error 
-const fireWithoutAuth = (fn, method, endpoint, opt) => {
+// @ts-expect -error 
+const fireWithoutAuth = (fn, method, endpoint, ...opt) => {
+    const arg = opt.length ? opt[0] : void 0;
     if (typeof fn === "function") {
         // @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, arg);
     }
     // @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, arg);
 };
 /**
  * Need typescript v5.5 later
@@ -358,7 +377,9 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
         // Here, I borrow data from "CCP Zoetrope".
         clog();
         casefireWithoutAuth: {
-            await fireWithoutAuth(fn, "get", `/characters/${ID_CCP_Zoetrope}/`).then(log);
+            await fireWithoutAuth(fn, "get", `/characters/{character_id}/`, {
+                pathParams: ID_CCP_Zoetrope
+            }).then(log);
             clog('(portrait)');
             await fireWithoutAuth(fn, "get", `/characters/${ID_CCP_Zoetrope}/portrait/`).then(log);
             clog('(affiliation)');
@@ -368,10 +389,16 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
             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);
+            if (is("withError")) {
+                await fireWithoutAuth(fn, "get", "/characters/{character_id}/assets/", {
+                    auth: true,
+                    pathParams: 12354
+                });
+                await fireWithoutAuth(fn, "delete", `/characters/${1234}/fittings/${56789}/`, {
+                    pathParams: [1234, 56789], // ⚠️ TODO: A semantics error should be deliberately caused here
+                    auth: true
+                }).catch(console.log);
+            }
         }
         // - - - - - - - - - - - -
         //     Miscellaneous

package/lib/tagged-request-api.mjs

@@ -53,7 +53,7 @@ export function decoreateESIRequestBody(requestBody) {
     // DEVNOTE: 2025/03/08 - In reality, you only need one function instance for each of "get", "post", "put", and "delete",
     // so you can just refer to the cached functions as a map.
     const methodMap = /** @type {TESIRequestFunctionMethods2<Opt>} */ ({});
-    /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
+    /** @satisfies {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
         methodMap[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, Opt>} */ (
         // @ts-expect-error Type peeling due to differences in inference process
         (e, opt) => requestBody(method, e, opt));

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "eve-esi-types",
-  "version": "3.0.4",
+  "version": "3.1.2",
   "description": "Extracted the main type of ESI. use for ESI request response types (version 2 only)",
   "main": "v2/index.d.ts",
   "scripts": {
-    "test": "node v2.mjs -debug",
+    "test": "node request-v3.mjs -debug",
     "test:mini": "node minimal-rq.mjs -debug"
   },
   "repository": {
@@ -15,6 +15,7 @@
     "v2",
     "lib",
     "web",
+    "docs",
     "*.d.mts",
     "*.mjs",
     "LICENSE",

package/{v2.mjs → request-v3.mjs}

@@ -92,7 +92,7 @@ async function getEVEStatus(fn) {
     return fn("get", "/status/");
 }
 // type following and run
-// node v2.mjs
+// node request-v3.mjs
 // or yarn test
 if (!is("x")) {
     getEVEStatus(fire).then(eveStatus => log(eveStatus));

package/tagged-rq.mjs

@@ -43,8 +43,8 @@ if (util.is("withError")) {
         },
         // token: "s.s.s"
     })).then(console.log).catch(console.log);
-    esi.fittings.delete("/characters/{character_id}/fittings/{fitting_id}/", {
-        pathParams: [1234, 56789],
+    esi.fittings.delete("/characters/1234/fittings/56789/", {
+        pathParams: [1234, 56789], // ⚠️ TODO: A semantics error should be deliberately caused here
         auth: true
     });
     esi.character.post("/characters/affiliation/", {