kuzzle 2.60.0-beta.3 → 2.60.0-beta.5

package/dist/lib/api/controllers/adminController.d.ts

@@ -44,7 +44,13 @@ declare class AdminController extends NativeController {
     shutdown(): Promise<{
         acknowledge: boolean;
     }>;
-    loadFixtures(request: KuzzleRequest): Promise<any>;
+    /**
+     * Always waits for the import, so that a failure is reported to the caller:
+     * `refresh=false` only skips waiting for the documents to be indexed.
+     */
+    loadFixtures(request: KuzzleRequest): Promise<{
+        acknowledge: boolean;
+    }>;
     loadMappings(request: KuzzleRequest): Promise<{
         acknowledge: boolean;
     }>;

package/dist/lib/api/controllers/adminController.js

@@ -161,15 +161,22 @@ class AdminController extends baseController_1.NativeController {
         if (this.shuttingDown) {
             throw kerror.get("api", "process", "action_locked", "Kuzzle is already shutting down.");
         }
+        this.shuttingDown = true;
         global.kuzzle.shutdown();
         return { acknowledge: true };
     }
-    loadFixtures(request) {
+    /**
+     * Always waits for the import, so that a failure is reported to the caller:
+     * `refresh=false` only skips waiting for the documents to be indexed.
+     */
+    async loadFixtures(request) {
         const fixtures = request.getBody();
         const refresh = request.getRefresh("wait_for");
-        return global.kuzzle.ask("core:storage:public:document:import", fixtures, {
+        await global.kuzzle.ask("core:storage:public:document:import", fixtures, {
             refresh,
         });
+        // The documented answer. 2.17.6 to 2.59 answered `null` instead.
+        return { acknowledge: true };
     }
     loadMappings(request) {
         const mappings = request.getBody();

package/dist/lib/api/controllers/documentController.d.ts

@@ -77,7 +77,7 @@ declare class DocumentController extends NativeController {
         errors: any;
         successes: any;
     }>;
-    export(request: KuzzleRequest): Promise<import("../../..").HttpStream>;
+    export(request: KuzzleRequest): Promise<import("../../types").HttpStream>;
     /**
      * @param {Request} request
      * @returns {Promise<Object>}

package/dist/lib/api/funnel.js

@@ -664,13 +664,24 @@ class Funnel {
             catch (e) {
                 error = e;
                 debug("Error processing request %s: %a", request.id, error);
+                // processRequest does not dump: do it as the event-less path does.
+                // Rethrown, never falling through to the event-less execution below,
+                // which ran a failed (or pipe-rejected) request a second time.
+                this.handleErrorDump((0, thrown_1.causeOf)(e));
+                throw e;
             }
             finally {
-                global.kuzzle.pipe("request:afterExecution", {
+                // Not awaited, as it always was: the caller's result does not depend
+                // on it. Its rejection is logged instead of left unhandled.
+                global.kuzzle
+                    .pipe("request:afterExecution", {
                     error: error,
                     request: request,
                     result: res,
                     success: error === undefined,
+                })
+                    ?.catch((pipeError) => {
+                    this.logger.error(pipeError, `request:afterExecution pipe failed for plugin request ${request.id}`);
                 });
             }
         }

package/dist/lib/api/httpRoutes.js

@@ -184,12 +184,6 @@ const routes = [
         controller: "admin",
         action: "resetDatabase",
     },
-    {
-        verb: "post",
-        path: "/admin/_resetKuzzleData",
-        controller: "admin",
-        action: "resetKuzzleData",
-    },
     { verb: "post", path: "/admin/_dump", controller: "admin", action: "dump" },
     {
         verb: "post",
@@ -251,12 +245,6 @@ const routes = [
         controller: "index",
         action: "exists",
     },
-    {
-        verb: "get",
-        path: "/:index/_autoRefresh",
-        controller: "index",
-        action: "getAutoRefresh",
-    },
     { verb: "get", path: "/_list", controller: "index", action: "list" },
     { verb: "get", path: "/_storageStats", controller: "index", action: "stats" },
     {
@@ -1133,13 +1121,6 @@ const routes = [
         controller: "ms",
         action: "append",
     },
-    {
-        verb: "post",
-        path: "/ms/_bgrewriteaof",
-        controller: "ms",
-        action: "bgrewriteaof",
-    },
-    { verb: "post", path: "/ms/_bgsave", controller: "ms", action: "bgsave" },
     { verb: "post", path: "/ms/_bitop/:_id", controller: "ms", action: "bitop" },
     { verb: "post", path: "/ms/_decr/:_id", controller: "ms", action: "decr" },
     {
@@ -1514,7 +1495,7 @@ const routes = [
         controller: "security",
         action: "deleteApiKey",
         openapi: {
-            description: "Deletes a user API key, identified by its clear-text `key` or its `fingerprint` instead of its `_id`. Exactly one of `key` or `fingerprint` must be provided. If you are looking to manage your own API keys, use the `auth` controller instead.",
+            description: "Deletes a user API key, identified by its clear-text `key` or its `fingerprint` instead of its `_id`. One of them must be provided; if several are given, `_id` is used first, then `key`, then `fingerprint`, and the others are ignored. A `key` in the query string is a secret written in the URL: prefer the `fingerprint`. If you are looking to manage your own API keys, use the `auth` controller instead.",
             parameters: [
                 {
                     in: "path",
@@ -1572,6 +1553,57 @@ const routes = [
         controller: "auth",
         action: "deleteApiKey",
     },
+    {
+        verb: "delete",
+        path: "/api-keys",
+        controller: "auth",
+        action: "deleteApiKey",
+        openapi: {
+            description: "Deletes an API key of the current user, identified by its clear-text `key` or its `fingerprint` instead of its `_id`. One of them must be provided; if several are given, `_id` is used first, then `key`, then `fingerprint`, and the others are ignored. A `key` in the query string is a secret written in the URL: prefer the `fingerprint`.",
+            parameters: [
+                {
+                    in: "query",
+                    name: "key",
+                    schema: { type: "string" },
+                    required: false,
+                    description: "Clear-text API key to delete",
+                },
+                {
+                    in: "query",
+                    name: "fingerprint",
+                    schema: { type: "string" },
+                    required: false,
+                    description: "SHA256 fingerprint of the API key to delete",
+                },
+                {
+                    in: "query",
+                    name: "refresh",
+                    schema: {
+                        type: "string",
+                        enum: ["wait_for", "false"],
+                        default: "wait_for",
+                    },
+                    required: false,
+                    description: "If set to `wait_for`, waits for the deletion to be indexed before responding",
+                },
+            ],
+            responses: {
+                200: {
+                    description: "The deleted API key ID",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    _id: { type: "string" },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
     // PUT (idempotent)
     { verb: "put", path: "/_me", controller: "auth", action: "updateSelf" },
     {

package/dist/lib/api/request/kuzzleRequest.d.ts

@@ -385,12 +385,17 @@ export declare class KuzzleRequest {
      */
     getDate(name: string, format?: string): string;
     /**
-     * Gets a parameter from a request arguments and returns it to timestamp format.
+     * Gets a parameter from a request arguments and checks that it is an integer
+     * timestamp (e.g. milliseconds since Epoch).
+     *
+     * An integer string, such as an HTTP query string value, is accepted and
+     * converted. A date string (e.g. `"2026-10-27"`) is rejected.
      *
      * @param name parameter name.
      * @throws {api.assert.missing_argument} If parameter not found and no default
      *                                       value provided
-     * @throws {api.assert.invalid_type} If parameter value is not a valid date.
+     * @throws {api.assert.invalid_type} If parameter value is not an integer
+     *                                   timestamp.
      */
     getTimestamp(name: string): number;
     /**

package/dist/lib/api/request/kuzzleRequest.js

@@ -676,31 +676,41 @@ class KuzzleRequest {
         if (args[name] === undefined) {
             throw assertionError.get("missing_argument", name);
         }
-        if (format && !(0, moment_1.default)(args[name], format, true).isValid()) {
-            throw assertionError.get("invalid_type", name, "date");
-        }
-        if (!(0, moment_1.default)(args[name], moment_1.default.ISO_8601).isValid()) {
+        // A custom format replaces the ISO 8601 check: applying both rejected
+        // every value of a format that is not ISO 8601.
+        const isValid = format
+            ? (0, moment_1.default)(args[name], format, true).isValid()
+            : (0, moment_1.default)(args[name], moment_1.default.ISO_8601).isValid();
+        if (!isValid) {
             throw assertionError.get("invalid_type", name, "date");
         }
         return this.getString(name);
     }
     /**
-     * Gets a parameter from a request arguments and returns it to timestamp format.
+     * Gets a parameter from a request arguments and checks that it is an integer
+     * timestamp (e.g. milliseconds since Epoch).
+     *
+     * An integer string, such as an HTTP query string value, is accepted and
+     * converted. A date string (e.g. `"2026-10-27"`) is rejected.
      *
      * @param name parameter name.
      * @throws {api.assert.missing_argument} If parameter not found and no default
      *                                       value provided
-     * @throws {api.assert.invalid_type} If parameter value is not a valid date.
+     * @throws {api.assert.invalid_type} If parameter value is not an integer
+     *                                   timestamp.
      */
     getTimestamp(name) {
-        const args = this.input.args;
-        if (args[name] === undefined) {
+        const value = this.input.args[name];
+        if (value === undefined) {
             throw assertionError.get("missing_argument", name);
         }
-        if ((0, moment_1.default)(args[name], true).isValid() === false) {
+        const timestamp = typeof value === "string" && /^-?\d+$/.test(value)
+            ? Number(value)
+            : value;
+        if (!Number.isSafeInteger(timestamp)) {
             throw assertionError.get("invalid_type", name, "date");
         }
-        return this.getInteger(name);
+        return timestamp;
     }
     /**
      * Returns the index specified in the request

package/dist/lib/api/request/requestContext.d.ts

@@ -19,7 +19,7 @@ export type ContextMisc = {
      */
     path?: string;
     /**
-     * HTTP headers
+     * HTTP method, uppercase (e.g. `GET`)
      */
     verb?: string;
     /**

package/dist/lib/api/request/requestResponse.js

@@ -127,7 +127,8 @@ class Headers {
             case "host":
             case "if-modified-since":
             case "if-unmodified-since":
-            case "last-modified, location":
+            case "last-modified":
+            case "location":
             case "max-forwards":
             case "proxy-authorization":
             case "referer":

package/dist/lib/cluster/command.d.ts

@@ -21,6 +21,8 @@ type CommandingNode = {
     };
     ip: string;
     nodeId: string;
+    /** Whether `nodeId` can be read: false until the handshake sets it. */
+    hasNodeId: boolean;
     activity: Activity[];
     /** Only `serialize()`: the command layer never mutates the state. */
     fullState: {
@@ -102,6 +104,11 @@ declare class ClusterCommand {
      * This method can (and should) never return a rejected promise.
      */
     listen(): Promise<void>;
+    /**
+     * Answers one request. Every request gets exactly one reply: REP/REQ
+     * requires it, and a request left unanswered wedges the peer's socket.
+     */
+    private answer;
     /**
      * Closes opened sockets and marks this server as closed.
      */

package/dist/lib/cluster/command.js

@@ -159,32 +159,9 @@ class ClusterCommand {
         while (this.state === stateEnum.RUNNING) {
             try {
                 const [type, data] = await this.server.receive();
-                // A REQ frame carries a topic and, for a handshake, a payload. A
-                // request missing either is answered with DISCARDED, which is what
-                // this socket owes every REQ — the two frames were read unchecked.
-                switch (type?.toString()) {
-                    case commandMessages_1.commandTopic.FULLSTATE:
-                        await this.sendFullState();
-                        break;
-                    case commandMessages_1.commandTopic.HANDSHAKE:
-                        if (data === undefined) {
-                            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
-                            break;
-                        }
-                        await this.handleHandshake(data);
-                        break;
-                    case commandMessages_1.commandTopic.RETRANSMIT:
-                        if (data === undefined) {
-                            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
-                            break;
-                        }
-                        await this.handleRetransmit(data);
-                        break;
-                    default:
-                        // REP/REQ sockets expect a reply to each request made, so we have
-                        // to send some kind of response on an invalid request received
-                        await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
-                }
+                // NOSONAR (S9382): a REP socket strictly alternates receive and send,
+                // so a request must be answered before the next one can be read.
+                await this.answer(type, data); // NOSONAR
             }
             catch (e) {
                 if (this.state !== stateEnum.CLOSED) {
@@ -193,6 +170,47 @@ class ClusterCommand {
             }
         }
     }
+    /**
+     * Answers one request. Every request gets exactly one reply: REP/REQ
+     * requires it, and a request left unanswered wedges the peer's socket.
+     */
+    async answer(type, data) {
+        // The socket is bound before the handshake sets this node's id, and a
+        // peer still talking to a dead node on this IP can reach it (#3031). A
+        // node with no id yet has no state to serve and cannot take a peer in:
+        // every request is answered DISCARDED, which the requester treats as no
+        // answer.
+        if (!this.node.hasNodeId) {
+            await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+            return;
+        }
+        // A REQ frame carries a topic and, for a handshake, a payload. A request
+        // missing either is answered with DISCARDED, which is what this socket
+        // owes every REQ — the two frames were read unchecked.
+        switch (type?.toString()) {
+            case commandMessages_1.commandTopic.FULLSTATE:
+                await this.sendFullState();
+                break;
+            case commandMessages_1.commandTopic.HANDSHAKE:
+                if (data === undefined) {
+                    await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+                    break;
+                }
+                await this.handleHandshake(data);
+                break;
+            case commandMessages_1.commandTopic.RETRANSMIT:
+                if (data === undefined) {
+                    await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+                    break;
+                }
+                await this.handleRetransmit(data);
+                break;
+            default:
+                // REP/REQ sockets expect a reply to each request made, so we have
+                // to send some kind of response on an invalid request received
+                await this.server.send([commandMessages_1.commandTopic.DISCARDED, null]);
+        }
+    }
     /**
      * Closes opened sockets and marks this server as closed.
      */
@@ -339,7 +357,19 @@ class ClusterCommand {
             // No payload message for a full state request
             await req.send([commandMessages_1.commandTopic.FULLSTATE, null]);
             try {
-                [, fullState = null] = await req.receive();
+                // NOSONAR (S9382): one node at a time by design, the loop stops at
+                // the first one that serves a full state.
+                const [topic, payload] = await req.receive(); // NOSONAR
+                // DISCARDED carries an empty frame, which would decode as an empty
+                // full state: a node that cannot serve one (#3031) is skipped like
+                // one that does not answer.
+                if (topic?.toString() === commandMessages_1.commandTopic.FULLSTATE && payload) {
+                    fullState = payload;
+                }
+                else {
+                    this.logger.warn(`Unable to fetch a full state from node ${id} (request discarded)`);
+                    idx = (idx + 1) % nodes.length;
+                }
             }
             catch {
                 // no response from the remote node in a timely fashion... retrying
@@ -403,7 +433,16 @@ class ClusterCommand {
         await req.send([commandMessages_1.commandTopic.HANDSHAKE, payload]);
         let response = null;
         try {
-            [, response = null] = await req.receive();
+            const [topic, answer] = await req.receive();
+            // DISCARDED carries an empty frame, which would decode as a handshake
+            // answer with nothing in it: a node that refused the handshake (#3031)
+            // is one that did not answer.
+            if (topic?.toString() === commandMessages_1.commandTopic.HANDSHAKE && answer) {
+                response = answer;
+            }
+            else {
+                this.logger.warn(`Couldn't complete handshake with node ${id}: request discarded`);
+            }
         }
         catch {
             this.logger.warn(`Couldn't complete handshake with node ${id}: no response received`);

package/dist/lib/cluster/node.d.ts

@@ -41,10 +41,21 @@ declare class ClusterNode {
      * The id of the ID card this node reserved during `handshake()`.
      *
      * Null until the handshake gets that far, and read as a `string` at
-     * seventeen sites here plus `subscriber.ts` and `command.ts` — all of which
-     * run after it. The accessor says once where that can fail.
+     * seventeen sites here plus `subscriber.ts` and `command.ts`. The accessor
+     * says once where that can fail: an internal read before the handshake is a
+     * bug, and it throws.
+     *
+     * Network input is not internal: the command socket is bound before the
+     * handshake, and a node restarted on the IP of a dead one can be reached by
+     * peers still talking to that dead node (#3031). The paths network input
+     * reaches check `hasNodeId` first.
      */
     get nodeId(): string;
+    /**
+     * Whether the handshake has set this node's id yet: the non-throwing check
+     * for the paths network input reaches before it has (#3031).
+     */
+    get hasNodeId(): boolean;
     set nodeId(id: string);
     private heartbeatTimer;
     readonly idCardHandler: ClusterIdCardHandler;

package/dist/lib/cluster/node.js

@@ -200,8 +200,14 @@ class ClusterNode {
      * The id of the ID card this node reserved during `handshake()`.
      *
      * Null until the handshake gets that far, and read as a `string` at
-     * seventeen sites here plus `subscriber.ts` and `command.ts` — all of which
-     * run after it. The accessor says once where that can fail.
+     * seventeen sites here plus `subscriber.ts` and `command.ts`. The accessor
+     * says once where that can fail: an internal read before the handshake is a
+     * bug, and it throws.
+     *
+     * Network input is not internal: the command socket is bound before the
+     * handshake, and a node restarted on the IP of a dead one can be reached by
+     * peers still talking to that dead node (#3031). The paths network input
+     * reaches check `hasNodeId` first.
      */
     get nodeId() {
         if (this._nodeId === null) {
@@ -209,6 +215,13 @@ class ClusterNode {
         }
         return this._nodeId;
     }
+    /**
+     * Whether the handshake has set this node's id yet: the non-throwing check
+     * for the paths network input reaches before it has (#3031).
+     */
+    get hasNodeId() {
+        return this._nodeId !== null;
+    }
     set nodeId(id) {
         this._nodeId = id;
     }
@@ -389,8 +402,11 @@ class ClusterNode {
         this.remoteNodes.delete(nodeId);
         this.fullState.removeNode(nodeId);
         subscriber.dispose();
-        if (broadcast) {
-            this.publisher.sendNodeEvicted(this.nodeId, nodeId, reason);
+        // A subscriber can evict its remote node (heartbeat lost, gap, invalid
+        // message) before this node's handshake: there is no evictor id to
+        // broadcast then, and the eviction stays local (#3031).
+        if (broadcast && this._nodeId !== null) {
+            this.publisher.sendNodeEvicted(this._nodeId, nodeId, reason);
         }
         if (this.countActiveNodes() < this.config.minimumNodes) {
             global.kuzzle.state = kuzzleStateEnum_1.default.NOT_ENOUGH_NODES;

package/dist/lib/cluster/subscriber.d.ts

@@ -15,6 +15,8 @@ type SubscribingNode = {
     config: IKuzzleConfiguration["cluster"];
     heartbeatDelay: number;
     nodeId: string;
+    /** Whether `nodeId` can be read: false until the handshake sets it. */
+    hasNodeId: boolean;
     fullState: State;
     eventEmitter: {
         emit(event: string, payload: unknown): void;

package/dist/lib/cluster/subscriber.js

@@ -383,6 +383,12 @@ class ClusterSubscriber {
      * @param message - decoded NodeEvicted protobuf message
      */
     async handleNodeEviction(message) {
+        // Before the handshake this node has no id to compare, and is not part of
+        // the cluster the eviction is about: the message is ignored (#3031).
+        if (!this.localNode.hasNodeId) {
+            debug("[CLUSTER] Eviction of node %s by %s ignored: the handshake has not run", message.nodeId, message.evictor);
+            return;
+        }
         if (message.nodeId === this.localNode.nodeId) {
             this.logger.error(`[CLUSTER] Node evicted by ${message.evictor}. Reason: ${message.reason}`);
             // A failure, like `evictSelf`'s: exit non-zero (#2785).

package/dist/lib/config/index.js

@@ -28,21 +28,27 @@ const assert_1 = __importDefault(require("assert"));
 const node_util_1 = require("node:util");
 const rc_1 = __importDefault(require("rc"));
 const default_config_1 = __importDefault(require("./default.config"));
+const authTokenSettings_1 = require("../core/security/authTokenSettings");
 const package_json_1 = __importDefault(require("../../package.json"));
 const kerror_1 = require("../kerror");
 const safeObject_1 = require("../util/safeObject");
 const bytes_1 = __importDefault(require("../util/bytes"));
 const wrapped = (0, kerror_1.wrap)("core", "configuration");
 function loadConfig() {
-    let loaded;
+    let raw;
     try {
-        loaded = (0, rc_1.default)("kuzzle", default_config_1.default);
+        raw = (0, rc_1.default)("kuzzle", withoutTokenDefaults(default_config_1.default));
     }
     catch (e) {
         throw wrapped.get("cannot_parse", e instanceof Error ? e.message : (0, node_util_1.inspect)(e));
     }
     // In place: what `unstringify` answers is the object it was given.
-    unstringify(loaded);
+    unstringify(raw);
+    const { authToken, deprecatedSettings, jwt } = resolveTokenSettings(raw.security);
+    const loaded = {
+        ...raw,
+        security: { ...raw.security, authToken, jwt },
+    };
     checkLimitsConfig(loaded);
     checkHttpOptions(loaded);
     checkWebSocketOptions(loaded);
@@ -56,6 +62,7 @@ function loadConfig() {
             hash: {
                 seed: Buffer.from("^m&mOISKBvb1xpl1mRsrylaQXpjb&IJX"),
             },
+            deprecatedSettings,
             notifiableProtocols: [],
         },
         version: package_json_1.default.version,
@@ -66,6 +73,56 @@ function loadConfig() {
     preprocessRedisOptions(config.services.memoryStorage);
     return config;
 }
+/**
+ * The packaged defaults, minus the values of `security.authToken` and of its
+ * deprecated spelling `security.jwt`: both sections ship the same non-null
+ * defaults, so once `rc` has merged them nothing tells a user's
+ * `jwt.expiresIn` from the packaged one. Left empty here, they hold only what
+ * the user set, and {@link resolveTokenSettings} applies the defaults after.
+ *
+ * A shallow copy: the other sections stay the packaged objects `rc` merges
+ * into, as before.
+ */
+function withoutTokenDefaults(defaults) {
+    const authToken = {};
+    const jwt = {};
+    return { ...defaults, security: { ...defaults.security, authToken, jwt } };
+}
+/**
+ * Resolves the authentication token settings: for each one, the value set
+ * under `security.authToken` wins, then the one set under the deprecated
+ * `security.jwt`, then the packaged default. A `null` counts as unset, as the
+ * readers' `authToken.x ?? jwt.x` always did. Exception: `gracePeriod` set in
+ * both sections keeps the `jwt` one, as it always did (see
+ * {@link LEGACY_FIRST}).
+ *
+ * Both sections get the resolved values, so a reader of either — a plugin
+ * may still read `jwt` — sees the settings in effect. `deprecatedSettings`
+ * lists the `security.jwt.*` keys the user set, for the deprecation warning.
+ */
+function resolveTokenSettings(security) {
+    const packaged = default_config_1.default.security.authToken;
+    const fromPackage = packaged;
+    const fromAuthToken = (0, safeObject_1.isPlainObject)(security.authToken)
+        ? security.authToken
+        : {};
+    const fromJwt = (0, safeObject_1.isPlainObject)(security.jwt) ? security.jwt : {};
+    const resolved = {};
+    for (const key of new Set([
+        ...Object.keys(packaged),
+        ...Object.keys(fromJwt),
+        ...Object.keys(fromAuthToken),
+    ])) {
+        resolved[key] = authTokenSettings_1.LEGACY_FIRST.has(key)
+            ? (fromJwt[key] ?? fromAuthToken[key] ?? fromPackage[key])
+            : (fromAuthToken[key] ?? fromJwt[key] ?? fromPackage[key]);
+    }
+    return {
+        authToken: { ...packaged, ...resolved },
+        deprecatedSettings: Object.keys(fromJwt).map((key) => `security.jwt.${key}`),
+        jwt: { ...resolved },
+    };
+}
 /**
  * RC params can be overriden using environment variables,
  * in which case all values are passed as strings.

package/dist/lib/core/backend/backend.d.ts

@@ -1,6 +1,6 @@
 import type { JSONObject } from "../../types/JSONObject";
 import { EmbeddedSDK } from "../shared/sdk/embeddedSdk";
-import type { EventDefinition } from "../../../index";
+import type { EventDefinition } from "../../types/EventHandler";
 import { BackendCluster, BackendConfig, BackendController, BackendHook, BackendImport, BackendPipe, BackendPlugin, BackendStorage, BackendVault, BackendOpenApi, BackendErrors, BackendSubscription } from "./index";
 import { Logger } from "../../kuzzle/Logger";
 import Plugin from "../plugin/plugin";
@@ -99,13 +99,14 @@ export declare class Backend {
      */
     plugin: BackendPlugin;
     /**
-     * InternalLogger
+     * Application logger
      *
+     * @method trace
      * @method debug
      * @method info
      * @method warn
      * @method error
-     * @method verbose
+     * @method fatal
      */
     log: Logger;
     /**