eve-esi-types 3.1.6 → 3.2.0

package/docs/v3/esi-types-util3.md

@@ -1,319 +0,0 @@
-<!--!
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
-  Released under the MIT license
-  https://opensource.org/licenses/mit-license.php
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
--->
-
-# ESI Types Utility 3.1 Summary
-
-This document provides detailed explanations of each type defined in the `eve-esi-types/v2/index.d.ts` file.
-
-> ## TESIRequestFunctionSignature2
-
-`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.
-
-#### Type Parameters
-
-- `ActualOpt`: The actual type of the options.
-- `M`: The HTTP method to use for the request.
-- `RealEP`: The real path of the ESI endpoint to send the request to.
-- `EPx`: The parameterized path of the ESI endpoint to send the request to.
-- `PathParams`: Parameters to include in the request if the endpoint is parameterized.
-- `Opt`: Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`.
-- `R`: The response type.
-- `HasOpt`: Determines if the options parameter is required.
-
-#### Parameters
-
-- `method`: The HTTP method to use for the request (e.g., "get", "post").
-- `endpoint`: The real path of the ESI endpoint to send the request to.
-- `options`: An optional object containing additional options for the request. If the endpoint has required parameters, this parameter must be provided.
-
-#### Returns
-
-A `Promise` object containing the response data, with the type inferred based on the method and endpoint.
-
-#### Remarks
-
-The `...options: HasOpt extends 1 ? [Opt] : [Opt?]` parameter is defined this way to enforce that if the endpoint has required parameters, the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
-
-
-> ## TESIRequestFunctionEachMethod2
-
-`TESIRequestFunctionEachMethod2` is a type that defines the signature of an ESI request function for a specific HTTP method. This function sends a request to a specified endpoint and returns a response.
-
-#### Type Parameters
-
-- `M`: The HTTP method to use for the request.
-- `ActualOpt`: The actual type of the options.
-- `RealEP`: The real path of the ESI endpoint to send the request to.
-- `EPx`: The parameterized path of the ESI endpoint to send the request to.
-- `PathParams`: Parameters to include in the request if the endpoint is parameterized.
-- `Opt`: Options to include in the request. If there is a required parameter, its type will be merged with `ActualOpt`.
-- `R`: The response type.
-- `HasOpt`: Determines if the options parameter is required.
-
-#### Parameters
-
-- `endpoint`: The real path of the ESI endpoint to send the request to.
-- `options`: An optional object containing additional options for the request. If the endpoint has required parameters, this parameter must be provided.
-
-#### Returns
-
-A `Promise` object containing the response data, with the type inferred based on the method and endpoint.
-
-#### Remarks
-
-The `...options: HasOpt extends 1 ? [Opt] : [Opt?]` parameter is defined this way to enforce that if the endpoint has required parameters, the `options` parameter must be provided. If there are no required parameters, the `options` parameter is optional.
-
-
-
-## ReplacePathParams
-
-`ReplacePathParams` is a type that replaces path parameters in a string with numbers.
-
-```typescript
-type ReplacePathParams<T extends unknown> = T extends `${infer Start}{${infer Param}}${infer End}`
-  ? `${Start}${number}${ReplacePathParams<End>}` : T;
-```
-
-  <details>
-> Example
-
-  ```typescript
-  type Example = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
-  // Result: `/characters/${number}/fittings/${number}/`
-  ```
-  </details>
-
-## InferPathParams
-
-`InferPathParams` is a type that infers the path parameters based on the real endpoint and the resolved endpoint.
-
-```typescript
-type InferPathParams<
-  RealEP extends unknown, EPx extends unknown
-> = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
-```
-
-## InferEndpointOrigin
-
-`InferEndpointOrigin` is a type that infers the original endpoint based on the real endpoint and the HTTP method. This type maps the real endpoint to its corresponding parameterized endpoint by checking if the real endpoint matches the pattern of any parameterized endpoint.
-
-```typescript
-type InferEndpointOrigin<
-  RealEP extends unknown, M extends TESIEntryMethod,
-  Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>
-> = {
-  [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
-    ? EP : never;
-}[Endpoints];
-```
-
-  <details>
-> Example
-
-  ```typescript
-type Original = InferEndpointOrigin<"/characters/123/fittings/456/", "delete">;
-// Result: "/characters/{character_id}/fittings/{fitting_id}/"
-  ```
-  </details>
-
-
-## ResolvedEndpoint
-
-`ResolvedEndpoint` is a type that determines the resolved endpoint based on the real endpoint and the method.
-
-```typescript
-type ResolvedEndpoint<
-  RealEP extends unknown, M extends TESIEntryMethod,
-> = InferEndpointOrigin<RealEP, M> extends never ? RealEP: InferEndpointOrigin<RealEP, M>;
-```
-
-  <details>
-> Example
-
-  ```typescript
-type Resolved = ResolvedEndpoint<"/characters/123/fittings/456/", "delete">;
-// Result: "/characters/{character_id}/fittings/{fitting_id}/"
-  ```
-  </details>
-
-## PickRequireParams
-
-`PickRequireParams` is a type that picks the required parameters from an entry type, including additional parameters. This type excludes the keys "result", "tag", and "cachedSeconds" from the entry type and the additional parameters, and returns the remaining keys as the required parameters.
-
-```typescript
-type PickRequireParams<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string,
-  AdditionalParams,
-  Entry = _ESIResponseType<M, EPx>
-> = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">;
-```
-
-  <details>
-> Example
-
-  ```typescript
-type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-type RequiredParams = PickRequireParams<"get", "/example/endpoint", { auth: string }>;
-// Result: "auth"
-  ```
-  </details>
-
-## HasRequireParams
-
-`HasRequireParams` is a type that determines if the given entry has required parameters, including additional options. This type checks if an entry has any required parameters by excluding the keys "result", "tag", and "cachedSeconds". If any keys remain after this exclusion, it means the entry has required parameters.
-
-```typescript
-type HasRequireParams<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string,
-  AdditionalParams,
-> = PickRequireParams<M, EPx, AdditionalParams> extends never ? 0 : 1;
-```
-
-  <details>
-> Example
-
-  ```typescript
-type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-type HasRequired = HasRequireParams<"get", "/example/endpoint", { auth: string }>;
-// Result: 1
-  ```
-  </details>
-
-## IfParameterizedPath
-
-`IfParameterizedPath` is a type that determines the required number of replacements if `EP` (endpoint) is a parameterized path.
-
-```typescript
-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;
-```
-
-## IdentifyParameters
-
-`IdentifyParameters` is a type that identifies the required parameters for a given entry type, including additional options. This type combines the required parameters from the entry type and the additional options, ensuring that all required parameters are marked as required.
-
-```typescript
-type IdentifyParameters<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string,
-  Opt extends Record<string, unknown>,
-  Entry = _ESIResponseType<M, EPx>,
-  Keys = Exclude<keyof Entry, "result" | "tag" | "cachedSeconds">
-> = RequireThese<Opt, Keys> & Pick<Entry, Keys>;
-```
-
-  <details>
-> Example
-
-  ```typescript
-type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-type ExampleOpt = { auth: string };
-type IdentifiedParams = IdentifyParameters<"get", "/example/endpoint", ExampleOpt, ExampleEntry>;
-// Result: { auth: string } & { auth: string }
-  ```
-  </details>
-
-## InferESIResponseResult
-
-`InferESIResponseResult` is a type that infers the result type of an ESI response based on the method and endpoint.
-
-```typescript
-type InferESIResponseResult<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string
-> = _ESIResponseType<M, EPx> extends { result: infer U } ? U : never;
-```
-
-  <details>
-> Example
-
-  ```typescript
-type Result = InferESIResponseResult<"get", "/characters/{character_id}/">;
-// Result: The inferred type of the response for the given method and endpoint.
-  ```
-  </details>
-
-## NoContentResponse
-
-`NoContentResponse` is a type that represents a response with no content (HTTP status 204).
-
-```typescript
-type NoContentResponse = { /* status: 204 */ };
-```
-
-## TESIEntryMethod
-
-`TESIEntryMethod` is a type that represents the HTTP methods supported by ESI.
-
-```typescript
-type TESIEntryMethod = keyof TESIResponseOKMap;
-```
-
-  <details>
-> Example
-
-  ```typescript
-  "get" | "post" | "put" | "delete"
-  ```
-  </details>
-
-## ESIEndpointOf
-
-`ESIEndpointOf` is a type that represents the endpoints for the specified HTTP method.
-
-```typescript
-type ESIEndpointOf<M extends TESIEntryMethod> = keyof TESIResponseOKMap[M];
-```
-
-  <details>
-> Example
-
-  ```typescript
-type TEndPointGet = ESIEndpointOf<"get">;
-type TEndPointPost = ESIEndpointOf<"post">;
-type TEndPointPut = ESIEndpointOf<"put">;
-type TEndPointDelete = ESIEndpointOf<"delete">;
-  ```
-  </details>
-
-## TESIResponseGetEntry
-
-`TESIResponseGetEntry` is a type that represents the entry details for the "get" method.
-
-```typescript
-type TESIResponseGetEntry<K extends TEndPointGet> = TESIResponseOKMap["get"][K];
-```
-
-## TESIResponsePutEntry
-
-`TESIResponsePutEntry` is a type that represents the entry details for the "put" method.
-
-```typescript
-type TESIResponsePutEntry<K extends TEndPointPut> = TESIResponseOKMap["put"][K];
-```
-
-## TESIResponsePostEntry
-
-`TESIResponsePostEntry` is a type that represents the entry details for the "post" method.
-
-```typescript
-type TESIResponsePostEntry<K extends TEndPointPost> = TESIResponseOKMap["post"][K];
-```
-
-## TESIResponseDeleteEntry
-
-`TESIResponseDeleteEntry` is a type that represents the entry details for the "delete" method.
-
-```typescript
-type TESIResponseDeleteEntry<K extends TEndPointDelete> = TESIResponseOKMap["delete"][K];
-```

