eve-esi-types 2.3.4 → 3.0.1

package/lib/tagged-request-api.mjs

@@ -9,9 +9,9 @@
 /**
  * @file eve-esi-types/lib/tagged-request-api.mts
  */
-import { request } from "./request-api.mjs";
+import { request2 } from "./request-api.mjs";
 /**
- * @import { TESIRequestFunctionMethods } from "../v2"
+ * @import { TESIRequestFunctionMethods2 } from "../v2"
  */
 /**
  * @typedef {`${string}${"" | `,${string}`}`} TMethodList
@@ -36,37 +36,36 @@ const ESITagMethodMapping = [
     "Wars:get"
 ];
 /**
- * `esi-tagged-types` and `injectESIRequestBody` allow for more intuitive use of ESI requests based on the "tags" defined in the EVE Swagger JSON.
- *
- * + The `ESI request API object` constructed by `injectESIRequestBody` lists narrowed endpoints by accessing the camel-cased "tags" members.
+ * Decorates the ESI request body into a tagged ESI request map.
  *
  * @example
  *    import * as taggedApi from "eve-esi-types/lib/tagged-request-api.mjs";
  *
- *    const esiRequest = taggedApi.injectESIRequestBody(...);
+ *    const esiRequest = taggedApi.decoreateESIRequestBody(...);
  *    const ret = await esiRequest.universe.get("/universe/structures/", { query: { filter: "market" }});
  *
  * @template {Record<string, unknown>} Opt - The options type for the request.
- * @param {TESIRequestFunctionSignature<Opt>} requestBody - The function signature for the ESI request.
- * @returns {XESI.TaggedESIRequestMap} - The tagged ESI request map.
- * @since 2.3
+ * @param {TESIRequestFunctionSignature2<Opt>} requestBody - The function signature for the ESI request.
+ * @returns {XESI.TaggedESIRequestMap2<Opt>} - The tagged ESI request map.
  */
