eve-esi-types 3.0.3 → 3.1.0

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

package/esi-types-util3.md

@@ -6,89 +6,192 @@
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 -->
 
-# ESI Types Utility Summary
+# ESI Types Utility 3.1 Summary
 
-## TESICachedSeconds
-`TESICachedSeconds` is a type to get the cached seconds for a specific HTTP method.
+This document provides detailed explanations of each type defined in the `index.d.ts` file.
 
-```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];
-```
+> ## TESIRequestFunctionSignature2
 
-## TPathParamsNever
-`TPathParamsNever` is a type used when path parameters are not required.
+`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.
 
-```typescript
-type TPathParamsNever = { pathParams?: never };
-```
+#### Type Parameters
 
-## TESIRequestFunctionSignature2
-`TESIRequestFunctionSignature2` is a type that defines the signature of an ESI request function.
+- `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.
 
-```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>;
-```
+#### 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.
 
-## 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}`
+type ReplacePathParams<T extends unknown> = 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.
+  <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 IfNeedPathParams<EP> = IfParameterizedPath<EP> extends never ? TPathParamsNever :
-  EP extends ReplacePathParams<EP> ? TPathParamsNever : { pathParams: IfParameterizedPath<EP> };
+type InferPathParams<
+  RealEP extends unknown, EPx extends unknown
+> = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
 ```
 
 ## InferEndpointOrigin
-`InferEndpointOrigin` is a type that infers the original endpoint path from a real endpoint path.
+
+`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, Endpoints> = {
+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 the endpoint is a parameterized path.
+
+`IfParameterizedPath` is a type that determines the required number of replacements if `EP` (endpoint) is a parameterized path.
 
 ```typescript
-type IfParameterizedPath<EP, Opt = never> = EP extends `${string}/{${string}}${string}`
+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]
@@ -96,26 +199,52 @@ type IfParameterizedPath<EP, Opt = never> = EP extends `${string}/{${string}}${s
 ```
 
 ## IdentifyParameters
-`IdentifyParameters` is a type that identifies the required parameters for a given entry type.
+
+`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<
-  Entry, Opt,
+  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,
-  EP extends keyof TESIResponseOKMap[M]
-> = TESIResponseOKMap[M][EP] extends { result: infer U } ? U : never;
+  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
@@ -123,41 +252,42 @@ 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.
+  <details>
+> Example
 
-```typescript
-type TEndPointGet = keyof TESIResponseOKMap["get"];
-```
+  ```typescript
+  "get" | "post" | "put" | "delete"
+  ```
+  </details>
 
-## TEndPointPost
-`TEndPointPost` is a type that represents the endpoints for the "post" method.
+## ESIEndpointOf
 
-```typescript
-type TEndPointPost = keyof TESIResponseOKMap["post"];
-```
-
-## TEndPointPut
-`TEndPointPut` is a type that represents the endpoints for the "put" method.
+`ESIEndpointOf` is a type that represents the endpoints for the specified HTTP method.
 
 ```typescript
-type TEndPointPut = keyof TESIResponseOKMap["put"];
+type ESIEndpointOf<M extends TESIEntryMethod> = keyof TESIResponseOKMap[M];
 ```
 
-## TEndPointDelete
-`TEndPointDelete` is a type that represents the endpoints for the "delete" method.
+  <details>
+> Example
 
-```typescript
-type TEndPointDelete = keyof TESIResponseOKMap["delete"];
-```
+  ```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
@@ -165,6 +295,7 @@ type TESIResponseGetEntry<K extends TEndPointGet> = TESIResponseOKMap["get"][K];
 ```
 
 ## TESIResponsePutEntry
+
 `TESIResponsePutEntry` is a type that represents the entry details for the "put" method.
 
 ```typescript
@@ -172,6 +303,7 @@ type TESIResponsePutEntry<K extends TEndPointPut> = TESIResponseOKMap["put"][K];
 ```
 
 ## TESIResponsePostEntry
+
 `TESIResponsePostEntry` is a type that represents the entry details for the "post" method.
 
 ```typescript
@@ -179,6 +311,7 @@ type TESIResponsePostEntry<K extends TEndPointPost> = TESIResponseOKMap["post"][
 ```
 
 ## TESIResponseDeleteEntry
+
 `TESIResponseDeleteEntry` is a type that represents the entry details for the "delete" method.
 
 ```typescript

package/lib/request-api.mjs

@@ -69,8 +69,8 @@ export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endp
 // implements rest methods of `request` (IESIRequestFunction2)
 //
 /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-    request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method>} */ (function (endpoint, opt) {
-        // @ts-expect-error TODO: 2025/3/12
-        return this(method, endpoint, opt);
+    request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, util.ESIRequestOptions>} */ ((endpoint, opt) => {
+        // @ts-expect-error TODO: ts(2345)
+        return request2(method, endpoint, opt);
     });
 });

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 = <M extends TESIEntryMethod, RealEP extends ReplacePathParams<ESIEndpointOf<M>> | ESIEndpointOf<M>, EPx extends ResolvedEndpoint<RealEP, M>, PathParams extends InferPathParams<RealEP, EPx>, Opt extends IdentifyParameters<M, EPx, ESIRequestOptions & PathParams>, R extends InferESIResponseResult<M, EPx>, HasOpt = HasRequireParams<M, EPx, PathParams>, XX = PickRequireParams<M, EPx, PathParams>>(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>, method: M, endpoint: RealEP, ...opt: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
+export interface IFireWithoutAuth {
+    <M extends TESIEntryMethod, RealEP extends ReplacePathParams<ESIEndpointOf<M>> | ESIEndpointOf<M>, EPx extends ResolvedEndpoint<RealEP, M>, PathParams extends InferPathParams<RealEP, EPx>, Opt extends IdentifyParameters<M, EPx, ESIRequestOptions & PathParams>, R extends InferESIResponseResult<M, EPx>, HasOpt = HasRequireParams<M, EPx, PathParams>, XX = PickRequireParams<M, EPx, PathParams>>(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>, method: M, endpoint: RealEP, ...opt: HasOpt extends 1 ? [Opt] : [Opt?]): Promise<R>;
+}
 /**
  * Need typescript v5.5 later
  * @import * as ESI from "../v2";

package/lib/rq-util.mjs

@@ -320,18 +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) => {
+    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
@@ -357,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)');
@@ -367,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
@@ -405,6 +433,7 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
             auth: true,
             token: "token.token.token"
         });
+        log(`get:/characters/${ID_CCP_Zoetrope}/ship/, returns=${willFailed}`);
         // in this case, "categories" and "search" is required
         await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", {
             pathParams: ID_CCP_Zoetrope,
@@ -414,16 +443,15 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
             },
             auth: true
         });
-        // TODO: want TypeScript semantics to throw an error because there is a required query parameter, but it's not possible
-        //   Or rather, I don't know how to do it.
-        await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", {
-            auth: true,
-            pathParams: 1234,
-            query: {
-                categories: ["alliance"], search: "test!!"
-            }
-        });
-        log(willFailed);
+        // // TODO: want TypeScript semantics to throw an error because there is a required query parameter, but it's not possible
+        // //   Or rather, I don't know how to do it.
+        // await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", {
+        //     auth: true,
+        //     pathParams: 1234,
+        //     query: {
+        //         categories: ["alliance"], search: "test!!"
+        //     }
+        // });
     }
     catch (e) {
         console.error("Failed to request -", e);

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/minimal-rq.mjs

@@ -27,9 +27,9 @@ const log = util.getUniversalLogger("[request-mini]: ");
 // Delegates implementation to `request` (TESIRequestFunctionMethods2)
 //
 const esiMethods = /** @type {TESIRequestFunctionMethods2} */ ({});
-/** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-    esiMethods[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method>} */ (function (endpoint, opt) {
-        // @ts-expect-error
+/** @satisfies {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
+    esiMethods[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, util.ESIRequestOptions>} */ ((endpoint, opt) => {
+        // @ts-expect-error ts(2345)
         return request2(method, endpoint, opt);
     });
 });
@@ -39,18 +39,20 @@ const esiMethods = /** @type {TESIRequestFunctionMethods2} */ ({});
  */
 async function getEVEStatus2(fn) {
     await util.getSDEVersion().then(sdeVersion => log(`sdeVersion: ${sdeVersion}`.blue));
+    const { clog, rlog } = util.getLogger();
+    rlog("- - - - - - - > run as IESIRequestFunction2<ESIRequestOptions>".red, fn);
     await util.fireRequestsDoesNotRequireAuth(fn);
     CaseIESIRequestFunctionMethods: {
+        rlog("- - - - - - - > run as TESIRequestFunctionMethods2<ESIRequestOptions>".red, esiMethods);
         await util.fireRequestsDoesNotRequireAuth(esiMethods);
     }
-    const { clog, rlog } = util.getLogger();
     CaseIESIRequestFunction2: {
         const ID_CCP_Zoetrope = 2112625428;
         // - - - - - - - - - - - -
         //       Character
         // - - - - - - - - - - - -
         // Here, I borrow data from "CCP Zoetrope".
-        rlog("- - - - - - - > run as IESIRequestFunction2<ESIRequestOptions>".red);
+        rlog("- - - - - - - > run as IESIRequestFunction2::TESIRequestFunctionMethods2<ESIRequestOptions>".red, fn);
         clog();
         await fn.get("/characters/{character_id}/", { pathParams: ID_CCP_Zoetrope }).then(log);
         clog('(portrait)');

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "eve-esi-types",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "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": {

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/", {

package/v2/esi-tagged-types.d.ts

@@ -9,9 +9,9 @@
  * THIS DTS IS AUTO GENERATED, DO NOT EDIT
  * 
  * @file eve-esi-types/v2/esi-tagged-types.d.ts
- * @summary This file is auto-generated and defines version 3.0.3 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.0 of the EVE Online ESI response types.
  */
-import { TESIResponseOKMap, TPathParamsNever } from "./index.d.ts";
+import { TESIResponseOKMap } from "./index.d.ts";
 export * from "./index.d.ts";
 
 /**
@@ -30,13 +30,12 @@ export declare type LCamelCase<S extends string> = S extends `${infer P1} ${infe
   ? `${Lowercase<P1>}${Capitalize<P2>}` : Lowercase<S>;
 
 
-declare type EInferSomethingBy = {
-  readonly METHOD: 0;
-  readonly TAGs: 1;
-};
-declare type InferSomethingBy<Tag, AsType extends EInferSomethingBy = EInferSomethingBy["METHOD"]> = {
+declare type InferSomethingByBrand<N = number> = N & { __enum: "InferSomethingBy" };
+declare type InferSomethingByMethod  = InferSomethingByBrand<0>;
+declare type InferSomethingByTags    = InferSomethingByBrand<1>;
+declare type InferSomethingBy<Tag, AsType extends InferSomethingByBrand = InferSomethingByMethod> = {
   [M in TESIEntryMethod]: TESIResponseOKMap[M] extends Record<`/${string}/`, { tag: infer ActualTag }>
-    ? AsType extends EInferSomethingBy["TAGs"]
+    ? AsType extends InferSomethingByTags
       ? ActualTag : ActualTag extends Tag
         ? M
       : never
@@ -50,7 +49,7 @@ declare type InferSomethingBy<Tag, AsType extends EInferSomethingBy = EInferSome
  * @template M - The HTTP method.
  * @date 2025/2/28
  */
-export declare type ESITags = InferSomethingBy<never, EInferSomethingBy["TAGs"]>
+export declare type ESITags = InferSomethingBy<never, InferSomethingByTags>
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
 //            Utility Type `InferMethod`
@@ -82,17 +81,21 @@ export declare type InferMethod<Tag> = InferSomethingBy<Tag>
  * 
  * @param endpoint - The endpoint path.
  * @param pathParams - The path parameters.
- * @param options - The request options.
+ * @param options - An optional object containing additional options for the request. If the endpoint has required parameters, this parameter must be provided.
  * @returns A promise that resolves to the response.
- * @date 2025/2/28
+ * 
+ * @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.
  */
+// TODO: 2025/3/16 1:20:50 Generics bug maybe OK?
 export declare type TaggedEndpointRequestFunction2<M extends TESIEntryMethod, Tag extends ESITags, ActualOpt = {}> = <
-  RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M],
-  EP extends InferEndpointOrigin<RealEP, SelectEndpointByTag<Tag, M>> extends never ? RealEP: InferEndpointOrigin<RealEP, SelectEndpointByTag<Tag, M>>,
-  PathParams extends RealEP extends EP ? IfNeedPathParams<EP>: TPathParamsNever,
-  Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt & PathParams>,
-  R extends InferESIResponseResult<M, EP>,
-  HasOpt = HasRequireParams<TESIResponseOKMap[M][EP]> extends never ? 0 : 1
+    RealEP extends ReplacePathParams<ESIEndpointOf<M>> | ESIEndpointOf<M>,
+    EPx extends ResolvedEndpoint<RealEP, M>,
+    PathParams extends InferPathParams<RealEP, EPx>,
+    Opt extends IdentifyParameters<M, EPx, ActualOpt & PathParams>,
+    R extends InferESIResponseResult<M, EPx>,
+    HasOpt = HasRequireParams<M, EPx, PathParams>,
   // RealEPX = ReplacePathParamsX<RealEPX>,
   // EPX = ReplacePathParams<EP>,
 >(endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;

package/v2/index.d.ts

@@ -9,9 +9,8 @@
  * THIS DTS IS AUTO GENERATED, DO NOT EDIT
  * 
  * @file eve-esi-types/v2/index.d.ts
- * @summary This file is auto-generated and defines version 3.0.3 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.0 of the EVE Online ESI response types.
  */
-
 import type { TESIResponseOKMap } from "./response-map.d.ts";
 export type { TESIResponseOKMap } from "./response-map.d.ts";
 
@@ -86,23 +85,103 @@ export declare type TESICachedSeconds<
   Method extends TESIEntryMethod, AsEndpoint = void
 > = {
   [M in TESIEntryMethod]: {
-    [EP in keyof TESIResponseOKMap[M]]: TESIResponseOKMap[M][EP]["cachedSeconds"] extends number
+    [EP in ESIEndpointOf<M>]: TESIResponseOKMap[M][EP] extends { cachedSeconds: number }
       ? AsEndpoint extends void
         ? TESIResponseOKMap[M][EP]["cachedSeconds"]: EP
       : never
-  }[keyof TESIResponseOKMap[M]];
+  }[ESIEndpointOf<M>];
 }[Method];
-// const cacheSecGet: TESICachedSeconds<"get">;
-// const cache5sec: TESICachedSeconds<"put">;
-// const cache3600sEndpoint: TESICachedSeconds<"post", 1>;
-export declare type TPathParamsNever = { pathParams?: never };
+// declare const cacheSecGet: TESICachedSeconds<"get">;
+// declare const cache5sec: TESICachedSeconds<"put">;
+// declare const cache3600sEndpoint: TESICachedSeconds<"post", 1>;
+// TODO: 2025/3/17 How do I get rid of `pathParams` completely?
+export declare type TPathParamsNever = { /* pathParams?: never */ };
+
+// local types
+/**
+ * Infers the response type of an ESI request based on the HTTP method and endpoint.
+ * 
+ * This type extracts the response type from the `TESIResponseOKMap` based on the provided
+ * HTTP method and endpoint.
+ * 
+ * @template M - The HTTP method to use for the request.
+ * @template EPx - The endpoint path.
+ * 
+ * @example
+ * ```ts
+ * type ResponseType = _ESIResponseType<"get", "/characters/{character_id}/">;
+ * // Result: The inferred response type for the given method and endpoint.
+ * ```
+ * @internal
+ * @see {@link ESIEndpointOf}
+ */
+export type _ESIResponseType<
+  M extends TESIEntryMethod,
+  EPx extends ESIEndpointOf<M> | string,
+> = TESIResponseOKMap[M][Extract<EPx, ESIEndpointOf<M>>];
+// type XOK = _ESIResponseType<"get", "/status/"> extends global._ESIResponseType<"get", "/status/"> ? 1 : 0;
+/**
+ * Determines if the endpoint requires path parameters.
+ * 
+ * @template EP - The string representing the endpoint path.
+ * @returns {TPathParamsNever | { pathParams: IfParameterizedPath<EP> }}
+ * Returns an object with `pathParams` if the endpoint requires parameters, otherwise returns `TPathParamsNever`.
+ * @example
+ * ```ts
+ * type Example = IfNeedPathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
+ * // Result: { pathParams: [number, number] }
+ * ```
+ * @internal
+ * @see {@link IfParameterizedPath}
+ * @see {@link ReplacePathParams}
+ */
+export type _IfNeedPathParams<EP extends unknown> = IfParameterizedPath<EP> extends never ? TPathParamsNever :
+  EP extends ReplacePathParams<EP> ? TPathParamsNever : { pathParams: IfParameterizedPath<EP> };
+
+/**
+ * Infer the result type of an ESI response based on the method and endpoint.
+ * 
+ * @template M - The HTTP method (e.g., "get", "post").
+ * @template EP - The endpoint path.
+ * @deprecated 2025/3/17 12:12:33
+ */
+export type __InferESIResponseResult<
+  M extends TESIEntryMethod,
+  EP extends ESIEndpointOf<M>
+> = TESIResponseOKMap[M][EP] extends { result: infer U } ? U : never;
+/**
+ * Identifies the required parameters for a given entry type.
+ *
+ * @template Entry - The entry type to identify parameters for.
+ * @template Opt - The type of the parameters.
+ * @type {Opt & Pick<Entry, Exclude<keyof Entry, "result">>}
+ * @deprecated 2025/3/17 12:12:33
+ */
+export type __IdentifyParameters<
+  Entry, Opt,
+  Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+  // @ts-expect-error 
+> = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
+
 
 declare global {
 
   /**
-   * mark a specific property as `required`
+   * Marks specific properties of a type as required.
+   * 
+   * @template T - The original type.
+   * @template K - The keys of the properties to mark as required.
+   * 
+   * @example
+   * ```ts
+   * type Original = { a?: number; b?: string; c: boolean };
+   * type RequiredA = RequireThese<Original, 'a'>;
+   * // Result: { a: number; b?: string; c: boolean }
+   * ```
    */
-  type RequireThese<T, K extends keyof T> = T & Required<Pick<T, K>>;
+  type RequireThese<T, K extends keyof T> = {
+    [P in keyof T]: P extends K ? Required<Pick<T, P>>[P] : T[P];
+  };
 
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   //                                Version 3 types
@@ -125,21 +204,22 @@ declare global {
    * 
    * @param method - The HTTP method to use for the request (e.g., "get", "post").
    * @param endpoint - The real path of the ESI endpoint to send the request to.
-   * @param options - An optional object containing additional options for the request.
+   * @param 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.
    */
   type TESIRequestFunctionSignature2<ActualOpt> = <
     M extends TESIEntryMethod,
-    // "/characters/123/fittings/456/"
-    RealEP extends ReplacePathParams<keyof TESIResponseOKMap[M] & string> | keyof TESIResponseOKMap[M],
-    // "/characters/{character_id}/fittings/{fitting_id}/"
-    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>,
-    HasOpt = HasRequireParams<TESIResponseOKMap[M][EP]> extends never ? 0 : 1
+    RealEP extends ReplacePathParams<ESIEndpointOf<M>> | ESIEndpointOf<M>,
+    EPx extends ResolvedEndpoint<RealEP, M>,
+    PathParams extends InferPathParams<RealEP, EPx>,
+    Opt extends IdentifyParameters<M, EPx, ActualOpt & PathParams>,
+    R extends InferESIResponseResult<M, EPx>,
+    HasOpt = HasRequireParams<M, EPx, PathParams>,
   >(method: M, endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
 
   /**
@@ -157,88 +237,149 @@ declare global {
    * @template R - The response type.
    *
    * @param endpoint - The real path of the ESI endpoint to send the request to.
-   * @param options - An optional object containing additional options for the request.
+   * @param 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.
    */
   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>,
-    HasOpt = HasRequireParams<TESIResponseOKMap[M][EP]> extends never ? 0 : 1
+    RealEP extends ReplacePathParams<ESIEndpointOf<M>> | ESIEndpointOf<M>,
+    EPx extends ResolvedEndpoint<RealEP, M>,
+    PathParams extends InferPathParams<RealEP, EPx>,
+    Opt extends IdentifyParameters<M, EPx, ActualOpt & PathParams>,
+    R extends InferESIResponseResult<M, EPx>,
+    HasOpt = HasRequireParams<M, EPx, PathParams>,
   >(endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
 
   /**
    * Replaces path parameters in a string with numbers.
    * 
    * @template T - The string representing the endpoint path.
+   * @type {string}
    * @example
    * ```ts
    * type Example = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
    * // Result: `/characters/${number}/fittings/${number}/`
    * ```
    */
-  type ReplacePathParams<T extends string> = T extends `${infer Start}{${infer Param}}${infer End}`
+  type ReplacePathParams<T extends unknown> = T extends `${infer Start}{${infer Param}}${infer End}`
     ? `${Start}${number}${ReplacePathParams<End>}` : T;
-
-  // // type Example = ReplacePathParamsX<"/characters/1234/fittings/{fitting_id}/">;
+  // type XEPP = ESIEndpointOf<"delete">
+  // // incomplete
+  // type Example2 = ReplacePathParams<"/characters/1234/fittings/{fitting_id}/">;
   // // Result: `characters/${number}/fittings/${number}/`
-  // type ReplacePathParamsX<T extends string> =
-  //   T extends `/${infer Start}/${infer Param}/${infer End}` ? `${Start}/${number}/${ReplacePathParams<End>}`
-  //   : T;
+  // type Example3 = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
+
   /**
-   * Determines if the endpoint requires path parameters.
+   * Infers the path parameters based on the real endpoint and the resolved endpoint.
    * 
-   * @template EP - The string representing the endpoint path.
-   * @returns {TPathParamsNever | { pathParams: IfParameterizedPath<EP> }}
-   * Returns an object with `pathParams` if the endpoint requires parameters, otherwise returns `TPathParamsNever`.
-   * @example
-   * ```ts
-   * type Example = IfNeedPathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
-   * // Result: { pathParams: [number, number] }
-   * ```
+   * @template RealEP - The real endpoint path.
+   * @template EPx - The resolved endpoint path.
+   * @returns {TPathParamsNever | _IfNeedPathParams<EPx>}
+   * @see {@link _IfNeedPathParams}
+   * @see {@link TPathParamsNever}
+   * @date 2025/3/17 4:32:47
    */
-  type IfNeedPathParams<EP> = IfParameterizedPath<EP> extends never ? TPathParamsNever :
-    EP extends ReplacePathParams<EP> ? TPathParamsNever : { pathParams: IfParameterizedPath<EP> };
+  type InferPathParams<
+    RealEP extends unknown, EPx extends unknown
+  > = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
+
   /**
-   * Infers the original endpoint path from a real endpoint path.
+   * 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.
    * 
    * @template RealEP - The real endpoint path.
-   * @returns {string} The original endpoint path with parameters.
+   * @template M - The HTTP method to use for the request.
+   * @template Endpoints - The possible endpoints for the given method.
+   * 
    * @example
    * ```ts
-   * type EPOrigin = InferEndpointOrigin<"/characters/123/fittings/456/", TEndPointDelete>;
+   * type Original = InferEndpointOrigin<"/characters/123/fittings/456/", "delete">;
    * // Result: "/characters/{character_id}/fittings/{fitting_id}/"
    * ```
+   * @see {@link ESIEndpointOf}
+   * @see {@link ReplacePathParams}
    */
-  type InferEndpointOrigin<RealEP extends unknown, Endpoints> = {
+  type InferEndpointOrigin<
+    RealEP extends unknown, M extends TESIEntryMethod,
+    Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>
+  > = {
     [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
       ? EP : never;
   }[Endpoints];
-  // type InferEndpointOrigin<RealEP extends string> = {
-  //   [Method in TESIEntryMethod]: {
-  //     [EP in keyof TESIResponseOKMap[Method]]: RealEP extends ReplacePathParams<EP>
-  //       ? EP : never;
-  //   }[keyof TESIResponseOKMap[Method]]
-  // }[TESIEntryMethod];
+  /**
+   * Determines the resolved endpoint based on the real endpoint and the method.
+   * 
+   * @template RealEP - The real endpoint path.
+   * @template M - The HTTP method to use for the request.
+   * 
+   * @example
+   * ```ts
+   * type Resolved = ResolvedEndpoint<"/characters/123/fittings/456/", "delete">;
+   * // Result: "/characters/{character_id}/fittings/{fitting_id}/"
+   * ```
+   * DONE: 2025/3/17 4:12:09 Ok, works
+   * 
+   * @see {@link InferEndpointOrigin}
+   */
+  type ResolvedEndpoint<
+    RealEP extends unknown, M extends TESIEntryMethod,
+  > = InferEndpointOrigin<RealEP, M> extends never ? RealEP: InferEndpointOrigin<RealEP, M>;
 
   /**
-   * Determines if the given entry has required parameters.
+   * 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.
+   * 
+   * @template M - The HTTP method to use for the request.
+   * @template EPx - The endpoint path.
+   * @template AdditionalParams - Additional parameters to include in the check.
+   * @template Entry - The entry type to pick parameters from.
+   * 
+   * @example
+   * ```ts
+   * type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
+   * type RequiredParams = PickRequireParams<"get", "/example/endpoint", { auth: string }, ExampleEntry>;
+   * // Result: "auth"
+   * ```
+   * @see {@link ESIEndpointOf}
+   * @see {@link _ESIResponseType}
+   */
+  type PickRequireParams<
+    M extends TESIEntryMethod,
+    EPx extends ESIEndpointOf<M> | string,
+    AdditionalParams,
+    Entry = _ESIResponseType<M, EPx>
+  > = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">;
+  /**
+   * 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.
    * 
-   * @template Entry - The entry type to check for required parameters.
+   * @template M - The HTTP method to use for the request.
+   * @template EPx - The endpoint path.
+   * @template AdditionalParams - Additional parameters to include in the check.
    * 
    * @example
    * ```ts
    * type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-   * type HasRequired = HasRequireParams<ExampleEntry>; // "auth"
+   * type HasRequired = HasRequireParams<"get", "/example/endpoint", { auth: string }>; // 1
    * ```
+   * @see {@link ESIEndpointOf}
+   * @see {@link PickRequireParams}
    */
-  type HasRequireParams<Entry> = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">;
+  type HasRequireParams<
+    M extends TESIEntryMethod,
+    EPx extends ESIEndpointOf<M> | string,
+    AdditionalParams,
+  > = PickRequireParams<M, EPx, AdditionalParams> extends never ? 0 : 1;
 
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   //                                Version 2 types
@@ -251,41 +392,76 @@ declare global {
    * @returns {number | [number, number] | Opt} 
    * Returns `number` if there is one parameter, `[number, number]` if there are two parameters, otherwise `Opt`.
    */
-  type IfParameterizedPath<EP, Opt = never> = EP extends `${string}/{${string}}${string}`
+  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;
 
   /**
-   * Identifies the required parameters for a given entry type.
+   * 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.
    *
+   * @template M - The HTTP method to use for the request.
+   * @template EPx - The endpoint path.
+   * @template Opt - The type of the additional options.
    * @template Entry - The entry type to identify parameters for.
-   * @template Opt - The type of the parameters.
-   * @type {Opt & Pick<Entry, Exclude<keyof Entry, "result">>}
+   * @template Keys - The keys of the entry type that are required parameters.
+   * 
+   * @example
+   * ```ts
+   * 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 }
+   * ```
+   * @see {@link RequireThese}
+   * @see {@link ESIEndpointOf}
+   * @see {@link _ESIResponseType}
    */
   //* ctt
   type IdentifyParameters<
-    Entry, Opt,
+    M extends TESIEntryMethod,
+    EPx extends ESIEndpointOf<M> | string,
+    Opt extends Record<string, unknown>,
+    Entry = _ESIResponseType<M, EPx>,
     Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+    // @ts-expect-error 
   > = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
   /*/
   type IdentifyParameters<
     Entry, Opt,
-    Keys = Exclude<keyof Entry, "result">
-  > = Opt & (Keys extends keyof Entry ? Pick<Entry, Keys> : {});
+    Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+    // @ts-expect-error 
+  > = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
+  // type IdentifyParameters<
+  //   Entry, Opt,
+  //   Keys = Exclude<keyof Entry, "result">
+  // > = Opt & (Keys extends keyof Entry ? Pick<Entry, Keys> : {});
   //*/
 
   /**
-   * Infer the result type of an ESI response based on the method and endpoint.
+   * Infers the result type of an ESI response based on the method and endpoint.
+   * 
+   * @template M - The HTTP method to use for the request.
+   * @template EPx - The endpoint path.
    * 
-   * @template M - The HTTP method (e.g., "get", "post").
-   * @template EP - The endpoint path.
+   * @example
+   * ```ts
+   * type Result = InferESIResponseResult<"get", "/characters/{character_id}/">;
+   * // Result: The inferred type of the response for the given method and endpoint.
+   * ```
+   * @see {@link ESIEndpointOf}
+   * @see {@link _ESIResponseType}
    */
   type InferESIResponseResult<
     M extends TESIEntryMethod,
-    EP extends keyof TESIResponseOKMap[M]
-  > = TESIResponseOKMap[M][EP] extends { result: infer U } ? U : never;
+    EPx extends ESIEndpointOf<M> | string
+  > = _ESIResponseType<M, EPx> extends { result: infer U } ? U : never;
+  /*
+  */
 
   /**
    * Represents a response with no content (HTTP status 204).
@@ -301,22 +477,26 @@ declare global {
    */
   type TESIEntryMethod = keyof TESIResponseOKMap;
 
+  /**
+   * @date 2025/3/16 21:45:50
+   */
+  type ESIEndpointOf<M extends TESIEntryMethod> = keyof TESIResponseOKMap[M];
   /**
    * Represents the endpoints for the "get" method.
    */
-  type TEndPointGet = keyof TESIResponseOKMap["get"];
+  type TEndPointGet = ESIEndpointOf<"get">;
   /**
    * Represents the endpoints for the "post" method.
    */
-  type TEndPointPost = keyof TESIResponseOKMap["post"];
+  type TEndPointPost = ESIEndpointOf<"post">;
   /**
    * Represents the endpoints for the "put" method.
    */
-  type TEndPointPut = keyof TESIResponseOKMap["put"];
+  type TEndPointPut = ESIEndpointOf<"put">;
   /**
    * Represents the endpoints for the "delete" method.
    */
-  type TEndPointDelete = keyof TESIResponseOKMap["delete"];
+  type TEndPointDelete = ESIEndpointOf<"delete">;
 
   /**
    * Represents the entry details for the "get" method.

package/v2/response-map.d.ts

@@ -9,7 +9,7 @@
  * THIS DTS IS AUTO GENERATED, DO NOT EDIT
  * 
  * @file eve-esi-types/v2/response-map.d.ts
- * @summary This file is auto-generated and defines version 3.0.3 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.0 of the EVE Online ESI response types.
  */
 import "./types-index.d.ts";
 

package/v2/types-index.d.ts

@@ -9,7 +9,7 @@
  * THIS DTS IS AUTO GENERATED, DO NOT EDIT
  * 
  * @file eve-esi-types/v2/types-index.d.ts
- * @summary This file is auto-generated and defines version 3.0.3 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.0 of the EVE Online ESI response types.
  */
 import "./get_wars_ok.d.ts";
 import "./get_status_ok.d.ts";