@grandlinex/swagger-mate 1.2.2 → 1.3.2

package/dist/mjs/Swagger/Path/SPathUtil.js

@@ -1,8 +1,10 @@
 import { getEntityMeta, XUtil, getColumnMeta, } from '@grandlinex/core';
 import map from './SUtilMap.js';
+import { isSwaggerRef, } from '../Meta/SwaggerTypes.js';
 function resolveDBType(dType) {
     switch (dType) {
         case 'int':
+        case 'long':
             return 'integer';
         case 'double':
         case 'float':
@@ -24,6 +26,11 @@ function resolveDBType(dType) {
     }
 }
 export default class SPathUtil {
+    /**
+     * Generates a default response mapping for the specified HTTP status types.
+     *
+     * @param {HttpStatusTypes[]} types - The HTTP status types for which default responses should be created.
+     * @return {SwaggerRPathConfResponse} An object mapping each provided status type to its default response definition. */
     static defaultResponse(...types) {
         const res = {};
         types.forEach((el) => {
@@ -31,6 +38,12 @@ export default class SPathUtil {
         });
         return res;
     }
+    /**
+     * Creates a request body definition for JSON content type using the provided schema.
+     *
+     * @param {SSchemaEl} schema - The JSON schema used for validating the request body.
+     * @return {SwaggerRPathReqBody} A Swagger path request body object specifying application/json content type with the provided schema.
+     */
     static jsonBody(schema) {
         return {
             content: {
@@ -40,6 +53,13 @@ export default class SPathUtil {
             },
         };
     }
+    /**
+     * Builds a Swagger request body for `multipart/form-data` requests.
+     *
+     * @param {SSchemaEl} [schema] Optional schema describing the form data.
+     *        If omitted, a default schema with a single binary `file` field is provided.
+     * @return {SwaggerRPathReqBody} Swagger request body definition with
+     *         `multipart/form-data` content and the supplied or default schema. */
     static formBody(schema) {
         return {
             content: {
@@ -58,6 +78,14 @@ export default class SPathUtil {
             },
         };
     }
+    /**
+     * Generates a Swagger content definition for the provided entity.
+     *
+     * @param {T} entity - The entity instance to derive the Swagger schema from.
+     * @param {boolean} [list] - When true, the schema will be wrapped in an array type, representing a list of entities.
+     *
+     * @returns {SwaggerContent|undefined} The Swagger content object for the entity, or `undefined` if the entity does not have a schema.
+     */
     static entityContent(entity, list) {
         const schema = this.schemaFromEntity(entity);
         if (!schema) {
@@ -79,6 +107,13 @@ export default class SPathUtil {
             },
         };
     }
+    /**
+     * @template T extends CoreEntity
+     * @param {T} entity - The entity instance for which to build the response configuration.
+     * @param {boolean} [list] - Indicates whether the response should represent a list of entities.
+     * @param {boolean} [create] - Indicates whether the response corresponds to a creation operation (status code 201); otherwise 200.
+     * @returns {SwaggerRPathConfResponse} The Swagger response configuration object containing the appropriate status code and content.
+     */
     static entityResponse(entity, list, create) {
         const code = create ? '201' : '200';
         const an = {};
@@ -88,9 +123,58 @@ export default class SPathUtil {
         };
         return an;
     }
+    /**
+     * Builds a JSON schema reference path for the given component name.
+     *
+     * @param {string} inp - The name of the schema component.
+     * @return {string} The JSON reference path formatted as `#/components/schemas/<inp>`.
+     */
     static schemaPath(inp) {
         return `#/components/schemas/${inp}`;
     }
+    /**
+     * Creates a Swagger request body definition that references a schema.
+     *
+     * @param {string | CoreEntity} $ref
+     *   Either the string reference to a schema or a `CoreEntity` instance whose
+     *   class name will be used to build the reference path.
+     * @param {boolean} list
+     *   If true, the referenced schema is wrapped in an array; otherwise the
+     *   schema is used directly.
+     * @returns {SwaggerRPathReqBody}
+     *   The request body object containing the appropriate content and schema
+     *   configuration.
+     */
+    static refRequest($ref, list) {
+        const t = typeof $ref === 'string'
+            ? { $ref }
+            : {
+                $ref: this.schemaPath(XUtil.getEntityNames($ref).className),
+            };
+        if (list) {
+            return {
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'array',
+                            items: t,
+                        },
+                    },
+                },
+            };
+        }
+        return {
+            content: {
+                'application/json': {
+                    schema: t,
+                },
+            },
+        };
+    }
+    /**
+     * Creates a Swagger response configuration for a given HTTP status code.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for */
     static refResponse(code, $ref, list, ...addCodes) {
         const an = {
             ...this.defaultResponse(...addCodes),
@@ -125,6 +209,15 @@ export default class SPathUtil {
         }
         return an;
     }
+    /**
+     * Builds a Swagger response configuration object for a given HTTP status code and schema.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for the response.
+     * @param {SSchemaEl} schema - The JSON schema definition for the response body.
+     * @param {boolean} list - If true, the schema is wrapped in an array for list responses.
+     * @param {...HttpStatusTypes} addCodes - Additional HTTP status codes for default responses.
+     * @return {SwaggerRPathConfResponse} The constructed response configuration object.
+     */
     static jsonResponse(code, schema, list, ...addCodes) {
         const an = {
             ...this.defaultResponse(...addCodes),
@@ -154,6 +247,23 @@ export default class SPathUtil {
         }
         return an;
     }
+    /**
+     * Generates a JSON schema representation from a CoreEntity instance.
+     *
+     * This method inspects the entity's metadata to construct a schema object
+     * describing the entity's shape. The resulting schema contains:
+     * - `type`: always `"object"`.
+     * - `description`: a string indicating the entity name.
+     * - `required`: an array of property names that are defined on the entity.
+     * - `properties`: an object mapping each property name to an object that
+     *   includes the resolved database type and its nullability.
+     *
+     * If no metadata is found for the provided entity, the method returns `undefined`.
+     *
+     * @param {T} entity - The entity instance for which to create a schema.
+     * @returns {SSchemaEl | undefined} The generated schema object, or `undefined`
+     *          if the entity's metadata could not be retrieved.
+     */
     static schemaFromEntity(entity) {
         const schema = {
             type: 'object',
@@ -169,16 +279,21 @@ export default class SPathUtil {
         keys.forEach((k) => {
             const cMeta = getColumnMeta(entity, k);
             if (cMeta && schema.properties) {
-                if (!cMeta.canBeNull) {
-                    schema.required?.push(k);
-                }
+                schema.required.push(k);
                 schema.properties[k] = {
                     type: resolveDBType(cMeta.dataType),
+                    nullable: cMeta.canBeNull,
                 };
             }
         });
         return schema;
     }
+    /**
+     * Generates a content schema object for the given entity. The schema contains a description derived from the entity metadata and a JSON content schema based on the entity's structure.
+     *
+     * @param {T} entity - The entity instance for which to generate the content schema. The generic type `T` must extend {@link CoreEntity}.
+     * @returns {{ description: string; content: { 'application/json': { schema: SSchemaEl } }; } | undefined} An object containing the content schema, or `undefined` if no metadata is available for the entity.
+     */
     static contentSchemaFromEntity(entity) {
         const meta = getEntityMeta(entity);
         if (!meta) {
@@ -194,8 +309,10 @@ export default class SPathUtil {
         };
     }
     /**
-     * generate global schema
-     * @param e
+     * Generates a mapping from entity names to their corresponding schema objects.
+     *
+     * @param {CoreEntity[]} e The entities for which schema entries should be generated.
+     * @return {SKey<SSchemaEl>} An object whose keys are entity names and values are the schemas derived from those entities.
      */
     static schemaEntryGen(...e) {
         const out = {};
@@ -207,6 +324,14 @@ export default class SPathUtil {
         });
         return out;
     }
+    /**
+     * Builds a JSON schema representation for an entity view that includes both the
+     * entity data and its related entity map.
+     *
+     * @param entity The primary entity used to construct the `dat` portion of the schema.
+     * @param entityMap The related entity map used to construct the `join_map` portion of the schema.
+     * @returns A {@link SSchemaEl} object schema with properties `i`, `dat`, and `join_map`.
+     */
     static schemaFromEntityView(entity, entityMap) {
         return {
             type: 'object',
@@ -219,4 +344,135 @@ export default class SPathUtil {
             },
         };
     }
+    /**
+     * Extends an entity schema object by merging additional schema options.
+     *
+     * @param {CoreEntity} entity
+     *   The entity for which the schema should be extended.
+     *
+     * @param {...Object} options
+     *   One or more objects defining schema extensions. Each object may contain:
+     *   - `key` (string): The property key to add or extend.
+     *   - `list` (boolean, optional): Indicates whether the property is a list.
+     *   - `entity` (CoreEntity, optional): The entity type for the property.
+     *   - `schema` (SSchemaEl, optional): A custom schema definition for the property.
+     *   - `required` (boolean, optional): Whether the property is required.
+     *
+     * @return {SSchemaEl}
+     *   The resulting schema element. If a single property is returned by
+     *   `extendEntitySchema`, its schema is returned directly; otherwise an
+     *   object schema with a type of `'object'` is returned.
+     */
+    static extendEntitySchemaObject(entity, ...options) {
+        const schema = this.extendEntitySchema(entity, ...options);
+        const ent = Object.entries(schema);
+        if (ent.length === 1) {
+            return ent[0][1];
+        }
+        return {
+            type: 'object',
+        };
+    }
+    /**
+     * Extends the schema of a given {@link CoreEntity} with additional properties.
+     *
+     * @param {CoreEntity} entity
+     *   The entity whose schema will be extended.
+     *
+     * @param {...{
+     *   key: string,
+     *   list?: boolean,
+     *   entity?: CoreEntity,
+     *   schema?: SSchemaEl,
+     *   required?: boolean
+     * }} options
+     *   One or more option objects specifying the extensions to apply. Each option
+     *   may provide either a direct schema (`schema`) or an entity reference
+     *   (`entity`). The `list` flag indicates whether the property should be
+     *   represented as an array of the provided schema. The `required` flag
+     *   adds the property to the schema’s required list.
+     *
+     * @returns {SKey<SSchemaEl>}
+     *   An object containing the updated schema for the entity, keyed by the
+     *   entity’s name. If the entity metadata cannot be found, an empty
+     *   object is returned.
+     */
+    static extendEntitySchema(entity, ...options) {
+        const meta = getEntityMeta(entity);
+        if (meta) {
+            const schema = SPathUtil.schemaEntryGen(entity)[meta.name];
+            if (schema && !isSwaggerRef(schema) && schema.properties) {
+                for (const option of options) {
+                    if (option.schema) {
+                        if (option.list) {
+                            schema.properties[option.key] = {
+                                type: 'array',
+                                items: option.schema,
+                            };
+                        }
+                        else {
+                            schema.properties[option.key] = option.schema;
+                        }
+                    }
+                    else if (option.entity) {
+                        const eMeta = getEntityMeta(option.entity);
+                        if (eMeta) {
+                            const scheme = SPathUtil.schemaEntryGen(option.entity)[eMeta.name];
+                            if (option.list) {
+                                schema.properties[option.key] = {
+                                    type: 'array',
+                                    items: scheme,
+                                };
+                            }
+                            else {
+                                schema.properties[option.key] = scheme;
+                            }
+                        }
+                    }
+                    if (option.required) {
+                        schema.required = [...(schema.required || []), option.key];
+                    }
+                }
+            }
+            return {
+                [meta.name]: schema,
+            };
+        }
+        return {};
+    }
+    /**
+     * Reduces the entity schema to a single schema element or a generic object.
+     *
+     * @param entity The entity whose schema should be reduced.
+     * @param keys Optional list of keys to include in the reduced schema. If omitted, all keys are considered.
+     * @return Returns the schema element of the sole key if only one key is present; otherwise, returns a generic object schema with type `'object'`. */
+    static reduceEntitySchemaObject(entity, ...keys) {
+        const schema = this.reduceEntitySchema(entity, ...keys);
+        const ent = Object.entries(schema);
+        if (ent.length === 1) {
+            return ent[0][1];
+        }
+        return {
+            type: 'object',
+        };
+    }
+    /**
+     * Creates a reduced version of an entity's schema by excluding specified properties.
+     *
+     * @param {CoreEntity} entity - The entity whose schema is to be processed.
+     * @param {...string} keys - Property names to remove from the schema's `properties` and `required` lists.
+     *
+     * @returns */
+    static reduceEntitySchema(entity, ...keys) {
+        const meta = getEntityMeta(entity);
+        if (meta) {
+            const schema = SPathUtil.schemaEntryGen(entity)[meta.name];
+            if (schema && !isSwaggerRef(schema) && schema.properties) {
+                schema.properties = Object.fromEntries(Object.entries(schema.properties).filter(([e]) => !keys.includes(e)));
+                schema.required = (schema.required || []).filter((e) => !keys.includes(e));
+            }
+            return { [meta.name]: schema };
+        }
+        return {};
+    }
 }

package/dist/mjs/Swagger/SwaggerUtil.d.ts

@@ -1,11 +1,27 @@
-import { ObjectLike } from '@grandlinex/core';
+import { CoreLogChannel, ObjectLike } from '@grandlinex/core';
 import { Server } from 'net';
 import { MergeInputType, SwaggerConfig, SwaggerRPath } from './Meta/SwaggerTypes.js';
 import { RouteData } from './annotation/index.js';
 export default class SwaggerUtil {
+    static logger: CoreLogChannel | null;
+    static getLogger(): CoreLogChannel;
     static writeMeta(conf: SwaggerConfig, kind: 'JSON' | 'YAML', path?: string): void;
     static readMeta(path: string): any;
-    static serveMeta(conf: SwaggerConfig, port?: number, auth?: string): Promise<Server | null>;
+    /**
+     * Serves a meta page for Swagger UI or rapi-doc.
+     *
+     * @param {SwaggerConfig} conf The swagger configuration to expose via `/spec`.
+     * @param {Object} [option] Options for serving the meta page.
+     * @param {'swagger-ui'|'rapi-doc'} [option.type='swagger-ui'] The type of UI to serve.
+     * @param {number} [option.port] The port to listen on. Defaults to 9000.
+     * @param {string} [option.auth] Optional authentication key appended to the URL.
+     * @returns {Promise<Server|null>} A promise that resolves with the created server instance or null.
+     */
+    static serveMeta(conf: SwaggerConfig, option?: {
+        type?: 'swagger-ui' | 'rapi-doc';
+        port?: number;
+        auth?: string;
+    }): Promise<Server | null>;
     static metaExtractor(root: ObjectLike, npmPackageVersion: boolean, ...path: ObjectLike[]): SwaggerConfig | undefined;
     static routeToSwaggerPath(route: RouteData): SwaggerRPath;
     static merge(root: SwaggerConfig, data: MergeInputType[]): SwaggerConfig;

package/dist/mjs/Swagger/SwaggerUtil.js

@@ -1,7 +1,7 @@
 import * as Path from 'path';
 import * as fs from 'fs';
 import jsyaml from 'js-yaml';
-import { CMap, instanceOfEntity } from '@grandlinex/core';
+import { CMap, CoreLogChannel, DefaultLogger, instanceOfEntity, } from '@grandlinex/core';
 import express from 'express';
 import * as process from 'process';
 import { getSComponent, getSPath, getSwaggerMeta } from './Meta/Swagger.js';
@@ -9,6 +9,13 @@ import PathHelp, { getBaseFolder } from '../PathHelp.js';
 import { getRouteMeta } from './annotation/index.js';
 import { SPathUtil } from '../index.js';
 export default class SwaggerUtil {
+    static getLogger() {
+        if (!this.logger) {
+            const logger = new DefaultLogger();
+            this.logger = new CoreLogChannel('SwaggerUtil', logger);
+        }
+        return this.logger;
+    }
     static writeMeta(conf, kind, path) {
         if (kind === 'JSON') {
             const p = Path.join(path || process.cwd(), 'openapi.json');
@@ -25,11 +32,25 @@ export default class SwaggerUtil {
             return JSON.parse(file);
         }
         catch (e) {
+            this.getLogger().error(e);
             return null;
         }
     }
-    static async serveMeta(conf, port, auth) {
-        const resFiles = PathHelp(getBaseFolder(), '..', 'res', 'html');
+    /**
+     * Serves a meta page for Swagger UI or rapi-doc.
+     *
+     * @param {SwaggerConfig} conf The swagger configuration to expose via `/spec`.
+     * @param {Object} [option] Options for serving the meta page.
+     * @param {'swagger-ui'|'rapi-doc'} [option.type='swagger-ui'] The type of UI to serve.
+     * @param {number} [option.port] The port to listen on. Defaults to 9000.
+     * @param {string} [option.auth] Optional authentication key appended to the URL.
+     * @returns {Promise<Server|null>} A promise that resolves with the created server instance or null.
+     */
+    static async serveMeta(conf, option) {
+        const type = option?.type ?? 'swagger-ui';
+        const port = option?.port || 9000;
+        const auth = option?.auth;
+        const resFiles = PathHelp(getBaseFolder(), '..', 'res', 'html', type);
         const key = auth ? `?auth=${auth}` : '';
         const app = express();
         app.use('/', express.static(resFiles));
@@ -37,8 +58,8 @@ export default class SwaggerUtil {
             res.status(200).send(conf);
         });
         return new Promise((resolve) => {
-            const s = app.listen(port || 9000, () => {
-                console.log(`listen on http://localhost:${port || 9000}${key}#`);
+            const s = app.listen(port, () => {
+                this.getLogger().log(`${type} listen on http://localhost:${port}${key}#`);
                 resolve(s);
             });
         });
@@ -83,7 +104,13 @@ export default class SwaggerUtil {
             // Handle requestBody
             if (!conf.requestBody) {
                 if (route.meta.requestSchema) {
-                    conf.requestBody = SPathUtil.jsonBody(route.meta.requestSchema);
+                    if (typeof route.meta.requestSchema === 'string' ||
+                        instanceOfEntity(route.meta.requestSchema)) {
+                        conf.requestBody = SPathUtil.refRequest(route.meta.requestSchema, route.meta.responseType === 'LIST');
+                    }
+                    else {
+                        conf.requestBody = SPathUtil.jsonBody(route.meta.requestSchema);
+                    }
                 }
             }
             // Handle responses

package/dist/mjs/Swagger/annotation/index.d.ts

@@ -8,13 +8,18 @@ export declare enum ActionMode {
     'DMZ_WITH_USER' = 2
 }
 export type ActionTypes = 'POST' | 'GET' | 'USE' | 'PATCH' | 'DELETE';
-export type ResponseTypes = 'LIST';
+/**
+ * LIST - Response is an array of items
+ * SINGLE - Response is a single item (default)
+ */
+export type ResponseRequestTypes = 'LIST' | 'SINGLE';
 export type RouteMeta = {
     pathOverride?: string;
     mode?: ActionMode;
-    requestSchema?: SSchemaEl;
+    requestSchema?: SSchemaEl | CoreEntity | string;
     responseSchema?: SSchemaEl | CoreEntity | string;
-    responseType?: ResponseTypes;
+    requestType?: ResponseRequestTypes;
+    responseType?: ResponseRequestTypes;
     responseCodes?: HttpStatusTypes[];
 } & SwaggerRPathConf;
 export type RouteData = {

package/dist/mjs/Swagger/debug/BaseCon.d.ts

@@ -38,13 +38,20 @@ export interface ConHandle {
     patch<T, J>(url: string, body?: J, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
     delete<T>(url: string, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
 }
+/**
+ * BaseCon provides a minimal client for interacting with an HTTP backend.
+ * It manages connection state, authentication tokens, and reconnection
+ * logic while delegating actual HTTP requests to a supplied {@link ConHandle}.
+ *
+ * @class
+ */
 export default class BaseCon {
-    api: string;
-    permanentHeader: undefined | Record<string, string>;
-    authorization: string | null;
-    disconnected: boolean;
-    failFlag: boolean;
-    logger: (arg: any) => void;
+    private api;
+    private permanentHeader;
+    private authorization;
+    private noAuth;
+    private disconnected;
+    private readonly logger;
     con: ConHandle;
     reconnect: () => Promise<boolean>;
     onReconnect: (con: BaseCon) => Promise<boolean>;
@@ -53,16 +60,113 @@ export default class BaseCon {
         endpoint: string;
         logger?: (arg: any) => void;
     });
+    /**
+     * Retrieves the API endpoint.
+     *
+     * @return {string} The API endpoint string.
+     */
+    getApiEndpoint(): string;
+    /**
+     * Sets the API endpoint URL used by the client.
+     *
+     * @param {string} endpoint - The full URL of the API endpoint.
+     * @returns {void}
+     */
+    setApiEndpoint(endpoint: string): void;
+    /**
+     * Indicates whether the instance is considered connected.
+     *
+     * The instance is regarded as connected when it either does not require authentication
+     * (`noAuth` is true) or it has an authorization token set (`authorization` is not null),
+     * and it is not currently marked as disconnected.
+     *
+     * @return {boolean} `true` if the instance is connected, `false` otherwise.
+     */
     isConnected(): boolean;
+    /**
+     * Returns the current authorization token.
+     *
+     * @return {string} The authorization token or an empty string if none is set.
+     */
     token(): string;
-    p(path: string, config?: ConHandleConfig): string;
+    private p;
+    /**
+     * Sends a ping request to the API to verify connectivity and version availability.
+     *
+     * @return {boolean} `true` if the API responded with a 200 status code and a valid version object; `false` otherwise.
+     */
     ping(): Promise<boolean>;
-    test(email: string, password: string): Promise<boolean>;
+    /**
+     * Validates the current authentication token by performing a ping and a test request
+     * to the backend. The method first ensures connectivity via {@link ping}. If the ping
+     * succeeds, it attempts to retrieve a token from the `/test/auth` endpoint using the
+     * current token in the `Authorization` header. The operation is considered successful
+     * if the response status code is 200 or 201.
+     *
+     * If any step fails, an error is logged and the method returns {@code false}. On
+     * success, it returns {@code true}.
+     *
+     * @return {Promise<boolean>} A promise that resolves to {@code true} if the token
+     * test succeeds, otherwise {@code false}.
+     */
     testToken(): Promise<boolean>;
-    connect(email: string, pw: string): Promise<boolean>;
     /**
-     * Enable client before auth
+     * Attempts to establish a connection to the backend without authentication.
+     *
+     * This method sends a ping request.  If the ping succeeds, it clears any
+     * existing authorization data, marks the instance as connected,
+     * enables the no‑authentication mode, and returns `true`.  If the ping
+     * fails, it logs a warning, clears authorization, marks the instance
+     * as disconnected, and returns `false`.
+     *
+     * @return {Promise<boolean>} `true` when a connection is successfully
+     * established without authentication, otherwise `false`.
+     */
+    connectNoAuth(): Promise<boolean>;
+    /**
+     * Forces a connection using the provided bearer token.
+     *
+     * @param {string} token The token to be used for authentication.
+     * @returns {void}
+     */
+    forceConnectWithToken(token: string): void;
+    /**
+     * Establishes a connection to the backend using the supplied credentials.
+     * Performs a health‑check ping first; if successful, it requests an authentication
+     * token from the `/token` endpoint.  When the token is obtained, the method
+     * updates internal state (authorization header, connection flags) and, unless
+     * a dry run is requested, sets up a reconnection routine.  Any errors are
+     * logged and the method resolves to `false`.
+     *
+     * @param {string} email - The user's email address for authentication.
+     * @param {string} pw - The password (or token) for the specified user.
+     * @param {boolean} [dry=false] - If `true`, the method performs a dry run
+     *   without persisting credentials or configuring reconnection logic.
+     *
+     * @returns  Promise<boolean>  `true` if the connection was successfully
+     *   established, otherwise `false`.
+     */
+    connect(email: string, pw: string, dry?: boolean): Promise<boolean>;
+    /**
+     * Performs an HTTP request using the client’s internal connection.
+     *
+     * The method verifies that the client is connected before attempting a request.
+     * It automatically injects the authorization token, permanent headers, and any
+     * headers supplied in `config`. If the request body is a `FormData` instance
+     * (or provides a `getHeaders` method), the appropriate form headers are added.
+     *
+     * Response handling:
+     * - `200` or `201`: returns `success: true` with the received data.
+     * - `498`: attempts to reconnect and retries the request once.
+     * - `401`: logs an authentication error, marks the client as disconnected.
+     * - `403` and other status codes: return `success: false` with the status code.
+     *
+     * @param {'POST'|'GET'|'PATCH'|'DELETE'} type The HTTP method to use.
+     * @param {string} path The endpoint path relative to the base URL.
+     * @param {J} [body] Optional request payload. May be `FormData` or a plain object.
+     * @param {ConHandleConfig} [config] Optional Axios-like configuration for the request.
+     * @returns {Promise<HandleRes<T>>} A promise that resolves to a `HandleRes` object
+     * containing the response data, status code, any error information, and headers.
      */
-    fakeEnableClient(): void;
     handle<T, J>(type: 'POST' | 'GET' | 'PATCH' | 'DELETE', path: string, body?: J, config?: ConHandleConfig): Promise<HandleRes<T>>;
 }