eve-esi-types 3.2.6 → 3.2.8

package/dist/v2/index.d.ts

@@ -9,14 +9,16 @@
  * 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.2.5 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.2.8 of the EVE Online ESI response types.
  */
 import type { TESIResponseOKMap } from "./response-map.d.ts";
-import type { PickPathParameters, InferKeysLen, CombineIntersection } from "./util.d.ts";
+import type { PickPathParameters, InferKeysLen, CombineIntersection, ExtractPathParamKeys } from "./util.d.ts";
 import type {
+  ESIEntryParamKeys, ESIEntryExtraKeys,
   _ESIResponseType,
   _IfNeedPathParams,
   TPathParamsNever,
+  ResolveEndpointParameters
   // ESIEndpointUnions,
   // IESIRequestFunction2,
   // InferESIResponseResultEX,
@@ -31,19 +33,15 @@ export type * from "./util.d.ts";
 //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 //                         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.
+ * @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
@@ -57,7 +55,7 @@ type ESIEntryKeys = "auth" | "query" | "body" | "pathParams";
 // incomplete
 export type RestrictKeys<
   T, RequireKeys/*  extends keyof T */,
-  Extras = Exclude<ESIEntryKeys, RequireKeys>
+  Extras = Exclude<ESIEntryParamKeys, RequireKeys>
 > = {
   [P in keyof T]: P extends Extras ? never : T[P];
 };
@@ -70,13 +68,13 @@ export type RestrictKeys2<
   {
     [RQ in keyof T as RQ extends RequireKeys ? RQ : never]-?: T[RQ];
   } &
-  // 2. Exclude extra keys from ESIEntryKeys and assign `never`
+  // 2. Exclude extra keys from ESIEntryParamKeys and assign `never`
   {
-    [Extra in ESIEntryKeys as Extra extends Extras ? Extra : never]?: never;
+    [Extra in ESIEntryParamKeys as Extra extends Extras ? Extra : never]?: never;
   } &
-  // 3. Include remaining keys (not in ESIEntryKeys) as optional with their original types
+  // 3. Include remaining keys (not in ESIEntryParamKeys) as optional with their original types
   {
-    [Other in keyof T as Other extends Extras ? (Other extends ESIEntryKeys ? never : Other) : never]?: T[Other];
+    [Other in keyof T as Other extends Extras ? (Other extends ESIEntryParamKeys ? never : Other) : never]?: T[Other];
   }
 ) extends infer O
     // Flatten the intersected type into a single object