package/docs/v3/has-require-params.md

@@ -1,50 +0,0 @@
-# Explanation of the `HasRequireParams` Type
-
-`HasRequireParams` is a conditional TypeScript utility type designed to determine whether an API entry has any required parameters, including additional options. It does so by leveraging the `PickRequireParams` type to extract the keys from an entry type that are considered required once common metadata keys (`"result"`, `"tag"`, and `"cachedSeconds"`) have been excluded. If there remain any keys after this exclusion, it means the entry has required parameters, and the type evaluates to `1`; otherwise, it evaluates to `0`.
-
-## Type Definition
-
-```typescript
-type HasRequireParams<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string,
-  AdditionalParams,
-> = PickRequireParams<M, EPx, AdditionalParams> extends never ? 0 : 1;
-```
-
-## Template Parameters
-
-- **`M extends TESIEntryMethod`**  
-  Represents the HTTP method (like `"get"`, `"post"`, `"delete"`, etc.) for the request. This helps identify the correct set of endpoints and types associated with that method.
-
-- **`EPx extends ESIEndpointOf<M> | string`**  
-  Denotes the endpoint path. It can be a specific parameterized endpoint from a predefined set (based on the HTTP method) or a generic string.
-
-- **`AdditionalParams`**  
-  Contains any extra parameters that should be considered during the evaluation. These are merged with the entry type to form a complete set of properties before excluding the metadata keys.
-
-## How It Works
-
-1. **Extracting Required Parameters**  
-   The type starts by merging the entry type with `AdditionalParams` and then uses `PickRequireParams` to exclude common metadata keys (`"result"`, `"tag"`, and `"cachedSeconds"`). This extraction isolates the parameters that are truly required for the API call.
-
-2. **Conditional Evaluation**  
-   - If the resulting type from `PickRequireParams` is `never` (meaning there are no keys left), then `HasRequireParams` evaluates to `0`.
-   - Otherwise, if there exists at least one required parameter, it evaluates to `1`.
-
-## Practical Example
-
-```typescript
-type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-type HasRequired = HasRequireParams<"get", "/example/endpoint", { auth: string }>;
-// Evaluates to: 1
-```
-
-In this example:
-- The `ExampleEntry` type includes metadata keys as well as an essential key `auth`.
-- After merging with `AdditionalParams` (which also includes `{ auth: string }`) and excluding the metadata keys, `auth` remains.
-- Since there is a required parameter (`auth`), `HasRequireParams` evaluates to `1`.
-
----
-
-`HasRequireParams` provides a straightforward mechanism to check if any required parameters exist for a given API entry, assisting in enhancing type safety and clarity in API definitions.

