eve-esi-types 3.1.2 → 3.1.4

package/lib/request-api.mjs

@@ -70,7 +70,7 @@ export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endp
 //
 /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
     request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, util.ESIRequestOptions>} */ ((endpoint, opt) => {
-        // @ts-expect-error TODO: ts(2345)
-        return request2(method, endpoint, opt);
+        // @ts-expect- error TODO: ts(2345)
+        return request2(method, endpoint, /** @type {Parameters<typeof request2>[2]} */ (opt));
     });
 });

package/lib/rq-util.d.mts

@@ -37,14 +37,6 @@ export type ESIRequestOptions = {
      * will need it for `POST` request etc.
      */
     body?: any;
-    /**
-     * cancel request immediately
-     */
-    cancelable?: AbortController;
-    /**
-     * Can be an empty object if no authentication is required.description
-     */
-    token?: TAcccessToken;
     /**
      * whether an authorization header is required
      *
@@ -57,7 +49,15 @@ export type ESIRequestOptions = {
      * @date 2025/3/13
      * @since v3.0.0
      */
-    pathParams?: number | number[];
+    pathParams?: number | [number, number];
+    /**
+     * Can be an empty object if no authentication is required.description
+     */
+    token?: TAcccessToken;
+    /**
+     * cancel request immediately
+     */
+    cancelable?: AbortController;
 };
 /**
  * @typedef {string | number | boolean} Truthy
@@ -141,7 +141,7 @@ export declare const initOptions: (method: string, opt: ESIRequestOptions) => {
  * fetch the extra pages
  *
  *   + if the `x-pages` header property ware more than 1
- * @template {any} T
+ * @template {unknown} T
  * @param {string} endpointUrl
  * @param {RequestInit} rqopt request options
  * @param {URLSearchParams} usp queries
@@ -181,22 +181,11 @@ export declare function getLogger(): {
     clog: (...args: any[]) => void;
     rlog: (...args: any[]) => void;
 };
-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";
- * @typedef {ESI.TESIResponseOKMap} TESIResponseOKMap
- * @typedef {ESI.TPathParamsNever} TPathParamsNever
- * @typedef {ESI.IESIRequestFunction2<ESIRequestOptions>} IESIRequestFunction2
- * @typedef {ESI.TESIRequestFunctionMethods2<ESIRequestOptions>} TESIRequestFunctionMethods2
- */
+type TPrependParams = TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>;
 /**
  * #### Fire a request that does not require authentication.
  *
- * @param {TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2} fn
+ * @param {TPrependParams} fn
  * @returns {Promise<void>}
  */
-export declare function fireRequestsDoesNotRequireAuth(fn: TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2<ESIRequestOptions>): Promise<void>;
+export declare function fireRequestsDoesNotRequireAuth(fn: TPrependParams): Promise<void>;

package/lib/rq-util.mjs

@@ -228,7 +228,7 @@ export const initOptions = (method, opt) => {
  * fetch the extra pages
  *
  *   + if the `x-pages` header property ware more than 1
- * @template {any} T
+ * @template {unknown} T
  * @param {string} endpointUrl
  * @param {RequestInit} rqopt request options
  * @param {URLSearchParams} usp queries
@@ -320,55 +320,37 @@ 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">;
-/*/
-//*/
+/**
+ * Need typescript v5.5 later
+ * @import * as ESI from "../v2";
+ * @typedef {ESI.TESIRequestFunctionMethods2<ESIRequestOptions>} TESIRequestFunctionMethods2
+ */
+/**
+ * @typedef {TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2} TPrependParams
+ */
 /**
  * #### Fire a request that does not require authentication.
  *
- * @type {import("./rq-util.d.mts").TFireWithoutAuth}
+ * @type {TESIEnhancedRequestFunctionSignature<TPrependParams, ESIRequestOptions>}
  */
-// @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, arg);
+        const arg = opt.length ? opt[0] : void 0;
+        return fn(method, endpoint, /** @type {Parameters<typeof fn>[2]} */ (arg));
     }
     // @ts-expect-error TODO: ts(2345) The argument type does not match the type of the specified parameter
-    return fn[method](endpoint, arg);
+    return fn[method](endpoint, ...opt);
 };