@@ -91,8 +89,8 @@ declare global {
   /**
    * Marks specific properties of a type as required.
    * 
-   * @template T - The original type.
-   * @template K - The keys of the properties to mark as required.
+   * @template T The original type.
+   * @template K The keys of the properties to mark as required.
    * 
    * @example
    * ```ts
@@ -112,141 +110,216 @@ declare global {
   //                                Version 3 types
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   /**
-   * ### ESI request function with real endpoint signature
-   * 
-   * 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.
-   * 
-   * @template ActualOpt - The actual type of the option.
-   * @template Mtd - The HTTP method to use for the request
-   * @template REP - The real path of the ESI endpoint to send the request to
-   * @template EPX - The parameterized path of the ESI endpoint to send the request to
-   * @template PPM - Parameters to include in the request if the endpoint is parameterized
-   * @template Opt - Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`
-   * @template Ret - The response type
-   * 
+   * Defines the function signature for making ESI requests to specific endpoints.
+   *
+   * This utility type provides a strongly-typed function signature for interacting with ESI endpoints.  
+   * It ensures type safety by inferring the required parameters, options, and response types for the given endpoint.
+   *
+   * @template ActualOpt - A record type representing additional options for the request.
+   * @template Mtd - The HTTP method (e.g., "get", "post") to use for the request.
+   * @template REP - The real path of the ESI endpoint to send the request to.
+   * @template EPO - The parameterized path of the ESI endpoint (e.g., `/characters/{character_id}/assets/`).
+   * @template Params - The resolved parameters for the endpoint, including path parameters and user-supplied options.
+   * @template Opt - The final options object to include in the request.
+   * @template Ret - The response type of the endpoint.
+   *
    * @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. 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.
-   * 
+   *
+   * @returns A `Promise` that resolves to the response type of the 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.
+   * - The `...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]` parameter ensures that if the endpoint has required parameters,  
+   *   the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
+   * - This type leverages `ResolveEndpointParameters` to infer the required options and response type.
+   *
+   * @example
+   * ```ts
+   * // Example: Making a request to the "get" method for a specific endpoint
+   * type ESIRequest = TESIRequestFunctionSignature2<ESIRequestOptions>;
+   * const runRequest: ESIRequest = async (method, endpoint, ...options) => {
+   *     // Implementation here
+   *     throw new Error();
+   * };
+   * runRequest("get", "/characters/{character_id}/assets/", {
+   *     pathParams: 12345,
+   *     auth: true,
+   *     token: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
+   * }).then(response => {
+   *     console.log(response);
+   * });
+   * ```
+   *
+   * @see {@link ResolveEndpointParameters}
+   * @see {@link InferESIResponseResult}
    */
+  /* ctt
   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>,
-    Ret extends InferESIResponseResult<Mtd, EPX>,
-    HasOpt = HasRequireParams<Mtd, EPX, PPM>,
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    PPM extends InferPathParams<REP, EPO>,
+    Opt extends IdentifyParameters<Mtd, EPO, ActualOpt, PPM>,
+    Ret extends InferESIResponseResult<Mtd, EPO>,
+    HasOpt = HasRequireParams<Mtd, EPO, PPM>,
   >(method: Mtd, endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
-
-  
-  type TESIRequestFunctionContext<
-    Mtd extends TESIEntryMethod = TESIEntryMethod,
-    REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd> = ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
-    ActualOpt extends Record<string, unknown> = Record<string, unknown>,
-
-    EPX extends ResolvedEndpoint<REP, Mtd> = ResolvedEndpoint<REP, Mtd>,
-    PPM extends InferPathParams<REP, EPX> = InferPathParams<REP, EPX>,
-    Opt extends IdentifyParameters<Mtd, EPX, ActualOpt, PPM> = IdentifyParameters<Mtd, EPX, ActualOpt, PPM>,
-    Ret extends InferESIResponseResult<Mtd, EPX> = InferESIResponseResult<Mtd, EPX>,
-    HasOpt = HasRequireParams<Mtd, EPX, PPM>,
-  > = {
-    method: Mtd; endpoint: REP;
-  } & (HasOpt extends 1 ? { options: Opt } : { options?: Opt }) & {
-    result?: Ret;
-  };
+  /*/
+  type TESIRequestFunctionSignature2<ActualOpt extends Record<string, unknown>> = <
+    Mtd extends TESIEntryMethod,
+    REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    Params extends ResolveEndpointParameters<Mtd, REP, EPO, ActualOpt>,
+    Opt extends Params["finalOptions"],
+    // Ret extends Params["result"],
+  >(method: Mtd, endpoint: REP, ...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]) => Promise<Params["result"]>;
+  //*/
 
   /**
-   * A function signature type for making enhanced ESI requests.
+   * Defines an enhanced function signature for making ESI requests with an additional prepended parameter.
    *
-   * 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.
+   * This utility type extends the base ESI request function signature by adding a prepended parameter
+   * to allow for extra context or pre-processing before performing the request. It ensures type safety
+   * by inferring the required parameters, options, and response types for the given endpoint.
    *
-   * 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.
+   * @template ActualOpt - A record type representing additional options for the request.
+   *
+   * @param prependParam - A prepended parameter providing additional context or configuration for the request.
+   * @param method - The HTTP method to use for the request (e.g., "get", "post").
+   * @param endpoint - The API endpoint, which might include path parameter replacements.
+   * @param options - Additional options for the request. If the endpoint has required parameters, this parameter must be provided.
    *
-   * 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.
+   * @returns A `Promise` that resolves to the response type of the endpoint.
    *
-   * 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.
+   * @remarks
+   * - The `...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]` parameter ensures that if the endpoint has required parameters,  
+   *   the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
+   * - This type leverages `ResolveEndpointParameters` to infer the required options and response type.
+   *
+   * @example
+   * ```ts
+   * // Example: Making a request with an additional prepended parameter
+   * type EnhancedRequest = TESIEnhancedRequestFunctionSignature<
+   *     { userId: string },
+   *     ESIRequestOptions
+   * >;
+   * const fetchWithContext: EnhancedRequest = async (context, method, endpoint, ...options) => {
+   *     console.log(`User ID: ${context.userId}`);
+   *     // Implementation here
+   *     throw new Error();
+   * };
+   * fetchWithContext(
+   *     { userId: "12345" },
+   *     "get",
+   *     "/characters/{character_id}/assets/",
+   *     {
+   *         pathParams: 12345,
+   *         auth: true,
+   *         token: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
+   *     }
+   * ).then(response => {
+   *     console.log(response);
+   * });
+   * ```
    *
-   * @returns {Promise<Ret>} A promise that resolves with the result type `Ret`, representing the response data from the ESI endpoint.
+   * @see {@link ResolveEndpointParameters}
+   * @see {@link InferESIResponseResult}
    * @see Documentation of [`TESIEnhancedRequestFunctionSignature`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/esi-enhanced-function-signature.md)
    */