package/docs/v3/infer-endpoint-origin.md

@@ -1,57 +0,0 @@
-# Explanation of the `InferEndpointOrigin` Type
-
-`InferEndpointOrigin` is a utility TypeScript type that deduces the original parameterized endpoint from a real endpoint string and a specified HTTP method. It does so by mapping over all possible parameterized endpoints associated with the given HTTP method, and selecting the one whose transformed version (via `ReplacePathParams`) matches the real endpoint. This technique enables you to recover the canonical endpoint structure from a concrete URL.
-
-## Type Definition
-
-```typescript
-type InferEndpointOrigin<
-  RealEP extends unknown, M extends TESIEntryMethod,
-  Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>
-> = {
-  [EP in Endpoints]: RealEP extends ReplacePathParams<EP>
-    ? EP : never;
-}[Endpoints];
-```
-
-## Template Parameters
-
-- **`RealEP extends unknown`**  
-  The real endpoint path, e.g., `"/characters/123/fittings/456/"`, representing the concrete URL accessed in a request.
-
-- **`M extends TESIEntryMethod`**  
-  The HTTP method (such as `"get"`, `"post"`, `"delete"`, etc.) used to determine which endpoints are applicable.
-
-- **`Endpoints extends ESIEndpointOf<M> = ESIEndpointOf<M>`**  
-  The union of all possible parameterized endpoints for the given HTTP method. These endpoints generally include dynamic segments in their definition, like `"/characters/{character_id}/fittings/{fitting_id}/"`.
-
-## How It Works
-
-1. **Mapping Over Endpoints**  
-   The type creates a mapped type where it iterates over each possible endpoint (`EP`) in the `Endpoints` union:
-   ```typescript
-   RealEP extends ReplacePathParams<EP> ? EP : never;
-   ```
-   - **Condition:** It checks if the real endpoint `RealEP` is assignable to the version of `EP` produced by `ReplacePathParams` (i.e., with its dynamic segments replaced by `${number}`).
-   - **Outcome:**  
-     - If the condition holds true, it retains `EP`—indicating that this is the matching original endpoint.
-     - Otherwise, it assigns `never` for that endpoint.
-
-2. **Indexing the Mapped Type**  
-   After processing all endpoints, the type uses an index lookup `[Endpoints]` to extract the union of all endpoints that passed the conditional check (i.e., where the condition did not yield `never`). In typical usage, this results in a single matching endpoint.
-
-## Practical Example
-
-```ts
-type Original = InferEndpointOrigin<"/characters/123/fittings/456/", "delete">;
-// Evaluates to: "/characters/{character_id}/fittings/{fitting_id}/"
-```
-
-In this example:
-- The real endpoint `"/characters/123/fittings/456/"` is compared against each parameterized endpoint available for the `"delete"` method.
-- When the condition `RealEP extends ReplacePathParams<EP>` is satisfied, it indicates that the endpoint structure matches. Accordingly, the original parameterized endpoint (`EP`) is selected.
-- The final resulting type is the parameterized endpoint, `"/characters/{character_id}/fittings/{fitting_id}/"`.
-
----
-
-`InferEndpointOrigin` thus serves as a robust mechanism to align concrete URLs with their original endpoint definitions, ensuring accurate type-checking for API route definitions.