-/**
- * 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
- */
+const token = `token.token.token`;
 /**
  * #### Fire a request that does not require authentication.
  *
- * @param {TESIRequestFunctionSignature2<ESIRequestOptions> | TESIRequestFunctionMethods2} fn
+ * @param {TPrependParams} fn
  * @returns {Promise<void>}
  */
 export async function fireRequestsDoesNotRequireAuth(fn) {
     const { clog, rlog } = getLogger();
+    const ID_SomeEVECharacter = 90000;
     const ID_CCP_Zoetrope = 2112625428;
     try {
         // - - - - - - - - - - - -
@@ -378,6 +360,7 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
         clog();
         casefireWithoutAuth: {
             await fireWithoutAuth(fn, "get", `/characters/{character_id}/`, {
+                // auth: true, // ✅ At this point, the expected semantic error is successfully triggered as intended.
                 pathParams: ID_CCP_Zoetrope
             }).then(log);
             clog('(portrait)');
@@ -392,12 +375,15 @@ export async function fireRequestsDoesNotRequireAuth(fn) {
             if (is("withError")) {
                 await fireWithoutAuth(fn, "get", "/characters/{character_id}/assets/", {
                     auth: true,
-                    pathParams: 12354
+                    pathParams: ID_SomeEVECharacter,
+                    token
+                }).then(assets => {
+                    log(assets.slice(0, 5));
                 });
                 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);
+                    auth: true,
+                    // pathParams: [1234, 56789], // ✅ At this point, the expected semantic error is successfully triggered as intended.
+                }).catch(log);
             }
         }
         // - - - - - - - - - - - -
@@ -429,20 +415,21 @@ 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/${ID_CCP_Zoetrope}/ship/`, {
+        let willFailed = await fireWithoutAuth(fn, "get", `/characters/${ID_SomeEVECharacter}/ship/`, {
             auth: true,
-            token: "token.token.token"
+            token //: "token.token.token"
         });
-        log(`get:/characters/${ID_CCP_Zoetrope}/ship/, returns=${willFailed}`);
+        log(`get:/characters/${ID_SomeEVECharacter}/ship/, returns:`, willFailed);
         // in this case, "categories" and "search" is required
         await fireWithoutAuth(fn, "get", "/characters/{character_id}/search/", {
-            pathParams: ID_CCP_Zoetrope,
+            pathParams: ID_SomeEVECharacter,
             query: {
-                categories: ["agent"],
-                search: "ok"
+                categories: ["inventory_type"],
+                search: "plex"
             },
-            auth: true
-        });
+            auth: true,
+            token
+        }).then(log);
         // // 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/", {

package/minimal-rq.mjs

@@ -29,8 +29,8 @@ const log = util.getUniversalLogger("[request-mini]: ");
 const esiMethods = /** @type {TESIRequestFunctionMethods2} */ ({});
 /** @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);
+        // @ts-expect -error ts(2345)
+        return request2(method, endpoint, /** @type {Parameters<typeof request2>[2]} */ (opt));
     });
 });
 // It should complete correctly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-esi-types",
-  "version": "3.1.2",
+  "version": "3.1.4",
   "description": "Extracted the main type of ESI. use for ESI request response types (version 2 only)",
   "main": "v2/index.d.ts",
   "scripts": {

package/tagged-rq.mjs

@@ -44,7 +44,7 @@ if (util.is("withError")) {
         // token: "s.s.s"
     })).then(console.log).catch(console.log);
     esi.fittings.delete("/characters/1234/fittings/56789/", {
-        pathParams: [1234, 56789], // ⚠️ TODO: A semantics error should be deliberately caused here
+        // pathParams: [1234, 56789], // ✅ At this point, the expected semantic error is successfully triggered as intended.
         auth: true
     });
     esi.character.post("/characters/affiliation/", {

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

@@ -9,7 +9,7 @@
  * 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.1.1 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.4 of the EVE Online ESI response types.
  */
 import { TESIResponseOKMap } from "./index.d.ts";
 export * from "./index.d.ts";
@@ -121,7 +121,7 @@ export declare type TaggedEndpointRequestFunction2<
     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>,
+    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>;

package/v2/index.d.ts

@@ -9,7 +9,7 @@
  * 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.1.1 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.4 of the EVE Online ESI response types.
  */
 import type { TESIResponseOKMap } from "./response-map.d.ts";
 export type { TESIResponseOKMap } from "./response-map.d.ts";
@@ -36,7 +36,7 @@ import type { PickPathParameters, InferKeysLen } from "./util.d.ts";
  * });
  * ```
  */