+  /* ctt
   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>
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    PPM extends InferPathParams<REP, EPO>,
+    Opt extends IdentifyParameters<Mtd, EPO, ActualOpt, PPM>,
+    Ret extends InferESIResponseResult<Mtd, EPO>,
+    HasOpt = HasRequireParams<Mtd, EPO, PPM>,
   >(
     prependParam: PrependParam,
     method: Mtd, endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]
   ) => Promise<Ret>;
+  /*/
+  type TESIEnhancedRequestFunctionSignature<
+    PrependParam extends unknown, ActualOpt extends Record<string, unknown>
+  > = <
+    Mtd extends TESIEntryMethod,
+    REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    Params extends ResolveEndpointParameters<Mtd, REP, EPO, ActualOpt>,
+    Opt extends Params["finalOptions"],
+  >(
+    prependParam: PrependParam,
+    method: Mtd, endpoint: REP,
+    ...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]
+  ) => Promise<Params["result"]>;
+  //*/
 
   /**
-   * Represents a function that can make ESI requests for a specific HTTP method.
+   * Defines the function signature for making ESI requests for a specific HTTP method.
    *
-   * This type is used to define functions that send requests to specific ESI endpoints using a given HTTP method.
+   * This utility type provides a strongly-typed function signature for interacting with ESI endpoints
+   * using a specific HTTP method. It ensures type safety by inferring the required parameters, options,
+   * and response types for the given endpoint.
    *
-   * @template Mtd - The HTTP method to use for the request.
-   * @template ActualOpt - The actual type of the options.
+   * @template Mtd - The HTTP method (e.g., "get", "post") to use for the request.
+   * @template ActualOpt - A record type representing additional options for the request.
    *
-   * @template REP - The real path of the ESI endpoint to send the request to.
-   * @template EPX - The parameterized path of the ESI endpoint to send the request to.
-   * @template PPM - Parameters to include in the request if the endpoint is parameterized.
-   * @template Opt - Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`.
-   * @template Ret - The response type.
+   * @param endpoint - The API endpoint, which might include path parameter replacements.
+   * @param options - Additional options for the request. If the endpoint has required parameters, this parameter must be provided.
    *
-   * @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. If the endpoint has required parameters, this parameter must be provided.
+   * @returns A `Promise` that resolves to the response type of the endpoint.
    *
-   * @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.
+   * - The `...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]` parameter ensures that if the endpoint has required parameters,  
+   *   the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
+   * - This type leverages `ResolveEndpointParameters` to infer the required options and response type.
+   *
+   * @example
+   * ```ts
+   * // Example: Making a request to the "get" method for a specific endpoint
+   * type GetRequest = TESIRequestFunctionEachMethod2<"get", ESIRequestOptions>;
+   * const fireGetRequest: GetRequest = async (endpoint, ...options) => {
+   *     // Implementation here
+   *     throw new Error();
+   * };
+   * fireGetRequest("/characters/{character_id}/assets/", {
+   *     pathParams: 12345,
+   *     auth: true,
+   *     token: "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."
+   * }).then(response => {
+   *     console.log(response);
+   * });
+   * ```
+   *
+   * @see {@link ResolveEndpointParameters}
+   * @see {@link InferESIResponseResult}
    */
