registerPublicEvents() {
    /**
     * Deletes on or multiple keys
     * @param  {string|Array.<string>} keys
     */
    global.kuzzle.onAsk("core:cache:public:del", (keys) =>
      this.public.commands.del(keys),
    );

    /**
     * Executes an arbitrary NATIVE cache command directly
     * @param {string} command
     * @param {Array} args -- command arguments
     */
    global.kuzzle.onAsk("core:cache:public:execute", (command, ...args) =>
      this.public.exec(command, ...args),
    );

    /**
     * Asks a key to expire in the provided delay
     * @param {string} key
     * @param {number} ttl (in seconds)
     */
    global.kuzzle.onAsk("core:cache:public:expire", (key, ttl) =>
      this.public.commands.expire(key, ttl),
    );

    /**
     * Wipes the database clean
     */
    global.kuzzle.onAsk("core:cache:public:flushdb", () =>
      this.public.commands.flushdb(),
    );

    /**
     * Returns basic information about the internal cache service
     * @returns {Promise.<Object>}
     */
    global.kuzzle.onAsk("core:cache:public:info:get", () => this.public.info());

    /**
     * Fetches a single value
     * @param {string} key
     * @return {string}
     */
    global.kuzzle.onAsk("core:cache:public:get", (key) =>
      this.public.commands.get(key),
    );

    /**
     * Executes multiple cache commands in one go, as a single transaction
     * @param {Array} commands to execute
     */
    global.kuzzle.onAsk("core:cache:public:mExecute", (commands) =>
      this.public.mExecute(commands),
    );

    /**
     * Makes a key persistent (disable its expiration delay, if there is one)
     * @param {string} key
     */
    global.kuzzle.onAsk("core:cache:public:persist", (key) =>
      this.public.commands.persist(key),
    );

    /**
     * Convenience method for easy access to options NX and PX of the "set"
     * command.
     * Deliberately not named after an existing Redis command to prevent
     * confusion with Redis' API.
     *
     * Options:
     *   - ttl: key expiration TTL in milliseconds
     *   - onlyIfNew: if true, does not write the key if it already exists
     *
     * @param {string} key
     * @param {string} value
     * @param {{ttl: number, onlyIfNew: boolean}} [opts]
     * @returns {Promise.<boolean>} true if the key was set, false otherwise
     */
    global.kuzzle.onAsk("core:cache:public:store", (key, value, opts) =>
      this.public.store(key, value, opts),
    );
  }
Executes an arbitrary NATIVE cache command directly
@param {string} command
@param {Array} args -- command arguments