@grandlinex/swagger-mate 1.2.2 → 1.3.2

package/dist/cjs/Swagger/debug/BaseCon.js

@@ -12,13 +12,20 @@ const form_data_1 = __importDefault(require("form-data"));
 function isErrorType(x) {
     return x && typeof x === 'object' && x.type === 'error';
 }
+/**
+ * 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
+ */
 class BaseCon {
     constructor(conf) {
         this.api = conf.endpoint;
-        this.logger = conf.logger || console.log;
+        this.logger = conf.logger ?? console.log;
         this.disconnected = true;
+        this.noAuth = false;
         this.authorization = null;
-        this.failFlag = false;
         this.con = conf.con;
         this.reconnect = async () => {
             this.disconnected = true;
@@ -27,10 +34,40 @@ class BaseCon {
         this.onReconnect = () => Promise.resolve(true);
         this.handle = this.handle.bind(this);
     }
-    // Class helper functions
+    /**
+     * Retrieves the API endpoint.
+     *
+     * @return {string} The API endpoint string.
+     */
+    getApiEndpoint() {
+        return this.api;
+    }
+    /**
+     * Sets the API endpoint URL used by the client.
+     *
+     * @param {string} endpoint - The full URL of the API endpoint.
+     * @returns {void}
+     */
+    setApiEndpoint(endpoint) {
+        this.api = endpoint;
+    }
+    /**
+     * 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() {
-        return this.authorization !== null && !this.disconnected;
+        return (this.noAuth || this.authorization !== null) && !this.disconnected;
     }
+    /**
+     * Returns the current authorization token.
+     *
+     * @return {string} The authorization token or an empty string if none is set.
+     */
     token() {
         return this.authorization || '';
     }
@@ -56,35 +93,34 @@ class BaseCon {
         }
         return `${this.api}${pp}`;
     }
+    /**
+     * 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.
+     */
     async ping() {
         try {
             const version = await this.con.get(this.p('/version'));
-            return version.data?.api === 1 && version.code === 200;
+            return version.data?.api !== undefined && version.code === 200;
         }
         catch (e) {
             this.logger('ping failed');
             return false;
         }
     }
-    async test(email, password) {
-        const ping = await this.ping();
-        if (ping) {
-            try {
-                this.logger({ email, password });
-                const con = await this.con.post(this.p('/token'), {
-                    username: email,
-                    token: password,
-                });
-                return con.code === 200 || con.code === 201;
-            }
-            catch (e) {
-                this.logger(e);
-                this.logger('cant connect to backend');
-            }
-        }
-        this.logger('test ping failed');
-        return false;
-    }
+    /**
+     * 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}.
+     */
     async testToken() {
         const ping = await this.ping();
         if (ping) {
@@ -104,7 +140,59 @@ class BaseCon {
         this.logger('test ping failed');
         return false;
     }
-    async connect(email, pw) {
+    /**
+     * 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`.
+     */
+    async connectNoAuth() {
+        const ping = await this.ping();
+        if (ping) {
+            this.authorization = null;
+            this.disconnected = false;
+            this.noAuth = true;
+            return true;
+        }
+        this.logger('cant connect to backend');
+        this.authorization = null;
+        this.disconnected = true;
+        return false;
+    }
+    /**
+     * Forces a connection using the provided bearer token.
+     *
+     * @param {string} token The token to be used for authentication.
+     * @returns {void}
+     */
+    forceConnectWithToken(token) {
+        this.authorization = `Bearer ${token}`;
+        this.disconnected = false;
+        this.noAuth = false;
+    }
+    /**
+     * 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`.
+     */
+    async connect(email, pw, dry = false) {
         const ping = await this.ping();
         if (ping) {
             try {
@@ -112,13 +200,15 @@ class BaseCon {
                     username: email,
                     token: pw,
                 });
-                // TODO check token
                 if (token.code === 200 || token.code === 201) {
-                    this.authorization = `Bearer ${token.data?.token}`;
-                    this.disconnected = false;
-                    this.reconnect = async () => {
-                        return (await this.connect(email, pw)) && (await this.testToken());
-                    };
+                    if (!dry) {
+                        this.authorization = `Bearer ${token.data?.token}`;
+                        this.disconnected = false;
+                        this.noAuth = false;
+                        this.reconnect = async () => {
+                            return ((await this.connect(email, pw)) && (await this.testToken()));
+                        };
+                    }
                     return true;
                 }
             }
@@ -129,17 +219,32 @@ class BaseCon {
         this.logger('cant connect to backend');
         this.authorization = null;
         this.disconnected = true;
+        this.noAuth = false;
         return false;
     }
     /**
-     * Enable client before auth
+     * 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() {
-        this.authorization = 'DEBUG';
-        this.disconnected = false;
-    }
     async handle(type, path, body, config) {
-        if (!this.authorization || this.disconnected) {
+        if (!this.isConnected()) {
             this.logger('Disconnected');
             return {
                 success: false,
@@ -246,7 +351,6 @@ class BaseCon {
                 };
             case 401:
                 this.logger('AUTH NOT VALID');
-                this.disconnected = true;
                 return {
                     success: false,
                     data: null,

package/dist/cjs/cli.js

@@ -76,7 +76,11 @@ async function run() {
             console.log('Serving Swagger Meta');
             const auth = process.env.SW_AUTH || undefined;
             const port = process.env.SW_PORT || undefined;
-            SwaggerUtil_js_1.default.serveMeta(conf, port ? parseInt(port, 10) : undefined, auth);
+            SwaggerUtil_js_1.default.serveMeta(conf, {
+                port: port ? parseInt(port, 10) : undefined,
+                auth,
+                type: 'rapi-doc',
+            });
         }
         if (arg[arg.length - 2] === '--build') {
             console.log('Building Swagger Meta');

package/dist/mjs/Swagger/Client/ClientUtil.d.ts

@@ -3,6 +3,7 @@ export type IfMappingKeyType = {
     key: string;
     type: string;
     required?: boolean;
+    nullable?: boolean;
 };
 export type IfMappingType = {
     name: string;
@@ -10,15 +11,28 @@ export type IfMappingType = {
     rawType?: string;
 };
 /**
- * Save string from unknown
- * @param e
+ * Returns a string representation of the given value. If the value is falsy,
+ * an empty string is returned.
+ *
+ * @param e - The value to convert to a string.
+ * @returns The string representation of `e`, or an empty string if `e` is falsy.
  */
 export declare function eS(e: any): string;
 /**
- * Optional field
- * @param required
+ * Returns a type annotation delimiter based on whether a value is required.
+ *
+ * @param {boolean} [required] - Indicates if the value is required. If omitted or false, the value is considered optional.
+ * @returns {string} A colon (`:`) for required values or a question mark followed by a colon (`?:`) for optional values.
  */
 export declare function rq(required?: boolean): string;
+/**
+ * Returns a type representation based on whether the value should be nullable.
+ *
+ * @param {string} type - The base type name to return when the value is not nullable.
+ * @param {boolean} nullable - Indicates if the type should be considered nullable. If `true`, the function returns a colon (`:`); if `false`, it returns the original type string.
+ * @return {string} The original type string when `nullable` is `false`, otherwise a colon (`:`) to represent a nullable type in the consuming context.
+ */
+export declare function rN(type: string, nullable?: boolean): string;
 export declare function sK(e: string): string;
 /**
  * Cast first letter to uppercase

package/dist/mjs/Swagger/Client/ClientUtil.js

@@ -1,14 +1,19 @@
 import { isSwaggerRef } from '../Meta/SwaggerTypes.js';
 /**
- * Save string from unknown
- * @param e
+ * Returns a string representation of the given value. If the value is falsy,
+ * an empty string is returned.
+ *
+ * @param e - The value to convert to a string.
+ * @returns The string representation of `e`, or an empty string if `e` is falsy.
  */
 export function eS(e) {
     return e || '';
 }
 /**
- * Optional field
- * @param required
+ * Returns a type annotation delimiter based on whether a value is required.
+ *
+ * @param {boolean} [required] - Indicates if the value is required. If omitted or false, the value is considered optional.
+ * @returns {string} A colon (`:`) for required values or a question mark followed by a colon (`?:`) for optional values.
  */
 export function rq(required) {
     if (!required) {
@@ -16,6 +21,19 @@ export function rq(required) {
     }
     return ':';
 }
+/**
+ * Returns a type representation based on whether the value should be nullable.
+ *
+ * @param {string} type - The base type name to return when the value is not nullable.
+ * @param {boolean} nullable - Indicates if the type should be considered nullable. If `true`, the function returns a colon (`:`); if `false`, it returns the original type string.
+ * @return {string} The original type string when `nullable` is `false`, otherwise a colon (`:`) to represent a nullable type in the consuming context.
+ */
+export function rN(type, nullable) {
+    if (nullable) {
+        return `${type} | null`;
+    }
+    return type;
+}
 export function sK(e) {
     if (e.indexOf(':') >= 0) {
         return `'${e}'`;
@@ -85,20 +103,41 @@ export function transformInterface(operation, tag, schema) {
                         const prop = schema.properties[key];
                         const isRequired = schema.required && schema.required.includes(key);
                         if (!isSwaggerRef(prop)) {
+                            const nullable = prop.nullable ?? false;
                             switch (prop.type) {
                                 case 'number':
                                 case 'integer':
-                                    cur.keys.push({ key, type: 'number', required: isRequired });
+                                    cur.keys.push({
+                                        key,
+                                        type: 'number',
+                                        required: isRequired,
+                                        nullable,
+                                    });
                                     break;
                                 case 'string':
-                                    cur.keys.push({ key, type: 'string', required: isRequired });
+                                    cur.keys.push({
+                                        key,
+                                        type: 'string',
+                                        required: isRequired,
+                                        nullable,
+                                    });
                                     break;
                                 case 'boolean':
-                                    cur.keys.push({ key, type: 'boolean', required: isRequired });
+                                    cur.keys.push({
+                                        key,
+                                        type: 'boolean',
+                                        required: isRequired,
+                                        nullable,
+                                    });
                                     break;
                                 case 'object':
                                     if (!prop.properties) {
-                                        cur.keys.push({ key, type: 'any', required: isRequired });
+                                        cur.keys.push({
+                                            key,
+                                            type: 'any',
+                                            required: isRequired,
+                                            nullable,
+                                        });
                                     }
                                     else {
                                         cur.keys.push({
@@ -115,6 +154,7 @@ export function transformInterface(operation, tag, schema) {
                                             key,
                                             type: `${typeByRef(prop.items.$ref)}[]`,
                                             required: isRequired,
+                                            nullable,
                                         });
                                     }
                                     else {
@@ -122,6 +162,7 @@ export function transformInterface(operation, tag, schema) {
                                             key,
                                             type: `${ifName(cur.name, `${key}Element`)}[]`,
                                             required: isRequired,
+                                            nullable,
                                         });
                                         out.push(...transformInterface(cur.name, key, prop));
                                     }
@@ -134,6 +175,7 @@ export function transformInterface(operation, tag, schema) {
                                 key,
                                 type: typeByRef(prop.$ref),
                                 required: isRequired,
+                                nullable: schema.nullable ?? false,
                             });
                         }
                     }

package/dist/mjs/Swagger/Client/InterfaceTemplate.js

@@ -1,11 +1,11 @@
 /* eslint-disable prettier/prettier */
-import { rq, S, sK } from './ClientUtil.js';
+import { rq, S, sK, rN } from './ClientUtil.js';
 function interfaceTemplate(IF_NAME, types, rawType) {
     if (rawType) {
         return `export type ${IF_NAME} = ${rawType};`;
     }
     return `export interface ${IF_NAME} {
-${types.map(({ key, type, required }) => `${S(2)}${sK(key)}${rq(required)} ${type};`).join('\n')}
+${types.map(({ key, type, required, nullable }) => `${S(2)}${sK(key)}${rq(required)} ${rN(type, nullable)};`).join('\n')}
 }`;
 }
 export { 

package/dist/mjs/Swagger/Client/SwaggerClient.js

@@ -143,13 +143,13 @@ function createPackage(name, version, module) {
         types: 'dist/index.d.ts',
         module: module ? 'dist/index.js' : undefined,
         type: module ? 'module' : undefined,
-        dependencies: {
-            'form-data': '4.0.4',
-            axios: '1.11.0',
-        },
         devDependencies: {
             '@types/node': '22.15.32',
-            typescript: '5.8.3',
+            typescript: '5.9.2',
+        },
+        peerDependencies: {
+            axios: '>=1.13.2',
+            'form-data': '>=4.0.5',
         },
         scripts: {
             build: 'tsc',

package/dist/mjs/Swagger/Meta/SwaggerTypes.d.ts

@@ -67,6 +67,7 @@ export type SSchemaEl = {
     items?: SSchemaEl;
     required?: string[];
     enum?: string[];
+    nullable?: boolean;
 } | SwaggerRRef;
 export type SwaggerContent = {
     [K in SMediaType]?: {

package/dist/mjs/Swagger/Path/SPathUtil.d.ts

@@ -2,15 +2,104 @@ import { CoreEntity } from '@grandlinex/core';
 import { HttpStatusTypes } from '../Meta/SwaggerTypesStatic.js';
 import { SKey, SSchemaEl, SwaggerContent, SwaggerRPathConfResponse, SwaggerRPathReqBody } from '../Meta/SwaggerTypes.js';
 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: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    /**
+     * 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: SSchemaEl): SwaggerRPathReqBody;
+    /**
+     * 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?: SSchemaEl): SwaggerRPathReqBody;
+    /**
+     * 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<T extends CoreEntity>(entity: T, list?: boolean): SwaggerContent | undefined;
+    /**
+     * @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<T extends CoreEntity>(entity: T, list?: boolean, create?: boolean): SwaggerRPathConfResponse;
+    /**
+     * 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: string): string;
+    /**
+     * 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: string | CoreEntity, list: boolean): SwaggerRPathReqBody;
+    /**
+     * Creates a Swagger response configuration for a given HTTP status code.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for */
     static refResponse(code: HttpStatusTypes, $ref: string | CoreEntity, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    /**
+     * 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: HttpStatusTypes, schema: SSchemaEl, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    /**
+     * 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<T extends CoreEntity>(entity: T): SSchemaEl | undefined;
+    /**
+     * 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<T extends CoreEntity>(entity: T): {
         description: string;
         content: {
@@ -20,9 +109,91 @@ export default class SPathUtil {
         };
     } | undefined;
     /**
-     * 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: CoreEntity[]): SKey<SSchemaEl>;
+    /**
+     * 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<A extends CoreEntity, B extends CoreEntity>(entity: A, entityMap: B): SSchemaEl;
+    /**
+     * 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: CoreEntity, ...options: {
+        key: string;
+        list?: boolean;
+        entity?: CoreEntity;
+        schema?: SSchemaEl;
+        required?: boolean;
+    }[]): SSchemaEl;
+    /**
+     * 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: CoreEntity, ...options: {
+        key: string;
+        list?: boolean;
+        entity?: CoreEntity;
+        schema?: SSchemaEl;
+        required?: boolean;
+    }[]): SKey<SSchemaEl>;
+    /**
+     * 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<T extends CoreEntity>(entity: T, ...keys: (keyof T)[]): SSchemaEl;
+    /**
+     * 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<T extends CoreEntity>(entity: T, ...keys: (keyof T)[]): SKey<SSchemaEl>;
 }