eve-esi-types 3.1.6 → 3.1.7

package/docs/v2/require-these.md

@@ -1,57 +0,0 @@
-# Explanation of the `RequireThese` Type
-
-The `RequireThese` type is a utility type that takes an existing type `T` and a subset of its keys `K`, and marks those keys as **required**. The rest of the properties in `T` remain unchanged. This is especially useful when you want to enforce that certain properties are provided while leaving other properties optional or in their original state.
-
-## Type Definition
-
-```typescript
-type RequireThese<T, K extends keyof T> = {
-  [P in keyof T as P extends K ? P : never]-?: T[P];
-} & {
-  [P in keyof T as P extends K ? never : P]: T[P];
-};
-```
-
-## How It Works
-
-1. **Selecting Required Keys**  
-   The first mapped type:
-   ```typescript
-   {
-     [P in keyof T as P extends K ? P : never]-?: T[P];
-   }
-   ```
-   - Iterates over each property key `P` in `T`.
-   - Uses a conditional type `P extends K ? P : never` to filter in only the keys that are specified in `K`.
-   - The `-?` operator removes the optional modifier, ensuring that these properties are marked as required.
-
-2. **Preserving Other Keys**  
-   The second mapped type:
-   ```typescript
-   {
-     [P in keyof T as P extends K ? never : P]: T[P];
-   }
-   ```
-   - Iterates over each property key `P` in `T`.
-   - Uses a conditional type to exclude the keys in `K` (by returning `never` for them), effectively preserving only the properties not in `K` in their original form.
-
-3. **Combining the Results**  
-   The intersection (`&`) of the two mapped types results in a new type that:
-   - Contains all keys in `K` as required.
-   - Contains all keys not in `K` with their original modifiers (optional or required).
-
-## Practical Example
-
-```typescript
-type Original = { a?: number; b?: string; c: boolean };
-type RequiredA = RequireThese<Original, 'a'>;
-// Evaluates to: { a: number; b?: string; c: boolean }
-```
-
-In this example:
-- The property `a` is transformed from an optional property to a required property.
-- The properties `b` and `c` retain their original statuses, with `b` remaining optional and `c` remaining required.
-
----
-
-`RequireThese` provides a concise way to enforce the presence of selected properties within a type, making it an effective tool for enhancing type safety in TypeScript.

package/docs/v3/esi-enhanced-function-signature.md

@@ -1,67 +0,0 @@
-# Explanation of the `TESIEnhancedRequestFunctionSignature` Type
-
-`TESIEnhancedRequestFunctionSignature` is a highly generic function signature type for performing enhanced ESI requests.  
-It extends a base request function signature by injecting a prepended parameter at the beginning of the function call,  
-thereby providing extra context or enabling pre-processing prior to executing the request.  
-
-This signature adapts to the specifics of the chosen HTTP method, endpoint configuration, inferred path parameters,  
-and additional request options—making it ideal for advanced API interactions where both flexibility and strict type-safety are required.
-
-## Generic Parameters
-
-- **`PrependParam`**: The type of the additional parameter that is injected at the beginning of the function call.
-- **`ActualOpt`**: An object representing the default options (typically extending `ESIRequestOptions`) used for the request.
-
-## Function Generic Parameters
-
-- **`Mtd`**: The ESI request method type (e.g., GET, POST, DELETE) as defined in `TESIEntryMethod`.
-- **`REP`**: The endpoint type, which can be either a version with replaced path parameters (via `ReplacePathParams`) or the raw endpoint type from `ESIEndpointOf<Mtd>`.
-- **`EPX`**: The resolved endpoint type, derived from `REP` and `Mtd`.
-- **`PPM`**: The type representing the inferred path parameters extracted from `REP` and `EPX`.
-- **`Opt`**: The type for additional request options, as deduced from the HTTP method (`Mtd`), endpoint (`EPX`), the default options (`ActualOpt`), and the inferred path parameters (`PPM`).
-- **`Ret`**: The type of the response result from the ESI request, as inferred from the method and the endpoint.
-- **`HasOpt`**: An internal flag, computed via `HasRequireParams<Mtd, EPX, PPM>`, used to determine whether the request options (`Opt`) are required (evaluating to `1`) or optional (evaluating to `0`).
-
-## Parameters
-
-- **`prependParam: PrependParam`**  
-  A prepended parameter that supplies additional context or configuration necessary for the request.
-  
-- **`method: Mtd`**  
-  The HTTP method for the request.
-
-- **`endpoint: REP`**  
-  The API endpoint, which may include path parameter replacements (as provided by `ReplacePathParams`).
-
-- **`...options: HasOpt extends 1 ? [Opt] : [Opt?]`**  
-  A rest parameter representing additional options for the request. This is required if `HasOpt` is `1` (indicating that some options are mandatory), otherwise it is optional.
-
-## Return Value
-
-- Returns a `Promise<Ret>` that resolves with the response from the ESI endpoint, where `Ret` reflects the inferred result type.
-
-## Type Definition
-
-```typescript
-type TESIEnhancedRequestFunctionSignature<
-  PrependParam extends unknown, ActualOpt extends Record<string, unknown>
-> = <
-  Mtd extends TESIEntryMethod,
-  REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
-  EPX extends ResolvedEndpoint<REP, Mtd>,
-  PPM extends InferPathParams<REP, EPX>,
-  Opt extends IdentifyParameters<Mtd, EPX, ActualOpt, PPM>,
-  Ret extends InferESIResponseResult<Mtd, EPX>,
-  HasOpt = HasRequireParams<Mtd, EPX, PPM>
->(
-  prependParam: PrependParam,
-  method: Mtd,
-  endpoint: REP,
-  ...options: HasOpt extends 1 ? [Opt] : [Opt?]
-) => Promise<Ret>;
-```
-
----
-
-`TESIEnhancedRequestFunctionSignature` combines dynamic type inference with advanced parameter and return type handling to support complex API interactions in a type-safe manner.  
-It ensures that extra configuration is accounted for at the start of the function call, aligning the signature with the specific needs of the API endpoint and HTTP method being used.

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.