kuzzle 2.56.0 → 2.57.0-beta.2

package/dist/lib/types/config/internalCache/InternalCacheRedisConfiguration.d.ts

@@ -1,111 +1,7 @@
-export type InternalCacheConfiguration = {
-    /**
-     * The cache service relies on Redis sample settings for Redis service (see also https://github.com/luin/ioredis)
-     *
-     * 1. using a single Redis database:
-     *  * node:
-     *    * host:
-     *        The host on which Redis can be reached.
-     *        Can take an IP address, an URI or a hostname
-     *    * port:
-     *        The port on which Redis is running its database:
-     *          * (optional, deprecated) database:
-     *        ID of the redis database (default: 0)
-     *        NOTE: this option is deprecated and will be removed in Kuzzle v3.
-     *        Use 'options.db' instead. If both options are set, then
-     *        "options.db" will take precedence.
-     *  * (optional) options:
-     *    Redis specific options compatible with IORedis.
-     *    See Redis client constructor available options:
-     *    https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
-     *
-     * 2. using a master/slaves Redis instance with Redis sentinels
-     *   (cf. http://redis.io/topics/sentinel):
-     *  * node:
-     *    * sentinels:
-     *        array of sentinels instances:
-     *          * host:
-     *              Host name/address of the sentinel server
-     *              Can be an IP address, an URI or a hostname
-     *          * port:
-     *              Network port opened by Redis on the sentinel server
-     *    * name:
-     *        Group of Redis instances composed of a master and one
-     *        or more slaves
-     *    * (optional, deprecated) database:
-     *        ID of the redis database (default: 0)
-     *        NOTE: this option is deprecated and will be removed in Kuzzle v3.
-     *              Use 'options.db' instead. If both options are set, then
-     *              "options.db" will take precedence.
-     *  * (optional) options:
-     *      Redis specific options compatible with IORedis.
-     *      See Redis client constructor available options:
-     *      https://github.com/luin/ioredis/blob/master/API.md#redis--eventemitter
-     *
-     * 3. using a redis cluster (cf. http://redis.io/topics/cluster-spec):
-     *   * nodes: array of master nodes of the cluster
-     *     * host:
-     *         Host name/address of a redis cluster node
-     *         Can be an IP address, an URI or a hostname
-     *     * port:
-     *        Network port opened by the redis cluster node
-     *   * (optional, deprecated) database:
-     *       ID of the redis database (default: 0)
-     *       NOTE: this option is deprecated and will be removed in Kuzzle v3.
-     *             Use 'options.db' instead. If both options are set, then
-     *             "options.db" will take precedence.
-     *   * (optional) options:
-     *       Redis specific options compatible with IORedis.
-     *       See Redis client constructor available options:
-     *       https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
-     *   * (optional) clusterOptions:
-     *       Redis Cluster specific options compatible with IORedis.
-     *       See Redis Cluster client constructor available options:
-     *       https://github.com/luin/ioredis/blob/master/API.md#new-clusterstartupnodes-options
-     *   * (optional) overrideDnsLookup:
-     *       Only available when using a Redis Cluster config.
-     *       Use with caution: if set to true, it makes Kuzzle skip DNS validation for TLS certificates
-     *       This is the only way to connect to an AWS Elasticache Cluster with TLS encryption.
-     *       See: https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
-     */
-    /**
-     * @default 'redis'
-     */
-    backend: "redis";
-    clusterOptions: {
-        /**
-         * @default true
-         */
-        enableReadyCheck: boolean;
-    };
+import type { BaseCacheRedisConfiguration } from "../cache/BaseCacheRedisConfiguration";
+export type InternalCacheConfiguration = BaseCacheRedisConfiguration & {
     /**
      * @default 0
      */
     database: number;
-    node: {
-        /**
-         * @default "localhost"
-         */
-        host: string;
-        /**
-         * @default 6379
-         */
-        port: number;
-    };
-    /**
-     * * (optional) options:
-     *    Redis specific options compatible with IORedis.
-     *    See Redis client constructor available options:
-     *    https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
-     *
-     */
-    options?: Record<string, unknown>;
-    /**
-     * Only available when using a Redis Cluster config.
-     * Use with caution: if set to true, it makes Kuzzle skip DNS validation for TLS certificates
-     * This is the only way to connect to an AWS Elasticache Cluster with TLS encryption.
-     *  See: https://github.com/luin/ioredis#special-note-aws-elasticache-clusters-with-tls
-     * @default false
-     */
-    overrideDnsLookup: boolean;
 };

package/dist/lib/types/config/publicCache/PublicCacheRedisConfiguration.d.ts

@@ -1,31 +1,7 @@
-export type PublicCacheRedisConfiguration = {
-    /**
-     * @default 'redis'
-     */
-    backend: "redis";
-    clusterOptions: {
-        /**
-         * @default true
-         */
-        enableReadyCheck: boolean;
-    };
+import type { BaseCacheRedisConfiguration } from "../cache/BaseCacheRedisConfiguration";
+export type PublicCacheRedisConfiguration = BaseCacheRedisConfiguration & {
     /**
      * @default 5
      */
     database: number;
-    node: {
-        /**
-         * @default 'localhost'
-         */
-        host: string;
-        /**
-         * @default 6379
-         */
-        port: number;
-    };
-    options?: Record<string, unknown>;
-    /**
-     * @default false
-     */
-    overrideDnsLookup: boolean;
 };

package/dist/lib/types/config/storageEngine/StorageEngineElasticsearchConfiguration.d.ts

@@ -279,6 +279,9 @@ export type StorageEngineElasticsearch = {
                         hash: {
                             type: "keyword";
                         };
+                        fingerprint: {
+                            type: "keyword";
+                        };
                         description: {
                             type: "text";
                         };

package/dist/lib/types/controllers/Controller.d.ts

@@ -1,6 +1,6 @@
-import { Backend } from "../../core/backend";
-import { ControllerDefinition } from "./ControllerDefinition";
-import { EmbeddedSDK } from "../../core/shared/sdk/embeddedSdk";
+import type { Backend } from "../../core/backend";
+import type { ControllerDefinition } from "./ControllerDefinition";
+import type { EmbeddedSDK } from "../../core/shared/sdk/embeddedSdk";
 /**
  * Base class to declare a controller class
  */
@@ -11,6 +11,11 @@ export declare abstract class Controller {
     protected app: Backend;
     /**
      * Controller name
+     *
+     * May be left unset: `app.controller.use()` derives it from the class name
+     * when the author has not set one. Declared as always present (`!`)
+     * because it is from `use()` on, and because v2.56.0 declared it so — an
+     * optional field broke `this.name` read as a `string` under `strict`.
      */
     name: string;
     /**
@@ -26,6 +31,10 @@ export declare abstract class Controller {
      *   }
      * }
      *
+     * The documented pattern is to assign it in the subclass constructor, and
+     * `app.controller.use()` rejects a controller without one — see
+     * Plugin.checkControllerDefinition. Declared as always present (`!`) for
+     * that reason, as v2.56.0 declared it.
      */
     definition: ControllerDefinition;
     /**

package/dist/lib/types/controllers/ControllerDefinition.d.ts

@@ -1,5 +1,5 @@
-import { JSONObject } from "kuzzle-sdk";
-import { KuzzleRequest } from "../../api/request";
+import type { JSONObject } from "../JSONObject";
+import type { KuzzleRequest } from "../../api/request";
 /**
  * API controller definition.
  *

package/dist/lib/types/controllers/{adminControlller.type.js → adminController.type.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=adminControlller.type.js.map
+//# sourceMappingURL=adminController.type.js.map

package/dist/lib/types/controllers/authController.type.d.ts

@@ -1,5 +1,5 @@
-import { User } from "../../model/security/user";
-import { Serialized } from "../core/auth/formatProcessing.type";
+import type { User } from "../../model/security/user";
+import type { Serialized } from "../core/auth/formatProcessing.type";
 export type GetCurrentUserResponse = Serialized<User> & {
     strategies: any;
 };

package/dist/lib/types/core/auth/formatProcessing.type.d.ts

@@ -1,5 +1,11 @@
+/**
+ * What `formatProcessing` can serialize: anything carrying an id. The id is
+ * nullable because the security models are — they carry `null` until they have
+ * been stored (ADR-0001, TD-62) — and `Serialized` echoes back whichever it
+ * has rather than widening it for everyone.
+ */
 export type Serializable = {
-    _id: string;
+    _id: string | null;
 };
 export type Serialized<T extends Serializable> = {
     _id: T["_id"];

package/dist/lib/types/errors/ErrorDomains.d.ts

@@ -1,4 +1,4 @@
-import { ErrorDefinition } from "./ErrorDefinition";
+import type { ErrorDefinition } from "./ErrorDefinition";
 /**
  * Represents the domains, subDomains and error names with associated definitions
  */

package/dist/lib/types/events/EventGenericDocument.d.ts

@@ -1,5 +1,6 @@
-import { KDocument, JSONObject } from "kuzzle-sdk";
-import { KuzzleRequest, PipeEventHandler } from "../../../index";
+import type { KDocument, KDocumentContent } from "kuzzle-sdk";
+import type { JSONObject } from "../JSONObject";
+import type { KuzzleRequest, PipeEventHandler } from "../../../index";
 /**
  * Events with documents only having the `_id`
  */
@@ -15,15 +16,15 @@ export type EventGenericDocumentBeforeGet = EventGenericDocumentPartial<"beforeG
 /**
  * Events having entire documents
  */
-type EventGenericDocument<name extends string, KDocumentContent> = {
+type EventGenericDocument<name extends string, TContent> = {
     name: `generic:document:${name}`;
-    args: [KDocument<KDocumentContent>[], KuzzleRequest];
+    args: [KDocument<TContent & KDocumentContent>[], KuzzleRequest];
 };
-export type EventGenericDocumentBeforeWrite<KDocumentContent = JSONObject> = EventGenericDocument<"beforeWrite", KDocumentContent>;
-export type EventGenericDocumentAfterWrite<KDocumentContent = JSONObject> = EventGenericDocument<"afterWrite", KDocumentContent>;
-export type EventGenericDocumentBeforeUpdate<KDocumentContent = JSONObject> = EventGenericDocument<"beforeUpdate", KDocumentContent>;
-export type EventGenericDocumentAfterUpdate<KDocumentContent = JSONObject> = EventGenericDocument<"afterUpdate", KDocumentContent>;
-export type EventGenericDocumentAfterGet<KDocumentContent = JSONObject> = EventGenericDocument<"afterGet", KDocumentContent>;
+export type EventGenericDocumentBeforeWrite<TContent = JSONObject> = EventGenericDocument<"beforeWrite", TContent>;
+export type EventGenericDocumentAfterWrite<TContent = JSONObject> = EventGenericDocument<"afterWrite", TContent>;
+export type EventGenericDocumentBeforeUpdate<TContent = JSONObject> = EventGenericDocument<"beforeUpdate", TContent>;
+export type EventGenericDocumentAfterUpdate<TContent = JSONObject> = EventGenericDocument<"afterUpdate", TContent>;
+export type EventGenericDocumentAfterGet<TContent = JSONObject> = EventGenericDocument<"afterGet", TContent>;
 export type EventGenericDocumentInjectMetadata = {
     name: `generic:document:injectMetadata`;
     args: [

package/dist/lib/types/events/EventProtocol.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { JSONObject } from "kuzzle-sdk";
-import { PipeEventHandler } from "../../../index";
-import { ClientConnection } from "../ClientConnection";
-import { HttpMessage } from "../HttpMessage";
+import type { JSONObject } from "../JSONObject";
+import type { PipeEventHandler } from "../../../index";
+import type { ClientConnection } from "../ClientConnection";
+import type { HttpMessage } from "../HttpMessage";
 export type EventHTTPBeforeParsingPayload = {
     name: `protocol:http:beforeParsingPayload`;
     args: [{

package/dist/lib/types/index.d.ts

@@ -1,18 +1,24 @@
 export * from "./controllers/Controller";
+export * from "./ApiRoute";
 export * from "./controllers/ControllerDefinition";
 export * from "./controllers/ControllerRights";
+export * from "./ClientConnection";
 export * from "./Deprecation";
 export * from "./EventHandler";
 export * from "./Global";
+export * from "./HttpMessage";
 export * from "./HttpStream";
+export * from "./JSONObject";
 export * from "./KuzzleDocument";
 export * from "./OpenApiDefinition";
 export * from "./PasswordPolicy";
 export * from "./Plugin";
+export * from "./PluginManifest";
 export * from "./Policy";
 export * from "./PolicyRestrictions";
 export * from "./ProfileDefinition";
 export * from "./RoleDefinition";
+export * from "./StrategyDefinition";
 export * from "./Target";
 export * from "./Token";
 export * from "./config/DumpConfiguration";
@@ -23,6 +29,7 @@ export * from "./config/PluginsConfiguration";
 export * from "./config/SecurityConfiguration";
 export * from "./config/ServerConfiguration";
 export * from "./config/ServicesConfiguration";
+export * from "./config/cache/BaseCacheRedisConfiguration";
 export * from "./config/internalCache/InternalCacheRedisConfiguration";
 export * from "./config/publicCache/PublicCacheRedisConfiguration";
 export * from "./config/storageEngine/StorageEngineElasticsearchConfiguration";

package/dist/lib/types/index.js

@@ -35,20 +35,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./controllers/Controller"), exports);
+__exportStar(require("./ApiRoute"), exports);
 __exportStar(require("./controllers/ControllerDefinition"), exports);
 __exportStar(require("./controllers/ControllerRights"), exports);
+__exportStar(require("./ClientConnection"), exports);
 __exportStar(require("./Deprecation"), exports);
 __exportStar(require("./EventHandler"), exports);
 __exportStar(require("./Global"), exports);
+__exportStar(require("./HttpMessage"), exports);
 __exportStar(require("./HttpStream"), exports);
+__exportStar(require("./JSONObject"), exports);
 __exportStar(require("./KuzzleDocument"), exports);
 __exportStar(require("./OpenApiDefinition"), exports);
 __exportStar(require("./PasswordPolicy"), exports);
 __exportStar(require("./Plugin"), exports);
+__exportStar(require("./PluginManifest"), exports);
 __exportStar(require("./Policy"), exports);
 __exportStar(require("./PolicyRestrictions"), exports);
 __exportStar(require("./ProfileDefinition"), exports);
 __exportStar(require("./RoleDefinition"), exports);
+__exportStar(require("./StrategyDefinition"), exports);
 __exportStar(require("./Target"), exports);
 __exportStar(require("./Token"), exports);
 __exportStar(require("./config/DumpConfiguration"), exports);
@@ -59,6 +65,7 @@ __exportStar(require("./config/PluginsConfiguration"), exports);
 __exportStar(require("./config/SecurityConfiguration"), exports);
 __exportStar(require("./config/ServerConfiguration"), exports);
 __exportStar(require("./config/ServicesConfiguration"), exports);
+__exportStar(require("./config/cache/BaseCacheRedisConfiguration"), exports);
 __exportStar(require("./config/internalCache/InternalCacheRedisConfiguration"), exports);
 __exportStar(require("./config/publicCache/PublicCacheRedisConfiguration"), exports);
 __exportStar(require("./config/storageEngine/StorageEngineElasticsearchConfiguration"), exports);

package/dist/lib/types/shared/StoreCollectionsDefinition.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import type { JSONObject } from "../JSONObject";
 export interface StoreCollectionDefinition {
     /**
      * Collection mappings

package/dist/lib/types/storage/7/Elasticsearch.d.ts

@@ -1,4 +1,5 @@
-import { ByteSize, ClusterNodesStats } from "sdk-es7/api/types";
+import type { ByteSize, ClusterNodesStats } from "sdk-es7/api/types";
+import type { JSONObject } from "../../JSONObject";
 export type InfoResult = {
     type: string;
     version: string;
@@ -7,20 +8,31 @@ export type InfoResult = {
     spaceUsed?: ByteSize;
     nodes?: ClusterNodesStats;
 };
+/**
+ * Kuzzle's own metadata, stored alongside every document it writes.
+ *
+ * `author` and `updater` are kuids, and `getKuid` answers `null` for an
+ * anonymous write — so both are nullable, as is `updatedAt` on a document that
+ * has only ever been created.
+ */
+export type KuzzleInfo = {
+    author: string | null;
+    createdAt: number;
+    updatedAt: number | null;
+    updater: string | null;
+};
+/**
+ * `_kuzzle_info` is `Partial` because a partial update writes only the two
+ * fields it owns (`updatedAt`, `updater`) and leaves the creation pair to the
+ * document already in the index.
+ */
 export type KRequestBody<T> = T & {
-    _kuzzle_info?: {
-        author: string;
-        createdAt: number;
-        updatedAt: number | null;
-        updater: string | null;
-    };
+    _kuzzle_info?: Partial<KuzzleInfo>;
 };
-export interface JSONObject {
-    [key: string]: any;
-}
+export type { JSONObject } from "../../JSONObject";
 export type KImportError = {
-    _id: string;
-    status: string;
+    _id?: string | null;
+    status: number;
     _source?: JSONObject;
     error?: {
         reason: string;
@@ -30,8 +42,45 @@ export type KImportError = {
 export type KRequestParams = {
     refresh?: boolean | "wait_for";
     timeout?: string;
-    userId?: string;
+    userId?: string | null;
     injectKuzzleMeta?: boolean;
     limits?: boolean;
     source?: boolean;
 };
+/**
+ * Maps an ES alias to the index/collection pair a multi-target search resolved
+ * it from — see `Elasticsearch._mapTargetsToAlias`.
+ */
+export type AliasToTargets = {
+    [alias: string]: {
+        collection: string;
+        index: string;
+    };
+};
+/**
+ * The standardised answer `_mExecute` builds for every m* write: the documents
+ * Elasticsearch accepted, and the ones it (or Kuzzle) rejected.
+ */
+export type KMExecuteResult = {
+    errors: JSONObject[];
+    items: JSONObject[];
+};
+/**
+ * The answer `import` builds from a bulk response: one entry per action, keyed
+ * by the action name Elasticsearch echoed back.
+ */
+export type KImportResult = {
+    errors: Array<Record<string, KImportError>>;
+    items: Array<Record<string, {
+        _id?: string | null;
+        status?: number;
+    }>>;
+};
+/**
+ * One row of a `cat.aliases` answer, once the two fields Elasticsearch always
+ * fills have been narrowed — see `Elasticsearch._catAliases`.
+ */
+export type CatAliasRecord = {
+    alias: string;
+    index: string;
+};

package/dist/lib/types/storage/8/Elasticsearch.d.ts

@@ -1,4 +1,5 @@
-import { estypes } from "sdk-es8";
+import type { estypes } from "sdk-es8";
+import type { JSONObject } from "../../JSONObject";
 export type InfoResult = {
     type: string;
     version: string;
@@ -29,20 +30,31 @@ export type KStats = {
     indexes: KStatsIndex[];
     size: estypes.ByteSize;
 };
+/**
+ * Kuzzle's own metadata, stored alongside every document it writes.
+ *
+ * `author` and `updater` are kuids, and `getKuid` answers `null` for an
+ * anonymous write — so both are nullable, as is `updatedAt` on a document that
+ * has only ever been created.
+ */
+export type KuzzleInfo = {
+    author: string | null;
+    createdAt: number;
+    updatedAt: number | null;
+    updater: string | null;
+};
+/**
+ * `_kuzzle_info` is `Partial` because a partial update writes only the two
+ * fields it owns (`updatedAt`, `updater`) and leaves the creation pair to the
+ * document already in the index.
+ */
 export type KRequestBody<T> = T & {
-    _kuzzle_info?: {
-        author: string;
-        createdAt: number;
-        updatedAt: number | null;
-        updater: string | null;
-    };
+    _kuzzle_info?: Partial<KuzzleInfo>;
 };
-export interface JSONObject {
-    [key: string]: any;
-}
+export type { JSONObject } from "../../JSONObject";
 export type KImportError = {
-    _id: string;
-    status: string;
+    _id?: string | null;
+    status: number;
     _source?: JSONObject;
     error?: {
         reason: string;
@@ -52,8 +64,45 @@ export type KImportError = {
 export type KRequestParams = {
     refresh?: boolean | "wait_for";
     timeout?: string;
-    userId?: string;
+    userId?: string | null;
     injectKuzzleMeta?: boolean;
     limits?: boolean;
     source?: boolean;
 };
+/**
+ * Maps an ES alias to the index/collection pair a multi-target search resolved
+ * it from — see `Elasticsearch._mapTargetsToAlias`.
+ */
+export type AliasToTargets = {
+    [alias: string]: {
+        collection: string;
+        index: string;
+    };
+};
+/**
+ * One row of a `cat.aliases` answer, once the two fields Elasticsearch always
+ * fills have been narrowed — see `Elasticsearch._catAliases`.
+ */
+export type CatAliasRecord = {
+    alias: string;
+    index: string;
+};
+/**
+ * The standardised answer `_mExecute` builds for every m* write: the documents
+ * Elasticsearch accepted, and the ones it (or Kuzzle) rejected.
+ */
+export type KMExecuteResult = {
+    errors: JSONObject[];
+    items: JSONObject[];
+};
+/**
+ * The answer `import` builds from a bulk response: one entry per action, keyed
+ * by the action name Elasticsearch echoed back.
+ */
+export type KImportResult = {
+    errors: Array<Record<string, KImportError>>;
+    items: Array<Record<string, {
+        _id?: string | null;
+        status?: number;
+    }>>;
+};

package/dist/lib/util/Inflector.d.ts

@@ -20,8 +20,11 @@ export declare class Inflector {
     static pascalCase(string: string): string;
     /**
      * Converts a string to camelCase
+     *
+     * Declared `unknown`, as v2.56.0's `any` accepted anything: lodash
+     * stringifies it.
      */
-    static camelCase(string: any): string;
+    static camelCase(string: unknown): string;
     /**
      * Converts a string to snake_case
      * https://stackoverflow.com/a/52964182

package/dist/lib/util/Inflector.js

@@ -56,9 +56,6 @@ class Inflector {
     static pascalCase(string) {
         return lodash_1.default.startCase(string).replace(/ /g, "");
     }
-    /**
-     * Converts a string to camelCase
-     */
     static camelCase(string) {
         return lodash_1.default.camelCase(string);
     }

package/dist/lib/util/assertType.d.ts

@@ -1,51 +1,48 @@
 /**
- * Throws if the provided data is not an array containing exclusively
- * values of the specified "type"
- * Returns a clone of the provided array if valid
+ * Throws if the provided data is not an object.
+ * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {array}
+ * @param attr - tested attribute name
+ * @param data
  */
-export function assertArray(attr: string, data: any, type: any): any[];
+export declare function assertObject<T extends object>(attr: string, data: T | null | undefined): T | null;
+export declare function assertObject(attr: string, data: unknown): Record<string, unknown> | null;
 /**
  * Throws if the provided data is not an object or an array.
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {object|array}
+ * @param attr - tested attribute name
+ * @param data
  */
-export function assertArrayOrObject(attr: string, data: any): object | any[];
+export declare function assertArrayOrObject(attr: string, data: unknown): object | null;
 /**
- * Throws if the provided data is not an integer
- * Returns the unmodified data if validated
+ * Throws if the provided data is not an array containing exclusively
+ * values of the specified "type"
+ * Returns a clone of the provided array if valid
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {number}
+ * @param attr - tested attribute name
+ * @param data
  */
-export function assertInteger(attr: string, data: any): number;
+export declare function assertArray(attr: string, data: unknown, type: "string"): string[];
+export declare function assertArray(attr: string, data: unknown, type: string): unknown[];
 /**
- * Throws if the provided data is not an object.
+ * Throws if the provided data is not a string
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {object}
+ * @param attr - tested attribute name
+ * @param data
  */
-export function assertObject(attr: string, data: any): object;
+export declare function assertString(attr: string, data: unknown): string | null;
 /**
- * Throws if the provided data is not a string
+ * Throws if the provided data is not an integer
  * Returns the unmodified data if validated
  *
  * @throws
- * @param {string} attr - tested attribute name
- * @param {*} data
- * @return {null|string}
+ * @param attr - tested attribute name
+ * @param data
  */
-export function assertString(attr: string, data: any): null | string;
+export declare function assertInteger(attr: string, data: unknown): number;