package/docs/v3/infer-path-params.md

@@ -1,41 +0,0 @@
-# Explanation of the `InferPathParams` Type
-
-`InferPathParams` is a conditional utility TypeScript type that infers path parameters by comparing the real endpoint path (`RealEP`) with the resolved endpoint path (`EPx`). It determines the appropriate type for the path parameters based on whether the real endpoint extends the resolved endpoint.
-
-## Type Definition
-
-```typescript
-type InferPathParams<
-  RealEP extends unknown, EPx extends unknown
-> = RealEP extends EPx ? _IfNeedPathParams<EPx> : TPathParamsNever;
-```
-
-## Template Parameters
-
-- **`RealEP extends unknown`**  
-  Represents the real endpoint path, which is the original route definition provided in your API.
-
-- **`EPx extends unknown`**  
-  Represents the resolved endpoint path, which may be a transformed or standardized version of the real endpoint.
-
-## How It Works
-
-1. **Conditional Check**  
-   The type first evaluates whether `RealEP` extends `EPx`:
-   - If **true**, it indicates that the real endpoint is compatible with the resolved endpoint.
-
-2. **Path Parameter Inference**  
-   - When the condition is met, the type returns `_IfNeedPathParams<EPx>`, a helper type that likely infers and extracts the necessary path parameters embedded within `EPx`.
-   - Otherwise, it returns `TPathParamsNever`, a type signaling that no valid path parameters could be inferred or that they are not needed.
-
-## Practical Example
-
-Consider a scenario where you have:
-- A real endpoint like `"/characters/{character_id}"`.
-- A resolved endpoint that might incorporate specific formatting or type annotations.
-
-Using `InferPathParams`, if the real endpoint correctly extends the resolved endpoint, `_IfNeedPathParams` will process `EPx` to extract dynamic segments (such as converting `{character_id}` to an interpolated type). If not, it falls back to `TPathParamsNever`.
-
----
-
-This type is instrumental in achieving type safety in API route definitions. By conditionally inferring path parameters, it ensures that only valid and necessary parameters are extracted, promoting robust type-checking and eliminating unnecessary types.