-export interface IESIRequestFunction2<ActualOpt>
+export interface IESIRequestFunction2<ActualOpt extends Record<string, unknown>>
   extends TESIRequestFunctionSignature2<ActualOpt>, TESIRequestFunctionMethods2<ActualOpt> {
 }
 
@@ -63,7 +63,7 @@ export interface IESIRequestFunction2<ActualOpt>
  * });
  * ```
  */
-export type TESIRequestFunctionMethods2<ActualOpt = {}> = {
+export type TESIRequestFunctionMethods2<ActualOpt extends Record<string, unknown>> = {
   [method in TESIEntryMethod]: TESIRequestFunctionEachMethod2<method, ActualOpt>;
 }
 
@@ -163,6 +163,55 @@ export type __IdentifyParameters<
   // @ts-expect-error 
 > = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
 
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//                         Internal types
+//  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+/**
+ * Defines the keys used in ESI entries.
+ */
+type ESIEntryKeys = "auth" | "query" | "body" | "pathParams";
+/**
+ * Restricts the keys of a type to the specified ones while excluding extra keys.
+ *
+ * This utility type is designed to enforce stricter semantics by marking unwanted keys as `never`.
+ *
+ * @template T - The original type to be constrained.
+ * @template T2 - The type to merge with the constrained type.
+ * @template RequireKeys - The keys to retain in the resulting type.
+ * @template Extras - Automatically derived keys to exclude from the resulting type.
+ *
+ * @example
+ * ```ts
+ * type Original = { auth?: string; query?: string; body?: string; pathParams?: string; extra?: string };
+ * type Required = { auth: true; query: { test: "pen" | "pencil" } };
+ * type Restricted = RestrictKeys<Original, Required, "auth" | "query">;
+ * // Result: { auth: true; query: { test: "pen" | "pencil" }; body?: undefined; pathParams?: undefined; extra?: string | undefined }
+ * ```
+ */
+//* ctt
+type RestrictKeys<
+  T, RequireKeys extends keyof T,
+  Extras = Exclude<ESIEntryKeys, RequireKeys>
+> = {
+  [P in keyof T]: P extends Extras ? never : T[P];
+};
+// type RequireEntry = {
+//   auth?: true;
+//   query?: { test: "pen" | "pencil" };
+//   body?: string;
+//   pathParams?: string;
+//   extra?: string
+// };
+// type Restricted = RestrictKeys<RequireEntry, "auth" | "query">;
+/*/
+type RestrictKeys<
+  T, T2,
+  K extends keyof T,
+  Extras = Exclude<ESIEntryKeys, K>
+> = T2 & {
+  [P in keyof T as P extends K ? never : P]: P extends Extras ? never : T[P];
+};
+//*/
 
 declare global {
 
@@ -180,7 +229,9 @@ declare global {
    * ```
    */
   type RequireThese<T, K extends keyof T> = {
-    [P in keyof T]: P extends K ? Required<Pick<T, P>>[P] : T[P];
+    [P in keyof T as P extends K ? P : never]-?: T[P];
+  } & {
+    [P in keyof T as P extends K ? never : P]: T[P];
   };
 
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -212,16 +263,62 @@ declare global {
    * 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> = <
+  type TESIRequestFunctionSignature2<ActualOpt extends Record<string, unknown>> = <
     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>,
+    Opt extends IdentifyParameters<Mtd, EPX, ActualOpt, PPM>,
     Ret extends InferESIResponseResult<Mtd, EPX>,
     HasOpt = HasRequireParams<Mtd, EPX, PPM>,
   >(method: Mtd, endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
 
+  /**
+   * A function signature type for making enhanced ESI requests.
+   *
+   * This type extends the base ESI request function signature by injecting a prepended parameter to allow for extra
+   * context or pre-processing before performing the request. It provides a highly generic interface that adapts to the
+   * chosen endpoint method, endpoint configuration, and additional options, making it ideal for advanced API interactions.
+   *
+   * Generic Parameters:
+   * @template PrependParam - The type of the additional parameter that is injected at the beginning of the function call.
+   * @template ActualOpt - An object representing the default options (typically extending ESIRequestOptions) used for the request.
+   *
+   * Function Generic Parameters:
+   * @template Mtd - The ESI request method type (e.g., GET, POST) as defined in TESIEntryMethod.
+   * @template REP - The endpoint type, which can be either a version with replaced path parameters (via ReplacePathParams)
+   *                 or the raw ESIEndpointOf<Mtd> type.
+   * @template EPX - The resolved endpoint type derived from REP and Mtd.
+   * @template PPM - The type representing the inferred path parameters extracted from REP and EPX.
+   * @template Opt - The type for additional request options, identified based on the method (Mtd), endpoint (EPX), the
+   *                 default options (ActualOpt), and inferred path parameters (PPM).
+   * @template Ret - The type of the response result from the ESI request, inferred from the method and endpoint.
+   * @template HasOpt - An internal flag used to determine whether request options (Opt) are required (1) or optional.
+   *
+   * Parameters:
+   * @param {PrependParam} prependParam - A prepended parameter providing additional context or configuration for the request.
+   * @param {Mtd} method - The ESI request method.
+   * @param {REP} endpoint - The API endpoint, which might include path parameter replacements.
+   * @param {...(HasOpt extends 1 ? [Opt] : [Opt?])} options - Additional options for the request; required if HasOpt is 1,
+   *   otherwise optional.
+   *
+   * @returns {Promise<Ret>} A promise that resolves with the result type `Ret`, representing the response data from the ESI endpoint.
+   */
+  type TESIEnhancedRequestFunctionSignature<
+    PrependParam extends unknown, ActualOpt extends Record<string, unknown>
+  > = <
+    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>
+  >(
+    prependParam: PrependParam,
+    method: Mtd, endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]
+  ) => Promise<Ret>;
+
   /**
    * Represents a function that can make ESI requests for a specific HTTP method.
    *
@@ -245,13 +342,13 @@ declare global {
    * 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<Mtd extends TESIEntryMethod, ActualOpt = {}> = <
+  type TESIRequestFunctionEachMethod2<Mtd extends TESIEntryMethod, ActualOpt extends Record<string, unknown>> = <
     REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
     EPX extends ResolvedEndpoint<REP, Mtd>,
     PPM extends InferPathParams<REP, EPX>,
-    Opt extends IdentifyParameters<Mtd, EPX, ActualOpt & PPM>,
+    Opt extends IdentifyParameters<Mtd, EPX, ActualOpt, PPM>,
     Ret extends InferESIResponseResult<Mtd, EPX>,
-    HasOpt = HasRequireParams<Mtd, EPX, PPM>,
+    HasOpt extends HasRequireParams<Mtd, EPX, PPM> = HasRequireParams<Mtd, EPX, PPM>,
   >(endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
 
   /**
@@ -408,7 +505,7 @@ declare global {
    * @template EPx - The endpoint path.
    * @template Opt - The type of the additional options.
    * @template Entry - The entry type to identify parameters for.
-   * @template Keys - The keys of the entry type that are required parameters.
+   * @template RequireKeys - The keys of the entry type that are required parameters.
    * 
    * @example
    * ```ts
@@ -426,20 +523,23 @@ declare global {
     M extends TESIEntryMethod,
     EPx extends ESIEndpointOf<M> | string,
     Opt extends Record<string, unknown>,
-    Entry = _ESIResponseType<M, EPx>,
-    Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
+    AdditionalParams,
+    Entry = _ESIResponseType<M, EPx> & AdditionalParams,
+    RequireKeys = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">
     // @ts-expect-error 
-  > = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
+  > = RestrictKeys<Opt, RequireKeys> & Pick<Entry, RequireKeys> & AdditionalParams;
   /*/
+  // DEVNOTE: 2025/3/24
+  // The definition is simple and highly maintainable, but it is not possible to reference the `pathParams` property when implementing `TESIRequestFunctionSignature2` etc.
   type IdentifyParameters<
-    Entry, Opt,
-    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> : {});
+    M extends TESIEntryMethod,
+    EPx extends ESIEndpointOf<M> | string,
+    Opt extends Record<string, unknown>,
+    AdditionalParams,
+    Entry = _ESIResponseType<M, EPx>,
+    Keys = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">
+    // @ts-expect- error 
+  > = RestrictKeys<Opt, Pick<Entry, Keys> & AdditionalParams, Keys>;
   //*/
 
   /**

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.1.1 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.4 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.1.1 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.4 of the EVE Online ESI response types.
  */
 import "./get_wars_ok.d.ts";
 import "./get_status_ok.d.ts";