eve-esi-types 3.2.4 → 3.2.7

package/dist/v2/types-util.d.ts

@@ -0,0 +1,281 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * THIS DTS IS AUTO GENERATED, DO NOT EDIT
+ * 
+ * @file eve-esi-types/v2/types-util.d.ts
+ * @summary This file is auto-generated and defines version 3.2.7 of the EVE Online ESI response types.
+ */
+import type { TESIResponseOKMap } from "./response-map.d.ts";
+import type { RestrictKeys, CombineIntersection } from "./index.d.ts";
+
+
+/**
+ * Defines the keys used in ESI entries for request parameters.  
+ * These keys represent the main categories of parameters that can be included in an ESI request.
+ */
+export type ESIEntryParamKeys = "auth" | "query" | "body" | "pathParams";
+/**
+ * Defines the keys that are not directly involved in ESI request parameters.  
+ * These keys represent metadata or additional information that is not part of the main request parameters.
+ */
+export type ESIEntryExtraKeys = "result" | "tag" | "cachedSeconds";
+
+/**
+ * Resolves the parameters required for making an ESI request to a specific endpoint.
+ *
+ * This type combines the user-supplied options, path parameters, and the expected response type
+ * to produce a structured result that includes:
+ * - The actual response payload type (`result`).
+ * - The final options object (`finalOptions`) that should be passed to the request.
+ * - A flag (`optionIsRequire`) indicating whether the options object is mandatory.
+ *
+ * @template Mtd - The HTTP method (e.g., "get", "post") of the request.
+ * @template REP - The endpoint path, which can be parameterized or already resolved with numbers.
+ * @template EPO - The resolved endpoint type tied to `REP`.
+ * @template Opt - A record type representing user-supplied request options.
+ * @template PathParams - A record type representing path parameters for the endpoint.
+ * @template EntryWithParams - The merged type of the response payload and path parameters.
+ * @template RequireKeys - The keys from `EntryWithParams` that represent actual request parameters.
+ *
+ * @returns An object containing:
+ * - `result`: The actual response payload type.
+ * - `finalOptions`: The exact options object to pass in (e.g., pathParams, query, body, auth).
+ * - `optionIsRequire`: A flag (`1` or `0`) indicating whether the options object is required.
+ *
+ * @example
+ * ```ts
+ * // Example endpoint: /characters/{character_id}/attributes/
+ * type ExampleOpt = { auth: true; token: "eyJhbGciOiJSUzI1NiIsI..." };
+ * type ResolvedParams = ResolveEndpointParameters<
+ *   "get", `/characters/${123345}/attributes/`, "/characters/{character_id}/attributes/",
+ *   ExampleOpt
+ * >;
+ * // Result:
+ * // { auth: true, token: "eyJhbGciOiJSUzI1NiIsI..." }
+ * ```
+ *
+ * @see {@link CombineIntersection}
+ * @see {@link RestrictKeys}
+ * @see {@link _ESIResponseType}
+ */
+export type ResolveEndpointParameters<
+  Mtd extends TESIEntryMethod,
+  // REP is either a parameterized path or already number-filled:
+  REP extends ReplacePathParams<ESIEndpointOf<Mtd>> | ESIEndpointOf<Mtd>,
+  // <— tie it directly to REP via ResolvedEndpoint:
+  EPO extends ResolvedEndpoint<Mtd, REP>,
+  // user-supplied options:
+  Opt extends Record<string, unknown>,
+
+  // now that EPO is fixed, these defaults all line up:
+  PathParams extends InferPathParams<REP, EPO> = InferPathParams<REP, EPO>,
+  EntryWithParams = _ESIResponseType<Mtd, EPO> & PathParams,
+  RequireKeys extends keyof EntryWithParams = Exclude<keyof EntryWithParams, ESIEntryExtraKeys>,
+  FinalOpt = CombineIntersection<
+    RestrictKeys<Opt, RequireKeys> & Pick<EntryWithParams, RequireKeys>
+  >
+> = {
+  // the actual `"result"` payload type
+  result: EntryWithParams extends { result: infer R } ? R : never;
+  // the exact options object you should pass in (pathParams/query/body/auth)
+  finalOptions: FinalOpt;
+  // 1 if you _must_ pass an options object, else 0
+  optionIsRequire: HasRequireParams<Mtd, EPO, PathParams>;
+};
+
+
+/**
+ * Represents a function that can make ESI requests with various HTTP methods.
+ *
+ * @template ActualOpt The actual type of the options.
+ *
+ * ```ts
+ * // @ ts-expect-error
+ * 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, opt) {
+ *         return this(method, endpoint, opt);
+ *     } as TESIRequestFunctionEachMethod2<typeof method>;
+ * });
+ * ```
+ */
+export interface IESIRequestFunction2<ActualOpt extends Record<string, unknown>>
+  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  
+ *    TESIRequestFunctionSignature2 and you want to implement additional shorthand methods.
+ *
+ * @template ActualOpt The actual type of the options.
+ *
+ * @example
+ * ```ts
+ * 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 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 TESIRequestFunctionMethods2<ActualOpt extends Record<string, unknown>> = {
+  [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 = 0
+> = {
+  [M in TESIEntryMethod]: {
+    [EP in ESIEndpointOf<M>]: TESIResponseOKMap[M][EP] extends { cachedSeconds: number }
+      ? AsEndpoint extends 0
+        ? TESIResponseOKMap[M][EP]["cachedSeconds"]: EP
+      : never
+  }[ESIEndpointOf<M>];
+}[Method];
+
+/**
+ * Indicates that no path parameters are allowed.
+ *
+ * This type serves as a compile-time signal for endpoints that do not support dynamic URL segments.  
+ * By using this type, it is clear that no path parameters should be provided.
+ */
+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.  
+ *  include `string` in the `EPx` constraints to avoid breaking typescript inference.
+ * 
+ * @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}
+ */
+//* ctt
+export type _IfNeedPathParams<
+  EP extends PropertyKey,
+  Parameterized extends IfParameterizedPath<EP> = IfParameterizedPath<EP>
+> = Parameterized extends 0
+  ? TPathParamsNever :
+    EP extends ReplacePathParams<EP>
+      ? TPathParamsNever : { pathParams: Parameterized };
+/*/
+export type _IfNeedPathParams<
+  EP extends PropertyKey,
+  Parameterized extends IfParameterizedPath<EP> = IfParameterizedPath<EP>
+> = Parameterized extends 0
+  ? TPathParamsNever : { pathParams: Parameterized };
+//*/
+
+/**
+ * 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.
+ * 
+ * @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}
+ * @deprecated 2025/4/28
+ * @see Documentation of [`PickRequireParams`](https://github.com/jeffy-g/eve-esi-types/blob/master/docs/v3/pick-require-params.md)
+ */
+export type __PickRequireParams<
+  M extends TESIEntryMethod,
+  EPx extends ESIEndpointOf<M> | string,
+  AdditionalParams,
+> = Exclude<keyof (_ESIResponseType<M, EPx> & AdditionalParams), ESIEntryExtraKeys>;
+
+/**
+ * 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
+ */
+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
+ */
+export type __IdentifyParameters<
+  Entry, Opt,
+  Keys = Exclude<keyof Entry, ESIEntryExtraKeys>
+  // @ts-expect-error 
+> = RequireThese<Opt, Keys> & Pick<Entry, Keys>;

package/dist/v2/util.d.ts

@@ -0,0 +1,149 @@
+/*!
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+//  Copyright (C) 2025 jeffy-g <hirotom1107@gmail.com>
+//  Released under the MIT license
+//  https://opensource.org/licenses/mit-license.php
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+*/
+/**
+ * @file eve-esi-types/v2/util.d.ts
+ * @since 2.3.1
+ */
+
+/**
+ * If `Path` is parameterized, return the parameter name, such as `killmail_id`.
+ * 
+ * @template Path The string representing the endpoint path.
+ * @returns {string | never} The parameter name if the path is parameterized, otherwise `never`.
+ */
+//* ctt
+export type PickPathParameters<Path extends PropertyKey> =
+  Path extends `${string}/{${infer Param}}/${infer Rest}`
+  ? Param | PickPathParameters<`/${Rest}`>
+  : never;
+/*/
+export type PickPathParameters<Path extends string> =
+  Path extends `${string}/{${infer Param}}/${string}/{${infer Param2}}/${string}`
+  ? Param | Param2 : Path extends `${string}/{${infer Param}}/${string}`
+    ? Param
+  : never;
+//*/
+export type PathParamsToMap<EP extends PropertyKey> =
+  EP extends `${infer _Start}{${infer Param}}${infer Rest}`
+    ? { [K in Param | keyof PathParamsToMap<Rest>]: string }
+    : {};
+
+/**
+ * Convert a union type to an intersection type.
+ * 
+ * @template U The union type to convert.
+ * @returns {I} The intersection type.
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Convert a union type to a tuple.
+ * 
+ * @template T The union type to convert.
+ * @returns {Array} The tuple representation of the union type.
+ */
+export type UnionToTuple<T> = UnionToIntersection<
+  T extends any ? () => T : never
+> extends () => infer R ? [...UnionToTuple<Exclude<T, R>>, R] : [];
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - -
+//              Implemented: 2025/4/28
+// - - - - - - - - - - - - - - - - - - - - - - - - - -
+/**
+ * Extracts parameter keys from a parameterized path string as a tuple.
+ *
+ * This utility type takes a parameterized path string (e.g., `"/foo/{a}/bar/{b}/baz/"`)
+ * and extracts the parameter keys (e.g., `["a", "b"]`) as a tuple.
+ *
+ * @template Path - The parameterized path string.
+ * @returns {string[]} A tuple of parameter keys extracted from the path.
+ *
+ * @example
+ * ```ts
+ * type Params = ExtractPathParamKeys<"/foo/{a}/bar/{b}/baz/">;
+ * // Result: ["a", "b"]
+ * ```
+ */
+export type ExtractPathParamKeys<
+  P extends PropertyKey
+> = P extends `${infer _Before}{${infer Param}}${infer Rest}`
+  ? [Param, ...ExtractPathParamKeys<Rest>]
+  : [];
+
+/**
+ * Extract parameter keys from either
+ *  - a single parameterized path string, or
+ *  - an array (or readonly array) of those strings,
+ * and return them as a union.
+ *
+ * @template Path
+ *   Either a string template or an (readonly) array of string templates.
+ * @returns A union of all parameter names.
+ *
+ * @example
+ * type U1 = ExtractPathParamUnion<"/foo/{a}/bar/{b}/baz/">;
+ * // -> "a" | "b"
+ *
+ * type U2 = ExtractPathParamUnion<
+ *   ["/foo/{a}/bar/{b}/baz/", "/users/{user_id}/posts/{post_id}"]
+ * >;
+ * // -> "a" | "b" | "user_id" | "post_id"
+ */
+export type ExtractPathParamUnion<Path extends string | readonly string[]> =
+  Path extends readonly any[]
+    ? ExtractPathParamKeys<Path[number]>[number]
+    : Path extends string
+      ? ExtractPathParamKeys<Path>[number] : never;
+
+
+/**
+ * #### Build an array of elements from a flattened tuple of type "1" | "2" | "3" ...
+ * 
+ * NOTE: This utility cannot calculate lengths greater than 48 (?).
+ * 
+ *  + Returns the final length of the array.
+ * 
+ * @template T The union type to be converted to a tuple and measured.
+ * @returns {number} The length of the tuple.
+ * @date 2025/2/11 18:12:02
+ */
+export type InferKeysLen<T> = UnionToTuple<T>["length"];
+/**
+ * Splits a string by a delimiter and returns a tuple of the resulting substrings.
+ * @example
+ * Split<"get:/characters/{character_id}/wallet/", ":">
+ * // Result: ["get", "/characters/{character_id}/wallet/"]
+ */
+export type Split<S extends string, D extends string = ":"> = 
+  S extends `${infer T}${D}${infer U}` 
+    ? [T, ...Split<U, D>] 
+    : [S];
+
+// // Test cases
+// type Test1 = Split<"get:/characters/{character_id}/wallet/">;
+// // Expected: ["get", "/characters/{character_id}/wallet/"]
+// type Test2 = Split<"a.b.c", ".">;
+// // Expected: ['a', 'b', 'c']
+// type Test3 = Split<"hello", ",">;
+// // Expected: ['hello']
+
+/**
+ * Combines an intersection of object types into a single object type.
+ * 
+ * @template IS The intersection of object types to combine.
+ * @returns {Record<string, unknown>} A single object type with all properties from the intersection.
+ * 
+ * @example
+ * type Combined = CombineIntersection<{ a: string } & { b: number }>;
+ * // Result: { a: string; b: number }
+ */
+//* ctt
+// export type CombineIntersection<IS> = IS extends infer O ? { [K in keyof O]: O[K] } : never;
+export type CombineIntersection<IS extends Record<string, unknown>> = { [K in keyof IS]: IS[K] };
+/*/
+export type CombineIntersection<IS> = IS;
+//*/

package/lib/console-util.mjs

@@ -83,7 +83,7 @@ export function getLogger(banner, logSelector = ".log-frame") {
         return console.log.bind(console, banner);
     }
     else {
-        /** @type {function(...any): void} */
+        /** @type {(...data: any[]) => void} */
         const log = (...data) => {
             let text = banner;
             for (const d of data) {

package/lib/request-api.d.mts

@@ -6,10 +6,10 @@
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
 import * as util from "./rq-util.mjs";
-import type { IESIRequestFunction2 } from "../v2";
+import type { IESIRequestFunction2 } from "../dist/v2";
 /**
- * @typedef {import("../v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
- * @typedef {import("../v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
+ * @typedef {import("../dist/v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {import("../dist/v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
  */
 /** #### Sample of `TESIRequestFunctionSignature`
  *
@@ -19,7 +19,7 @@ import type { IESIRequestFunction2 } from "../v2";
  * @type {IESIRequestFunction2}
  * @param method - The HTTP method to use for the request
  * @param endpoint - The Path of the ESI endpoint to send the request to
- * @param options - An object of options to include in the request
+ * @param opt - An object of options to include in the request
  * @returns A Promise object containing the response data
  * @throws {util.ESIRequestError}
  */

package/lib/request-api.mjs

@@ -5,7 +5,7 @@
 //  https://opensource.org/licenses/mit-license.php
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 */
-/// <reference types="../v2"/>
+/// <reference types="../dist/v2"/>
 // - - - - - - - - - - - - - - - - - - - -
 //               imports
 // - - - - - - - - - - - - - - - - - - - -
@@ -17,8 +17,8 @@ import * as util from "./rq-util.mjs";
 const log = util.getUniversalLogger("[request-api]: ");
 const DEBUG = util.isDebug();
 /**
- * @typedef {import("../v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
- * @typedef {import("../v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
+ * @typedef {import("../dist/v2").IESIRequestFunction2<util.ESIRequestOptions>} IESIRequestFunction2
+ * @typedef {import("../dist/v2").TESIRequestFunctionMethods2<util.ESIRequestOptions>} TESIRequestFunctionMethods2
  */
 // - - - - - - - - - - - - - - - - - - - -
 //            main functions
@@ -31,22 +31,20 @@ const DEBUG = util.isDebug();
  * @type {IESIRequestFunction2}
  * @param method - The HTTP method to use for the request
  * @param endpoint - The Path of the ESI endpoint to send the request to
- * @param options - An object of options to include in the request
+ * @param opt - An object of options to include in the request
  * @returns A Promise object containing the response data
  * @throws {util.ESIRequestError}
  */
 export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endpoint, opt) => {
+    // When only options are provided
+    const nOpt = util.normalizeOptions([opt]);
     /** @type {number[]=} */
     let pathParams;
-    if (typeof opt?.pathParams === "number" || Array.isArray(opt?.pathParams)) {
-        pathParams = /** @type {number[]} */ (Array.isArray(opt.pathParams) ? opt.pathParams : [opt.pathParams]);
-    }
-    if (Array.isArray(pathParams)) {
-        endpoint = util.replaceCbt(endpoint, pathParams);
+    if (typeof nOpt.pathParams === "number" || Array.isArray(nOpt.pathParams)) {
+        pathParams = (Array.isArray(nOpt.pathParams) ? nOpt.pathParams : [nOpt.pathParams]);
     }
-    // When only options are provided
-    const actualOpt = /** @type {NonNullable<typeof opt>} */ (opt || {});
-    const { rqopt, qss } = util.initOptions(method, actualOpt);
+    Array.isArray(pathParams) && (endpoint = util.replaceCbt(endpoint, pathParams));
+    const { rqopt, qss } = util.initOptions(method, nOpt);
     const endpointUrl = util.curl(endpoint);
     const up = new URLSearchParams(qss);
     const url = `${endpointUrl}${up.size ? `?${up}` : ""}`;
@@ -59,7 +57,7 @@ export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endp
         }
         // else if (isError(status)) {}
         // Actually, throw Error
-        throw await util.handleESIError(res, endpointUrl, actualOpt.cancelable);
+        throw await util.handleESIError(res, endpointUrl, nOpt.cancelable);
     }
     catch (e) {
         log(e);
@@ -69,8 +67,9 @@ export const request2 = /** @type {IESIRequestFunction2} */ (async (method, endp
 // implements rest methods of `request` (IESIRequestFunction2)
 //
 /** @type {TESIEntryMethod[]} */ (["get", "post", "put", "delete"]).forEach((method) => {
-    request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, util.ESIRequestOptions>} */ ((endpoint, opt) => {
-        // @ts-expect- error TODO: ts(2345)
-        return request2(method, endpoint, /** @type {Parameters<typeof request2>[2]} */ (opt));
+    request2[method] = /** @type {TESIRequestFunctionEachMethod2<typeof method, util.ESIRequestOptions>} */ ((endpoint, ...opt) => {
+        // @ts-expect-error TODO: ts(2345)
+        return request2(method, endpoint, ...opt);
+        // return request2(method, endpoint, /** @type {Parameters<typeof request2>[2]} */(opt) as Parameters<typeof request2>[2]);
     });
 });