package/docs/v3/pick-require-params.md

@@ -1,56 +0,0 @@
-# Explanation of the `PickRequireParams` Type
-
-`PickRequireParams` is an advanced TypeScript utility type designed to extract the required keys from an entry type after merging it with additional parameters. It achieves this by excluding specific keys—namely, `"result"`, `"tag"`, and `"cachedSeconds"`—which are considered metadata or non-essential for defining required parameters. This type proves extremely useful when determining which parameters are needed for a particular API operation.
-
-## Type Definition
-
-```typescript
-type PickRequireParams<
-  M extends TESIEntryMethod,
-  EPx extends ESIEndpointOf<M> | string,
-  AdditionalParams,
-  Entry = _ESIResponseType<M, EPx>
-> = Exclude<keyof (Entry & AdditionalParams), "result" | "tag" | "cachedSeconds">;
-```
-
-## Template Parameters
-
-- **`M extends TESIEntryMethod`**  
-  Denotes the HTTP method (such as `"get"`, `"post"`, etc.) used for the request. This helps narrow down the endpoint and response types applicable for the method.
-
-- **`EPx extends ESIEndpointOf<M> | string`**  
-  Represents the endpoint path. It can either be a specific parameterized endpoint from a predefined collection (for the given HTTP method) or a generic string.
-
-- **`AdditionalParams`**  
-  Contains any extra parameters that need to be considered. These are merged with the entry type to facilitate a comprehensive parameter extraction.
-
-- **`Entry = _ESIResponseType<M, EPx>`**  
-  By default, this infers the response type corresponding to the HTTP method and endpoint provided. The resulting type is combined with `AdditionalParams` to determine the full set of keys available before excluding the non-required ones.
-
-## How It Works
-
-1. **Merging Types**  
-   The type starts by merging `Entry` with `AdditionalParams` using an intersection (`Entry & AdditionalParams`). This combined type gathers all properties from both sources.
-
-2. **Extracting Keys**  
-   Using `keyof` on the merged type yields a union of all property keys present in either `Entry` or `AdditionalParams`.
-
-3. **Excluding Unwanted Keys**  
-   The `Exclude` utility then removes the keys `"result"`, `"tag"`, and `"cachedSeconds"` from the union. These keys are typically reserved for metadata or caching information and are not required as input parameters.
-
-## Practical Example
-
-```typescript
-type ExampleEntry = { result: string, tag: string, cachedSeconds: number, auth: string };
-type RequiredParams = PickRequireParams<"get", "/example/endpoint", { auth: string }, ExampleEntry>;
-// Result: "auth"
-```
-
-In this example:
-- The `ExampleEntry` type contains metadata keys (`result`, `tag`, `cachedSeconds`) and an essential key `auth`.
-- After merging with `AdditionalParams` (which provides `{ auth: string }`), the `PickRequireParams` type excludes the metadata keys.
-- The final resulting type, `RequiredParams`, is `"auth"`, representing the required parameter.
-
----
-
-`PickRequireParams` provides a powerful approach to isolating the essential parameters needed for API operations, ensuring that extraneous metadata does not interfere with type-safety and clarity in your API definitions.