-export function injectESIRequestBody(requestBody) {
-    const rq = /** @type {XESI.TaggedESIRequestMap<Opt>} */ ({});
+export function decoreateESIRequestBody(requestBody) {
+    const rq = /** @type {XESI.TaggedESIRequestMap2<Opt>} */ ({});
     // 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 {TESIRequestFunctionMethods<Opt>} */ ({});
+    const methodMap = /** @type {TESIRequestFunctionMethods2<Opt>} */ ({});
     /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-        methodMap[method] = /** @type {TESIRequestFunctionEachMethod<typeof method, Opt>} */ ((e, params, opt) => requestBody(method, e, params, opt));
+        methodMap[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, Opt>} */ (
+        // @ts-expect-error Type peeling due to differences in inference process
+        (e, opt) => requestBody(method, e, opt));
     });
     for (const tagEntry of ESITagMethodMapping) {
         const [tag, methodList] = /** @type {[tag: XESI.ESITags, methods: TMethodList]} */ (tagEntry.split(":"));
         const methods = /** @type {TESIEntryMethod[]} */ (methodList.split(","));
-        const entry = /** @type {XESI.ESITaggedEndpointRequest<typeof tag, Opt>} */ ({});
+        const entry = /** @type {XESI.ESITaggedEndpointRequest2<typeof tag, Opt>} */ ({});
         for (const method of methods) {
             // However, from the point of view of type annotation, the parameters are different, so you need to cast it as `as type` instead of `satisfies`.
             // @ts-expect-error
-            entry[method] = /** @type {XESI.TaggedEndpointRequestFunction<typeof method, typeof tag, Opt>} */ (methodMap[method]);
+            entry[method] = /** @type {XESI.TaggedEndpointRequestFunction2<typeof method, typeof tag, Opt>} */ (methodMap[method]);
         }
         const camelCased = /** @type {XESI.LCamelCase<XESI.ESITags>} */ (tag[0].toLowerCase() + tag.slice(1).replace(/\s(.)/g, "$1"));
         rq[camelCased] = entry;
@@ -77,9 +76,9 @@ export function injectESIRequestBody(requestBody) {
  * @import { ESIRequestOptions } from "./rq-util.mjs";
  */
 /**
- * Injects the minimal implementation of ESI requests into `XESI.TaggedESIRequestMap`.
+ * Injects the minimal implementation of ESI requests into `XESI.TaggedESIRequestMap2`.
  *
- * @since 2.3
- * @type {XESI.TaggedESIRequestMap<ESIRequestOptions>}
+ * @since 2.x
+ * @type {XESI.TaggedESIRequestMap2<ESIRequestOptions>}
  */
-export const esi = injectESIRequestBody(request);
+export const esi = decoreateESIRequestBody(request2);

package/minimal-rq.mjs

@@ -10,55 +10,56 @@
 //               imports
 // - - - - - - - - - - - - - - - - - - - -
 import * as util from "./lib/rq-util.mjs";
-import { request } from "./lib/request-api.mjs";
+import { request2 } from "./lib/request-api.mjs";
 // - - - - - - - - - - - - - - - - - - - -
 //           constants, types
 // - - - - - - - - - - - - - - - - - - - -
 // shorthands
 const log = util.getUniversalLogger("[request-mini]: ");
 /**
- * @typedef {import("./v2").IESIRequestFunction<util.ESIRequestOptions>} IESIRequestFunction
- * @typedef {import("./v2").TESIRequestFunctionMethods<util.ESIRequestOptions>} TESIRequestFunctionMethods
+ * @typedef {import("./v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {import("./v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
  */
 // - - - - - - - - - - - - - - - - - - - -
 //            main functions
 // - - - - - - - - - - - - - - - - - - - -
 //
-// Delegates implementation to `request` (TESIRequestFunctionMethods)
+// Delegates implementation to `request` (TESIRequestFunctionMethods2)
 //
-const esiMethods = /** @type {TESIRequestFunctionMethods} */ ({});
+const esiMethods = /** @type {TESIRequestFunctionMethods2} */ ({});
 /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-    esiMethods[method] = /** @type {TESIRequestFunctionEachMethod<typeof method>} */ (function (endpoint, params, opt) {
-        return request(method, endpoint, params, opt);
+    esiMethods[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method>} */ (function (endpoint, opt) {
+        // @ts-expect-error
+        return request2(method, endpoint, opt);
     });
 });
 // It should complete correctly.
 /**
- * @param {IESIRequestFunction} fn
+ * @param {IESIRequestFunction2} fn
  */
-async function getEVEStatus(fn) {
+async function getEVEStatus2(fn) {
     await util.getSDEVersion().then(sdeVersion => log(`sdeVersion: ${sdeVersion}`.blue));
     await util.fireRequestsDoesNotRequireAuth(fn);
     CaseIESIRequestFunctionMethods: {
         await util.fireRequestsDoesNotRequireAuth(esiMethods);
     }
     const { clog, rlog } = util.getLogger();
-    CaseIESIRequestFunction: {
+    CaseIESIRequestFunction2: {
         const ID_CCP_Zoetrope = 2112625428;
         // - - - - - - - - - - - -
         //       Character
         // - - - - - - - - - - - -
         // Here, I borrow data from "CCP Zoetrope".
-        rlog("- - - - - - - > run as IESIRequestFunction<ESIRequestOptions>".red);
+        rlog("- - - - - - - > run as IESIRequestFunction2<ESIRequestOptions>".red);
         clog();
-        await fn.get("/characters/{character_id}/", ID_CCP_Zoetrope).then(log);
+        await fn.get("/characters/{character_id}/", { pathParams: ID_CCP_Zoetrope }).then(log);
         clog('(portrait)');
-        await fn.get("/characters/{character_id}/portrait/", ID_CCP_Zoetrope).then(log);
+        await fn.get(`/characters/${ID_CCP_Zoetrope}/portrait/`).then(log);
         clog('(affiliation)');
         const affiliation = await fn.post("/characters/affiliation/", { body: [ID_CCP_Zoetrope] });
         log(affiliation);
         clog('(corporation)');
-        await fn.get("/corporations/{corporation_id}/", affiliation[0].corporation_id).then(log);
+        await fn.get(`/corporations/${affiliation[0].corporation_id}/`).then(log);
         rlog("get:/incursions/".green);
         await fn.get("/incursions/").then(log);
         // - - - - - - - - - - - -
@@ -68,7 +69,8 @@ async function getEVEStatus(fn) {
         const ids = await fn.post("/universe/ids/", { body: ["the forge", "plex"] });
         log(ids.inventory_types, ids.regions);
         rlog(`get:/markets/${ids?.regions?.[0].id}/orders/?type_id=${ids?.inventory_types?.[0].id}, item PLEX`.green);
-        const orders = await fn.get("/markets/{region_id}/orders/", ids?.regions?.[0].id, {
+        const orders = await fn.get("/markets/{region_id}/orders/", {
+            pathParams: ids?.regions?.[0].id || 0,
             query: {
                 // page: 1,
                 order_type: "sell",
@@ -80,7 +82,7 @@ async function getEVEStatus(fn) {
     return fn.get("/status/");
 }
 const runTest = () => {
-    getEVEStatus(request).then(eveStatus => log(eveStatus));
+    getEVEStatus2(request2).then(eveStatus => log(eveStatus));
 };
 // type following and run
 // node minimal-rq.mjs -debug

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-esi-types",
-  "version": "2.3.4",
+  "version": "3.0.1",
   "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

@@ -5,19 +5,35 @@
 //  https://opensource.org/licenses/mit-license.php
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
+/// <reference types="./v2"/>
 /**
  * @file tagged-rq.mts
  * @command node tagged-rq.mjs -x
  */
-import { esi as esiRq } from "./lib/tagged-request-api.mjs";
-// console.log(esiRq);
+import { esi } from "./lib/tagged-request-api.mjs";
+// import * as util from "./lib/rq-util.mjs";
 // Furthermore, the endpoint selected is narrowed down by "tags" and "method".
-esiRq.character.get("/characters/{character_id}/", 2112625428).then(console.log);
-esiRq.universe.get("/universe/structures/", { query: { filter: "market" } }).then(console.log);
-esiRq.universe.post("/universe/ids/", {
+esi.assets.get("/characters/2112625428/assets/", {
+    auth: true
+}).then(console.log).catch(console.log);
+esi.character.get("/characters/{character_id}/", { pathParams: 2112625428 }).then(console.log);
+esi.mail.post("/characters/2112625428/mail/", /** @satisfies {Pick<TESIResponsePostEntry<"/characters/{character_id}/mail/">, "auth" | "body">} */ ({
+    auth: true,
+    body: {
+        subject: "test!!",
+        body: "",
+        recipients: [{
+                recipient_id: 2112625428, recipient_type: "character"
+            }]
+    },
+    // token: "s.s.s"
+})).then(console.log).catch(console.log);
+esi.universe.get("/universe/structures/", { query: { filter: "market" } }).then(console.log);
+esi.universe.post("/universe/ids/", {
     body: ["the forge", "plex"]
 }).then(console.log);
-esiRq.fittings.delete("/characters/{character_id}/fittings/{fitting_id}/", [1234, 56789]);
-esiRq.assets.get("/characters/{character_id}/assets/", 1234, {
+esi.fittings.delete("/characters/{character_id}/fittings/{fitting_id}/", {
+    pathParams: [1234, 56789],
     auth: true
-}).then(console.log).catch(console.log);
+});
+esi.character.post("/characters/affiliation/").catch(console.log);

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 2.3.2 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.0.0 of the EVE Online ESI response types.
  */
-import { TESIResponseOKMap } from "./index.d.ts";
+import { TESIResponseOKMap, TPathParamsNever } from "./index.d.ts";
 export * from "./index.d.ts";
 
 /**
@@ -30,13 +30,13 @@ export declare type LCamelCase<S extends string> = S extends `${infer P1} ${infe
   ? `${Lowercase<P1>}${Capitalize<P2>}` : Lowercase<S>;
 
 
-declare const enum EInferSomethingBy {
-  METHOD,
-  TAGs
-}
-declare type InferSomethingBy<Tag, AsType extends EInferSomethingBy = EInferSomethingBy.METHOD> = {
+declare type EInferSomethingBy = {
+  readonly METHOD: 0;
+  readonly TAGs: 1;
+};
+declare type InferSomethingBy<Tag, AsType extends EInferSomethingBy = EInferSomethingBy["METHOD"]> = {
   [M in TESIEntryMethod]: TESIResponseOKMap[M] extends Record<`/${string}/`, { tag: infer ActualTag }>
-    ? AsType extends EInferSomethingBy.TAGs
+    ? AsType extends EInferSomethingBy["TAGs"]
       ? ActualTag : ActualTag extends Tag
         ? M
       : never
@@ -50,7 +50,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, EInferSomethingBy["TAGs"]>
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
 //            Utility Type `InferMethod`
@@ -67,7 +67,7 @@ export declare type InferMethod<Tag> = InferSomethingBy<Tag>
 // type XPlanetary = InferMethod<"Planetary Interaction">;
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
-//    Utility Type `TaggedEndpointRequestFunction`
+//    Utility Type `TaggedEndpointRequestFunction2`
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
 /**
  * Creates a function type for making requests to tagged endpoints.
@@ -86,15 +86,19 @@ export declare type InferMethod<Tag> = InferSomethingBy<Tag>
  * @returns A promise that resolves to the response.
  * @date 2025/2/28
  */
-export declare type TaggedEndpointRequestFunction<M extends TESIEntryMethod, Tag extends ESITags, ActualOpt = {}> = <
-  EP extends SelectEndpointByTag<Tag, M>,
-  P2 extends IfParameterizedPath<EP, Opt>,
-  Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt>,
-  R extends InferESIResponseResult<M, EP>
->(endpoint: EP, pathParams?: P2, options?: Opt) => Promise<R>;
+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>,
+  // RealEPX = ReplacePathParamsX<RealEPX>,
+  // EPX = ReplacePathParams<EP>,
+>(endpoint: RealEP, options?: Opt) => Promise<R>;
+
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
-//    Utility Type `ESITaggedEndpointRequest`
+//    Utility Type `ESITaggedEndpointRequest2`
 // - - - - - - - - - - - - - - - - - - - - - - - - - -
 /**
  * Maps tags to their corresponding endpoint request functions.
@@ -102,9 +106,9 @@ export declare type TaggedEndpointRequestFunction<M extends TESIEntryMethod, Tag
  * @template Tag - The tag to map.
  * @date 2025/2/28
  */
-export declare type ESITaggedEndpointRequest<Tag extends ESITags, ActualOpt = {}> = {
+export declare type ESITaggedEndpointRequest2<Tag extends ESITags, ActualOpt = {}> = {
   [tag in Tag]: {
-    [method in InferMethod<Tag>]: TaggedEndpointRequestFunction<method, tag, ActualOpt>;
+    [method in InferMethod<Tag>]: TaggedEndpointRequestFunction2<method, tag, ActualOpt>;
   };
 }[Tag];
 
@@ -132,22 +136,22 @@ export declare type SelectEndpointByTag<
 
 /**
  * Maps lower camel case tags to their corresponding endpoint request functions.
- * @date 2025/2/28
+ * @date 2025/3/12
  */
-export declare type TaggedESIRequestMap<ActualOpt = {}> = {
-  [tag in ESITags as LCamelCase<tag>]: ESITaggedEndpointRequest<tag, ActualOpt>;
+export declare type TaggedESIRequestMap2<ActualOpt = {}> = {
+  [tag in ESITags as LCamelCase<tag>]: ESITaggedEndpointRequest2<tag, ActualOpt>;
 };
 
 /**
  * Creates a partial map of lower camel case tags to their corresponding endpoint request functions.
  * ```ts
  * // implements "factionWarfare", "wallet"
- * const esiRq: XTaggedESIRequestMapPartial<"factionWarfare" | "wallet">;
+ * const esiRq: TaggedESIRequestMapPartial2<"factionWarfare" | "wallet">;
  * ```
  * 
  * @template Props - The properties to require in the partial map.
  * @date 2025/2/28
  */
-export declare type TaggedESIRequestMapPartial<Props extends LCamelCase<ESITags>> = RequireThese<Partial<TaggedESIRequestMap>, Props>;
+export declare type TaggedESIRequestMapPartial2<Props extends LCamelCase<ESITags>> = RequireThese<Partial<TaggedESIRequestMap2>, Props>;
 
 export as namespace XESI;

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 2.3.2 of the EVE Online ESI response types.
+ * @summary This file is auto-generated and defines version 3.0.0 of the EVE Online ESI response types.
  */
 
 import type { TESIResponseOKMap } from "./response-map.d.ts";
@@ -25,49 +25,78 @@ import type { PickPathParameters, InferKeysLen } from "./util.d.ts";
  * @example
  * ```ts
  * // @ ts-expect-error
- * export const request: IESIRequestFunction<ESIRequestOptions> = (method, endpoint, pathParams, opt) => {
+ * export const request: IESIRequestFunction2<ESIRequestOptions> = (method, endpoint, opt) => {
  * // Implementation for "get" | "post" | "put" | "delete" request
  * };
  * // You can easily implement "get" | "post" | "put" | "delete" requests
  * // with code like the following:
  * (["get", "post", "put", "delete"] as (keyof typeof request)[]).forEach((method) => {
- *     request[method] = function (this: typeof request, endpoint, params, opt) {
- *         return this(method, endpoint, params, opt);
- *     } as TESIRequestFunctionEachMethod<typeof method>;
+ *     request[method] = function (this: typeof request, endpoint, opt) {
+ *         return this(method, endpoint, opt);
+ *     } as TESIRequestFunctionEachMethod2<typeof method>;
  * });
  * ```
  */
-export interface IESIRequestFunction<ActualOpt>
-  extends TESIRequestFunctionSignature<ActualOpt>, TESIRequestFunctionMethods<ActualOpt> {
+export interface IESIRequestFunction2<ActualOpt>
+  extends TESIRequestFunctionSignature2<ActualOpt>, TESIRequestFunctionMethods2<ActualOpt> {
 }
 
 /**
  * Represents the methods available for making ESI requests.
  * 
  *  + This interface is used when you already have implementation code such as  
- *    TESIRequestFunctionSignature and you want to implement additional shorthand methods.
+ *    TESIRequestFunctionSignature2 and you want to implement additional shorthand methods.
  *
  * @template ActualOpt - The actual type of the options.
  *
  * @example
  * ```ts
- * export const request: TESIRequestFunctionSignature<ESIRequestOptions> = (method, endpoint, pathParams, opt) => {
+ * export const request: TESIRequestFunctionSignature2<ESIRequestOptions> = (method, endpoint, opt) => {
  * // Implementation for "get" | "post" | "put" | "delete" request
  * };
  * // You can easily implement "get" | "post" | "put" | "delete" requests
  * // with code like the following:
- * const esiMethods = {} as TESIRequestFunctionMethods<ESIRequestOptions>;
- * (["get", "post", "put", "delete"] as (keyof TESIRequestFunctionMethods)[]).forEach((method) => {
- *     esiMethods[method] = function (endpoint, params, opt) {
- *         return request(method, endpoint, params, opt);
- *     } as TESIRequestFunctionEachMethod<typeof method>;
+ * const esiMethods = {} as TESIRequestFunctionMethods2<ESIRequestOptions>;
+ * (["get", "post", "put", "delete"] as (keyof TESIRequestFunctionMethods2)[]).forEach((method) => {
+ *     esiMethods[method] = function (endpoint, opt) {
+ *         return request(method, endpoint, opt);
+ *     } as TESIRequestFunctionEachMethod2<typeof method>;
  * });
  * ```
  */
-export type TESIRequestFunctionMethods<ActualOpt = {}> = {
-  [method in TESIEntryMethod]: TESIRequestFunctionEachMethod<method, ActualOpt>;
+export type TESIRequestFunctionMethods2<ActualOpt = {}> = {
+  [method in TESIEntryMethod]: TESIRequestFunctionEachMethod2<method, ActualOpt>;
 }
 
+/**
+ * List of "x-cached-seconds"
+ * 
+ * ```ts
+ * // const cacheSecGet: 3600 | 300 | 604800 | 120 | 5 | 600 | 86400 | 60 | 30 | 1200 | 1800 | 30758400
+ * const cacheSecGet: TESICachedSeconds<"get">;
+ * // const cache5sec: 5
+ * const cache5s: TESICachedSeconds<"put">;
+ * // const cache3600s: 3600
+ * const cache3600s: TESICachedSeconds<"post">;
+ * // "/characters/affiliation/"
+ * const cache3600sEndpoint: TESICachedSeconds<"post", 1>;
+ * ```
+ */
+export declare 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];
+// const cacheSecGet: TESICachedSeconds<"get">;
+// const cache5sec: TESICachedSeconds<"put">;
+// const cache3600sEndpoint: TESICachedSeconds<"post", 1>;
+export declare type TPathParamsNever = { pathParams?: never };
+
 declare global {
 
   /**
@@ -75,63 +104,140 @@ declare global {
    */
   type RequireThese<T, K extends keyof T> = T & Required<Pick<T, K>>;
 
+  //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  //                                Version 3 types
+  //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   /**
-   * If `EP` (endpoint) is a parameterized path, determines the required number of replacements.
+   * ### ESI request function with real endpoint signature
    * 
-   * @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`.
-   */
-  type IfParameterizedPath<EP, Opt> = EP extends `${string}/{${string}}${string}`
-    ? PickPathParameters<EP> extends never
-      ? Opt : InferKeysLen<PickPathParameters<EP>> extends 1
-          ? number : [number, number]
-      : Opt;
-
-  /**
-   * ### ESI request function all in one signature
-   * 
-   * TESIRequestFunctionSignature is a type that defines the signature of an ESI request function.
+   * 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.  
-   *   Required parameters inferred by typescript are merged.
+   * @template ActualOpt - The actual type of the option.
    * @template M - The HTTP method to use for the request
-   * @template EP - The Path of the ESI endpoint to send the request to
-   * @template P2 - Parameters to include in the request
-   * @template Opt - Options to include in the request  
-   *   If there is a required parameter, its type will be merged with `ActualOpt`
+   * @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 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
+   * 
+   * @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.
+   * 
+   * @returns A Promise object containing the response data, with the type inferred based on the method and endpoint.
    */
-  type TESIRequestFunctionSignature<ActualOpt> = <
+  type TESIRequestFunctionSignature2<ActualOpt> = <
     M extends TESIEntryMethod,
-    EP extends keyof TESIResponseOKMap[M],
-    P2 extends IfParameterizedPath<EP, Opt>,
-    Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt>,
+    // "/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>
-  >(method: M, endpoint: EP, pathParams?: P2, options?: Opt) => Promise<R>;
+  >(method: M, endpoint: RealEP, options?: Opt) => Promise<R>;
 
   /**
-   * Represents a function that makes an ESI request using a specific HTTP method.
+   * Represents a function that can make ESI requests for a specific HTTP method.
    *
-   * @template M - The HTTP method to use for the request (e.g., "get", "post").
-   * @template ActualOpt - The actual type of the options to include in the request.
-   * 
-   * @param endpoint - The path of the ESI endpoint to send the request to.
-   * @param pathParams - An optional parameter that can be a number, an array of numbers, or other parameters
-   *                     depending on whether the path is parameterized.
+   * 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 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 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.
+   *
+   * @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.
-   * 
+   *
    * @returns A Promise object containing the response data, with the type inferred based on the method and endpoint.
    */
-  type TESIRequestFunctionEachMethod<M extends TESIEntryMethod, ActualOpt = {}> = <
-    EP extends keyof TESIResponseOKMap[M],
-    P2 extends IfParameterizedPath<EP, Opt>,
-    Opt extends IdentifyParameters<TESIResponseOKMap[M][EP], ActualOpt>,
+  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: EP, pathParams?: P2, options?: Opt) => Promise<R>;
+  >(endpoint: RealEP, options?: Opt) => Promise<R>;
+
+  /**
+   * Replaces path parameters in a string with numbers.
+   * 
+   * @template T - The string representing the endpoint path.
+   * @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}`
+    ? `${Start}${number}${ReplacePathParams<End>}` : T;
+
+  // // type Example = ReplacePathParamsX<"/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;
+  /**
+   * 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] }
+   * ```
+   */
+  type IfNeedPathParams<EP> = IfParameterizedPath<EP> extends never ? TPathParamsNever :
+    EP extends ReplacePathParams<EP> ? TPathParamsNever : { pathParams: IfParameterizedPath<EP> };
+  /**
+   * Infers the original endpoint path from a real endpoint path.
+   * 
+   * @template RealEP - The real endpoint path.
+   * @returns {string} The original endpoint path with parameters.
+   * @example
+   * ```ts
+   * type EPOrigin = InferEndpointOrigin<"/characters/123/fittings/456/", TEndPointDelete>;
+   * // Result: "/characters/{character_id}/fittings/{fitting_id}/"
+   * ```
+   */
+  type InferEndpointOrigin<RealEP extends unknown, Endpoints> = {
+    [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];
+
+  //  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  //                                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`.
+   */
+  type IfParameterizedPath<EP, 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.
@@ -143,7 +249,7 @@ declare global {
   //* ctt
   type IdentifyParameters<
     Entry, Opt,
-    Keys = Exclude<keyof Entry, "result" | "tag">
+    Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
   > = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
   /*/
   type IdentifyParameters<