+  /* ctt
   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>,
-    Ret extends InferESIResponseResult<Mtd, EPX>,
-    HasOpt extends HasRequireParams<Mtd, EPX, PPM> = HasRequireParams<Mtd, EPX, PPM>,
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    PPM extends InferPathParams<REP, EPO>,
+    Opt extends IdentifyParameters<Mtd, EPO, ActualOpt, PPM>,
+    Ret extends InferESIResponseResult<Mtd, EPO>,
+    HasOpt = HasRequireParams<Mtd, EPO, PPM>,
   >(endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
+  /*/
+  type TESIRequestFunctionEachMethod2<Mtd extends TESIEntryMethod, ActualOpt extends Record<string, unknown>> = <
+    REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
+    EPO extends ResolvedEndpoint<Mtd, REP>,
+    Params extends ResolveEndpointParameters<Mtd, REP, EPO, ActualOpt>,
+    Opt extends Params["finalOptions"],
+  >(endpoint: REP, ...options: Params["optionIsRequire"] extends 1 ? [Opt] : [Opt?]) => Promise<Params["result"]>;
+  //*/
 
   /**
    * Replaces path parameters in a string with numbers.
    * 
-   * @template T - The string representing the endpoint path.
+   * @template T The string representing the endpoint path.
    * @type {string}
    * @example
    * ```ts
@@ -257,7 +330,7 @@ declare global {
    */
   type ReplacePathParams<T extends unknown> = T extends `${infer Start}{${infer Param}}${infer End}`
     ? `${Start}${number}${ReplacePathParams<End>}` : T;
-  // type XEPP = ESIEndpointOf<"delete">
+
   // // incomplete
   // type Example2 = ReplacePathParams<"/characters/1234/fittings/{fitting_id}/">;
   // // Result: `characters/${number}/fittings/${number}/`