package/docs/v3/replace-path-params.md

@@ -1,60 +0,0 @@
-# Explanation of the `ReplacePathParams` Type
-
-`ReplacePathParams` is a recursive TypeScript type designed to replace dynamic segments—specifically,  
-the path parameters enclosed in curly braces—in a string literal with a standardized template literal interpolation of `${number}`.  
-This is especially useful when defining API endpoints where parameters in the URL are expected to be numeric.
-
-## Type Definition
-
-```typescript
-type ReplacePathParams<T extends unknown> = T extends `${infer Start}{${infer Param}}${infer End}`
-  ? `${Start}${number}${ReplacePathParams<End>}`
-  : T;
-```
-
-### Parameters
-
- + T extends unknown Although T is declared with the type unknown, it is intended to be a string literal representing the endpoint path.  
-   The type processes the string to find dynamic segments that need to be replaced.
-
-### How It Works
-
-1. Pattern Matching The type checks if the input string T matches the pattern:
-
-   `${infer Start}{${infer Param}}${infer End}`
-
- + `Start`: Captures the substring leading up to the first occurrence of a path parameter.
-
- + `{${infer Param}}`: Matches a section of the string enclosed in curly braces. The content inside the braces, which is the path parameter's name, is stored temporarily in Param.
-
- + `End`: Captures the remaining part of the string following the matched dynamic segment.
-
-2. **Recursive Replacement** If the pattern is matched:
-
- + The matching segment `{${infer Param}}` is replaced with `${number}`.
-
- + The type then recursively applies itself to the remainder of the string (`End`) by calling `ReplacePathParams<End>`,  
-   ensuring that all occurrences of path parameters are replaced.
-
-3. Base Case If `T` does not contain any substring that fits the pattern (i.e., no occurrence of a dynamic segment in curly braces),  
-   the type simply evaluates to `T` without modification. This serves as the termination condition for the recursion.
-
-### Practical Example
-
-```ts
-type Example = ReplacePathParams<"/characters/{character_id}/fittings/{fitting_id}/">;
-// Evaluates to: "/characters/${number}/fittings/${number}/"
-```
-
-In this example:
-
-1. The first dynamic segment `{character_id}` is replaced with `${number}`.
-
-1. The type then recursively processes the remaining string, encountering and replacing {fitting_id} with `${number}`.
-
-1. The final resulting type is `"/characters/${number}/fittings/${number}/"`.
-
----
-
-The `ReplacePathParams` type is a powerful tool for transforming endpoint strings into a more standardized format.  
-This is especially beneficial when type-checking API route definitions or dynamically generating strongly-typed URL strings based on certain conditions.

