eve-esi-types 3.0.4 → 3.1.2

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.4 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.1 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`
@@ -62,26 +61,51 @@ export declare type ESITags = InferSomethingBy<never, EInferSomethingBy["TAGs"]>
  * @date 2025/2/28
  */
 export declare type InferMethod<Tag> = InferSomethingBy<Tag>
-// type XAssets = InferMethod<"Assets">;
-// type XContacts = InferMethod<"Contacts">;
-// type XPlanetary = InferMethod<"Planetary Interaction">;
+/* ctt
+type XAssets = InferMethod<"Assets">;
+type XContacts = InferMethod<"Contacts">;
+type XPlanetary = InferMethod<"Planetary Interaction">;
+/*/
+//*/
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
 //    Utility Type `TaggedEndpointRequestFunction2`
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
+/**
+ * Infers the endpoint origin based on the provided endpoints.
+ * 
+ *  + Customed InferEndpointOrigin
+ * 
+ * @template RealEP - The real endpoint type.
+ * @template Endpoints - The possible endpoints.
+ * 
+ * @typeParam RealEP - The type of the real endpoint.
+ * @typeParam Endpoints - The type of the possible endpoints.
+ * 
+ * @returns The inferred endpoint origin.
+ */
+type _InferEndpointOrigin<
+  RealEP extends unknown, Endpoints extends string | number | symbol
+> = {
+  [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
+    ? EP : never;
+}[Endpoints];
+
 /**
  * Creates a function type for making requests to tagged endpoints.
  * 
  * @template M - The HTTP method.
  * @template Tag - The tag associated with the endpoint.
  * @template ActualOpt - The actual options for the request.
- * @template EP - The endpoint path.
- * @template P2 - The path parameters.
+ * @template EndPoints - The possible endpoints.
+ * @template REP - The real endpoint path.
+ * @template EPX - The inferred endpoint origin.
+ * @template PPM - The path parameters.
  * @template Opt - The request options.
- * @template R - The response type.
+ * @template Ret - The response type.
+ * @template HasOpt - Indicates if the endpoint has required parameters.
  * 
  * @param endpoint - The endpoint path.
- * @param pathParams - The path parameters.
  * @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.
  * 
@@ -89,16 +113,18 @@ export declare type InferMethod<Tag> = InferSomethingBy<Tag>
  * 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.
  */
-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
-  // RealEPX = ReplacePathParamsX<RealEPX>,
-  // EPX = ReplacePathParams<EP>,
->(endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
+export declare type TaggedEndpointRequestFunction2<
+  M extends TESIEntryMethod, Tag extends ESITags,
+  ActualOpt extends Record<string, unknown> = {},
+  EndPoints extends SelectEndpointByTag<Tag, M> = SelectEndpointByTag<Tag, M>,
+> = <
+    REP extends ReplacePathParams<EndPoints> | EndPoints,
+    EPX extends _InferEndpointOrigin<REP, EndPoints> extends never ? REP: _InferEndpointOrigin<REP, EndPoints>,
+    PPM extends InferPathParams<REP, EPX>,
+    Opt extends IdentifyParameters<M, EPX, ActualOpt & PPM>,
+    Ret extends InferESIResponseResult<M, EPX>,
+    HasOpt = HasRequireParams<M, EPX, PPM>,
+>(endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
 
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -108,9 +134,10 @@ export declare type TaggedEndpointRequestFunction2<M extends TESIEntryMethod, Ta
  * Maps tags to their corresponding endpoint request functions.
  * 
  * @template Tag - The tag to map.
+ * @template ActualOpt - The actual options for the request.
  * @date 2025/2/28
  */
-export declare type ESITaggedEndpointRequest2<Tag extends ESITags, ActualOpt = {}> = {
+export declare type ESITaggedEndpointRequest2<Tag extends ESITags, ActualOpt extends Record<string, unknown> = {}> = {
   [tag in Tag]: {
     [method in InferMethod<Tag>]: TaggedEndpointRequestFunction2<method, tag, ActualOpt>;
   };
@@ -135,14 +162,19 @@ export declare type SelectEndpointByTag<
       ? EP : never
     : never;
 }[keyof TESIResponseOKMap[M]];
-// type XAssetsEndpointGet = SelectEndpointByTag<"Assets", "get">;
-// type XAssetsEndpointPost = SelectEndpointByTag<"Assets", "post">;
+/* ctt
+type XAssetsEndpointGet = SelectEndpointByTag<"Assets", "get">;
+type XAssetsEndpointPost = SelectEndpointByTag<"Assets", "post">;
+/*/
+//*/
 
 /**
  * Maps lower camel case tags to their corresponding endpoint request functions.
+ * 
+ * @template ActualOpt - The actual options for the request.
  * @date 2025/3/12
  */
-export declare type TaggedESIRequestMap2<ActualOpt = {}> = {
+export declare type TaggedESIRequestMap2<ActualOpt extends Record<string, unknown> = {}> = {
   [tag in ESITags as LCamelCase<tag>]: ESITaggedEndpointRequest2<tag, ActualOpt>;
 };
 

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.4 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.1.1 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
@@ -116,12 +195,12 @@ declare global {
    * This function sends a request to a specified endpoint and returns a response.
    * 
    * @template ActualOpt - The actual type of the option.
-   * @template M - The HTTP method to use for the request
-   * @template RealEP - The real path of the ESI endpoint to send the request to
-   * @template EP - The parameterized path of the ESI endpoint to send the request to
-   * @template PathParams - Parameters to include in the request if the endpoint is parameterized
+   * @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 R - The response type
+   * @template Ret - The response type
    * 
    * @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.
@@ -134,31 +213,28 @@ declare global {
    * 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
-  >(method: M, endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
+    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>,
+  >(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.
    *
    * This type is used to define functions that send requests to specific ESI endpoints using a given HTTP method.
    *
-   * @template M - The HTTP method to use for the request.
+   * @template Mtd - The HTTP method to use for the request.
    * @template ActualOpt - The actual type of the options.
    *
-   * @template RealEP - The real path of the ESI endpoint to send the request to.
-   * @template EP - The parameterized path of the ESI endpoint to send the request to.
-   * @template PathParams - Parameters to include in the request if the endpoint is parameterized.
+   * @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 R - The response type.
+   * @template Ret - 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. If the endpoint has required parameters, this parameter must be provided.
@@ -169,84 +245,141 @@ 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<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
-  >(endpoint: RealEP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<R>;
+  type TESIRequestFunctionEachMethod2<Mtd extends TESIEntryMethod, ActualOpt = {}> = <
+    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>,
+  >(endpoint: REP, ...options: HasOpt extends 1 ? [Opt] : [Opt?]) => Promise<Ret>;
 
   /**
    * 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
@@ -259,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).
@@ -309,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.