@@ -266,17 +339,17 @@ declare global {
   /**
    * Infers the path parameters based on the real endpoint and the resolved endpoint.
    * 
-   * @template RealEP - The real endpoint path.
-   * @template EPx - The resolved endpoint path.
-   * @returns {TPathParamsNever | _IfNeedPathParams<EPx>}
+   * @template RealEP The real endpoint path.
+   * @template EPO (Endpoint Path Origin) The resolved endpoint path.
+   * @returns {TPathParamsNever | _IfNeedPathParams<EPO>}
    * @see {@link _IfNeedPathParams}
    * @see {@link TPathParamsNever}
    * @see Documentation of [`InferPathParams`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/infer-path-params.md)
    * @date 2025/3/17
    */
   type InferPathParams<
-    RealEP extends unknown, EPx extends unknown
-  > = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
+    RealEP extends PropertyKey, EPO extends PropertyKey
+  > = RealEP extends EPO ? _IfNeedPathParams<EPO> : TPathParamsNever;
 
   /**
    * Infers the original endpoint based on the real endpoint and the HTTP method.
@@ -284,9 +357,9 @@ declare global {
    * 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.
-   * @template M - The HTTP method to use for the request.
-   * @template Endpoints - The possible endpoints for the given method.
+   * @template RealEP The real endpoint path.
+   * @template M The HTTP method to use for the request.
+   * @template Endpoints The possible endpoints for the given method.
    * 
    * @example
    * ```ts
@@ -298,7 +371,7 @@ declare global {
    * @see Documentation of [`InferEndpointOrigin`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/infer-endpoint-origin.md)
    */
   type InferEndpointOrigin<
-    RealEP extends unknown, M extends TESIEntryMethod,
+    M extends TESIEntryMethod, RealEP extends PropertyKey,
     Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>
   > = {
     [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
@@ -307,8 +380,8 @@ declare global {
   /**
    * 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.
+   * @template RealEP The real endpoint path.
+   * @template M The HTTP method to use for the request.
    * 
    * @example
    * ```ts
@@ -319,45 +392,19 @@ declare global {
    * @see Documentation of [`ResolvedEndpoint`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/resolved-endpoint.md)
    */
   type ResolvedEndpoint<
-    RealEP extends unknown, M extends TESIEntryMethod,
-  > = InferEndpointOrigin<RealEP, M> extends never ? RealEP: InferEndpointOrigin<RealEP, M>;
-
-  /**
-   * 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}
-   * @see Documentation of [`PickRequireParams`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/pick-require-params.md)
-   */
-  type PickRequireParams<
     M extends TESIEntryMethod,
-    EPx extends ESIEndpointOf<M> | string,
-    AdditionalParams,
-    Entry = _ESIResponseType<M, EPx>
-  > = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">;
+    RealEP extends PropertyKey,
+  > = InferEndpointOrigin<M, RealEP> extends never ? RealEP: InferEndpointOrigin<M, RealEP>;
+
   /**
    * 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 M - The HTTP method to use for the request.
-   * @template EPx - The endpoint path.
-   * @template AdditionalParams - Additional parameters to include in the check.
+   * @template M The HTTP method to use for the request.
+   * @template EPx The endpoint path.
+   * @template PathParams Path parameters to include in the check.
    * 
    * @example
    * ```ts
@@ -365,82 +412,120 @@ declare global {
    * type HasRequired = HasRequireParams<"get", "/example/endpoint", { auth: string }>; // 1
    * ```
    * @see {@link ESIEndpointOf}
-   * @see {@link PickRequireParams}
    * @see Documentation of [`HasRequireParams`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/has-require-params.md)
    */
+  /* ctt
   type HasRequireParams<
     M extends TESIEntryMethod,
     EPx extends ESIEndpointOf<M> | string,
     AdditionalParams,
   > = PickRequireParams<M, EPx, AdditionalParams> extends never ? 0 : 1;
+  /*/
+  type HasRequireParams<
+    M extends TESIEntryMethod,
+    EPx extends ESIEndpointOf<M> | string,
+    PathParams extends Record<string, unknown>,
+    RequireKeys = Exclude<keyof (_ESIResponseType<M, EPx> & PathParams), ESIEntryExtraKeys>
+  > = [RequireKeys] extends [never] ? 0 : 1;
+  //*/
 
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   //                                Version 2 types
   //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   /**
-   * If `EP` (endpoint) is a parameterized path, determines the required number of replacements.
-   * 
-   * @template EP The string representing the endpoint path.
-   * @template Opt The type to return if `EP` is not parameterized.
-   * @returns {number | [number, number] | Opt} 
-   * Returns `number` if there is one parameter, `[number, number]` if there are two parameters, otherwise `Opt`.
-   * @see Documentation of [`IfParameterizedPath`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v2/if-parameterized-path.md)
+   * Determines the number of parameters in a parameterized endpoint path.
+   *
+   * This utility type checks if the given endpoint path contains parameters (e.g., `{param}`) and returns:
+   * - `number` if there is one parameter.
+   * - `[number, number]` if there are two parameters.
+   * - `never` if there are no parameters.
+   *
+   * @template EP - The string representing the endpoint path.
+   * @returns {number | [number, number] | never} The number of parameters in the path.
+   *
+   * @example
+   * ```ts
+   * type SingleParam = IfParameterizedPath<"/characters/{character_id}/">;
+   * // Result: number
+   *
+   * type TwoParams = IfParameterizedPath<"/characters/{character_id}/assets/{asset_id}/">;
+   * // Result: [number, number]
+   *
+   * type NoParams = IfParameterizedPath<"/characters/1234/">;
+   * // Result: 0
+   * ```
+   * @see {@link ExtractPathParamKeys}
    */
-  type IfParameterizedPath<EP extends unknown, Opt = never> = EP extends `${string}/{${string}}${string}`
+  /* ctt
+  type IfParameterizedPath<EP extends PropertyKey> = EP extends `${string}/{${string}}${string}`
     ? PickPathParameters<EP> extends never
-      ? Opt : InferKeysLen<PickPathParameters<EP>> extends 1
+      ? 0 : InferKeysLen<PickPathParameters<EP>> extends 1
         ? number : [number, number]
-      : Opt;
+      : 0;
+  /*/
+  export type IfParameterizedPath<EP extends PropertyKey> =
+    ExtractPathParamKeys<EP> extends []
+      ? 0 : ExtractPathParamKeys<EP> extends [any]
+      ? number : ExtractPathParamKeys<EP> extends [any, any]
+      ? [number, number]
+      : never;
+  //*/
 
   /**
-   * Identifies the required parameters for a given entry type, including additional options.
+   * Identifies and combines the required request parameters for a given ESI entry.
    *
-   * This type combines the required parameters from the entry type and the additional options,
-   * ensuring that all required parameters are marked as required.
+   * Given:
+   * - `Opt`: the shape of user-supplied options (e.g., query/body/path params),
+   * - `_ESIResponseType<M, EPx>`: the expected response payload type for method `M` and endpoint `EPx`,
+   * - `PathParams`: the path parameters for the endpoint,
+   *
+   * this type:
+   * 1. Merges `_ESIResponseType<M, EPx>` with `PathParams` to form `EntryWithParams`.
+   * 2. Excludes extra metadata keys (`result`, `tag`, `cachedSeconds`) from `EntryWithParams`, yielding `RequireKeys`.
+   * 3. Restricts `Opt` to only the keys in `RequireKeys`.
+   * 4. Picks those `RequireKeys` from `EntryWithParams`.
+   * 5. Flattens the intersection into a single parameter object via `CombineIntersection`.
+   *
+   * @template M            The HTTP method (e.g., "get", "post") of the request.
+   * @template EPx          The endpoint path, constrained to `ESIEndpointOf<M>` or `string`.
+   * @template Opt          A record type of user-supplied request options.
+   * @template PathParams   A record type representing path parameters for the endpoint.
+   * @template EntryWithParams  The merged type of response payload and `PathParams`.
+   * @template RequireKeys The keys from `EntryWithParams` that represent actual request parameters.
    *
-   * @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 RequireKeys - 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 }
+   * // /characters/{character_id}/attributes/
+   * type ExampleEntry = { result: GetCharactersCharacterIdAttributesOk; tag: "Skills"; cachedSeconds: 120; auth: true };
+   * type ExampleOpt   = { auth: true; token: "eyJhbGciOiJSUzI1NiIsI..." };
+   * type ExamplePath  = { pathParams: number };
+   *
+   * // Assume _ESIResponseType<"get", "/characters/{character_id}/attributes/"> = ExampleEntry
+   * type IdentifiedParams = IdentifyParameters<
+   *   "get", "/characters/{character_id}/attributes/", ExampleOpt, ExamplePath
+   * >;
+   * // Resolves to: { auth: true; token: "eyJhbGciOiJSUzI1NiIsI..."; pathParams: number; }
    * ```
-   * @see {@link RequireThese}
    * @see {@link ESIEndpointOf}
    * @see {@link _ESIResponseType}
    * @see Documentation of [`IdentifyParameters`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v2/identify-parameters.md)
    */
-  /* ctt
   type IdentifyParameters<
     M extends TESIEntryMethod,
     EPx extends ESIEndpointOf<M> | string,
     Opt extends Record<string, unknown>,
-    PathParams,
+    PathParams extends Record<string, unknown>,
     EntryWithParams = _ESIResponseType<M, EPx> & PathParams,
-    RequireKeys extends keyof EntryWithParams = Exclude<keyof EntryWithParams, "result" | "tag" | "cachedSeconds">
-  > = RestrictKeys<Opt, RequireKeys> & Pick<EntryWithParams, RequireKeys>;
-  /*/
-  type IdentifyParameters<
-    M extends TESIEntryMethod,
-    EPx extends ESIEndpointOf<M> | string,
-    Opt extends Record<string, unknown>,
-    PathParams,
-    EntryWithParams = _ESIResponseType<M, EPx> & PathParams,
-    RequireKeys extends keyof EntryWithParams = Exclude<keyof EntryWithParams, "result" | "tag" | "cachedSeconds">
-  > = CombineIntersection< RestrictKeys<Opt, RequireKeys> & Pick<EntryWithParams, RequireKeys> >;
-  //*/
+    RequireKeys extends keyof EntryWithParams = Exclude<keyof EntryWithParams, ESIEntryExtraKeys>
+  > = CombineIntersection<
+    RestrictKeys<Opt, RequireKeys> & Pick<EntryWithParams, RequireKeys>
+  >;
 
   /**
    * 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 to use for the request.
+   * @template EPx The endpoint path.
    * 
    * @example
    * ```ts
@@ -511,25 +596,25 @@ declare global {
   /**
    * Represents the entry details for the "get" method.
    * 
-   * @template K - The endpoint key.
+   * @template K The endpoint key.
    */
   type TESIResponseGetEntry<K extends TEndPointGet> = TESIResponseOKMap["get"][K];
   /**
    * Represents the entry details for the "put" method.
    * 
-   * @template K - The endpoint key.
+   * @template K The endpoint key.
    */
   type TESIResponsePutEntry<K extends TEndPointPut> = TESIResponseOKMap["put"][K];
   /**
    * Represents the entry details for the "post" method.
    * 
-   * @template K - The endpoint key.
+   * @template K The endpoint key.
    */
   type TESIResponsePostEntry<K extends TEndPointPost> = TESIResponseOKMap["post"][K];
   /**
    * Represents the entry details for the "delete" method.
    * 
-   * @template K - The endpoint key.
+   * @template K The endpoint key.
    */
   type TESIResponseDeleteEntry<K extends TEndPointDelete> = TESIResponseOKMap["delete"][K];
 }