package/docs/v3/resolved-endpoint.md

@@ -1,44 +0,0 @@
-# Explanation of the `ResolvedEndpoint` Type
-
-`ResolvedEndpoint` is a utility TypeScript type that determines the final, "resolved" endpoint based on a given real endpoint and the specific HTTP method. It leverages the `InferEndpointOrigin` type to deduce the original parameterized endpoint from the real endpoint. If no matching parameterized endpoint is found (i.e., the inference results in `never`), it defaults back to the real endpoint.
-
-## Type Definition
-
-```typescript
-type ResolvedEndpoint<
-  RealEP extends unknown, M extends TESIEntryMethod,
-> = InferEndpointOrigin<RealEP, M> extends never ? RealEP : InferEndpointOrigin<RealEP, M>;
-```
-
-## Template Parameters
-
-- **`RealEP extends unknown`**  
-  The real endpoint path, representing the actual URL used in a request (for example, `"/characters/123/fittings/456/"`).
-
-- **`M extends TESIEntryMethod`**  
-  The HTTP method (such as `"get"`, `"post"`, `"delete"`, etc.) used for the request. This is used to narrow down which set of parameterized endpoints should be considered.
-
-## How It Works
-
-1. **Endpoint Inference**  
-   The type starts by invoking `InferEndpointOrigin<RealEP, M>`, which attempts to map the real endpoint to its original parameterized form (e.g., converting `"/characters/123/fittings/456/"` to `"/characters/{character_id}/fittings/{fitting_id}/"`).
-
-2. **Conditional Resolution**  
-   - If `InferEndpointOrigin<RealEP, M>` results in `never`, it means no matching parameterized endpoint could be inferred from the given real endpoint. In such cases, the type falls back and returns `RealEP` as is.
-   - If the inference is successful, the resolved parameterized endpoint is returned.
-
-## Practical Example
-
-```ts
-type Resolved = ResolvedEndpoint<"/characters/123/fittings/456/", "delete">;
-// Evaluates to: "/characters/{character_id}/fittings/{fitting_id}/"
-```
-
-In this example:
-- The real endpoint `"/characters/123/fittings/456/"` along with the HTTP method `"delete"` is provided.
-- `InferEndpointOrigin` successfully maps it to its original form (`"/characters/{character_id}/fittings/{fitting_id}/"`), so that becomes the resolved endpoint.
-- If the mapping had failed (i.e., if no parameterized endpoint matched), the type would have defaulted to returning the original real endpoint.
-
----
-
-`ResolvedEndpoint` thus ensures that you get a consistent and properly parameterized endpoint format, which is crucial for maintaining type safety and clarity in API route definitions.

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "compilerOptions": {
-    "skipDefaultLibCheck": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    // "declarationDir": "./dts",
-    "outDir": ".", 
-    "target": "esnext",
-    "module": "esnext",
-    "diagnostics": true,
-    "newLine": "LF",
-    "strict": true,
-    "moduleResolution": "node",
-    "rootDirs": [
-      "./scripts"
-    ]
-  },
-  "include": [
-    "./scripts/**/*.mts",
-    "./scripts/**/*.d.ts",
-    "./v2/*.d.ts"
-  ],
-  "exclude": [
-    "./scripts/auth-*",
-    "./scripts/esi-*",
-  ]
-}