@allurereport/core 3.2.0 → 3.4.0

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { DefaultLabelsConfig, EnvironmentsConfig, KnownTestFailure, ReportVariables } from "@allurereport/core-api";
+import type { CategoriesConfig, DefaultLabelsConfig, EnvironmentsConfig, KnownTestFailure, ReportVariables } from "@allurereport/core-api";
 import type { Plugin, QualityGateConfig, ReportFiles } from "@allurereport/plugin-api";
 import type { ResultsReader } from "@allurereport/reader-api";
 export interface PluginInstance {
@@ -12,11 +12,12 @@ export interface FullConfig {
     output: string;
     open: boolean;
     port: string | undefined;
+    hideLabels?: (string | RegExp)[];
     historyPath?: string;
     historyLimit?: number;
     knownIssuesPath: string;
     defaultLabels?: DefaultLabelsConfig;
-    stage?: string;
+    dump?: string;
     environment?: string;
     environments?: EnvironmentsConfig;
     variables?: ReportVariables;
@@ -27,6 +28,7 @@ export interface FullConfig {
     known?: KnownTestFailure[];
     realTime?: any;
     qualityGate?: QualityGateConfig;
+    categories?: CategoriesConfig;
     allureService?: {
         accessToken?: string;
     };

package/dist/config.d.ts

@@ -5,11 +5,13 @@ export interface ConfigOverride {
     output?: Config["output"];
     open?: Config["open"];
     port?: Config["port"];
+    hideLabels?: Config["hideLabels"];
     historyPath?: Config["historyPath"];
     historyLimit?: Config["historyLimit"];
     knownIssuesPath?: Config["knownIssuesPath"];
     plugins?: Config["plugins"];
 }
+export declare const assertValidPluginId: (id: string) => void;
 export declare const getPluginId: (key: string) => string;
 export declare const findConfig: (cwd: string, configPath?: string) => Promise<string | undefined>;
 export declare const validateConfig: (config: Config) => {

package/dist/config.js

@@ -2,11 +2,14 @@ import * as console from "node:console";
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import * as process from "node:process";
+import { validateEnvironmentName } from "@allurereport/core-api";
 import { parse } from "yaml";
 import { readKnownIssues } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
+import { environmentIdentityById, environmentIdentityByName, normalizeEnvironmentDescriptorMap, } from "./utils/environment.js";
 import { importWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
+import { assertValidPluginIdForWindows, isWindows } from "./utils/windows.js";
 const CONFIG_FILENAMES = [
     "allurerc.js",
     "allurerc.mjs",
@@ -16,8 +19,31 @@ const CONFIG_FILENAMES = [
     "allurerc.yml",
 ];
 const DEFAULT_CONFIG = {};
+export const assertValidPluginId = (id) => {
+    if (id.length === 0) {
+        throw new Error("Invalid plugin id: must not be empty");
+    }
+    if (id === "." || id === "..") {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not be "." or ".."`);
+    }
+    if (id.includes("..")) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not contain ".."`);
+    }
+    if (/[/\\]/.test(id)) {
+        throw new Error(`Invalid plugin id ${JSON.stringify(id)}: must not contain path separators`);
+    }
+    if (isWindows()) {
+        assertValidPluginIdForWindows(id);
+    }
+};
 export const getPluginId = (key) => {
-    return key.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
+    const trimmed = key.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`Invalid plugin key ${JSON.stringify(key)}: must not be empty or whitespace-only`);
+    }
+    const id = trimmed.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
+    assertValidPluginId(id);
+    return id;
 };
 export const findConfig = async (cwd, configPath) => {
     if (configPath) {
@@ -51,16 +77,19 @@ export const validateConfig = (config) => {
         "output",
         "open",
         "port",
+        "hideLabels",
         "historyPath",
         "historyLimit",
         "knownIssuesPath",
         "plugins",
         "defaultLabels",
         "variables",
+        "environment",
         "environments",
         "appendHistory",
         "qualityGate",
         "allureService",
+        "categories",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -97,14 +126,42 @@ export const loadJsonConfig = async (configPath) => {
 export const loadJsConfig = async (configPath) => {
     return (await import(normalizeImportPath(configPath))).default;
 };
+const resolveConfigEnvironments = (config) => {
+    const errors = [];
+    const { normalized: environments, errors: environmentErrors } = normalizeEnvironmentDescriptorMap(config.environments ?? {}, "config.environments");
+    let environment;
+    errors.push(...environmentErrors);
+    if (config.environment !== undefined) {
+        const environmentResult = validateEnvironmentName(config.environment);
+        if (!environmentResult.valid) {
+            errors.push(`environment ${environmentResult.reason}`);
+        }
+        else {
+            const normalizedEnvironment = environmentResult.normalized;
+            environment =
+                environmentIdentityById(environments, normalizedEnvironment)?.id ??
+                    environmentIdentityByName(environments, normalizedEnvironment)?.id ??
+                    normalizedEnvironment;
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`The provided Allure config contains invalid environments: ${errors.join("; ")}`);
+    }
+    return {
+        environments,
+        environment,
+    };
+};
 export const resolveConfig = async (config, override = {}) => {
     const validationResult = validateConfig(config);
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
+    const { environments, environment } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
     const port = override.port ?? config.port ?? undefined;
+    const hideLabels = override.hideLabels ?? config.hideLabels;
     const historyPath = override.historyPath ?? config.historyPath;
     const historyLimit = override.historyLimit ?? config.historyLimit;
     const appendHistory = config.appendHistory ?? true;
@@ -112,22 +169,24 @@ export const resolveConfig = async (config, override = {}) => {
     const output = resolve(override.output ?? config.output ?? "./allure-report");
     const known = await readKnownIssues(knownIssuesPath);
     const variables = config.variables ?? {};
-    const environments = config.environments ?? {};
-    const plugins = Object.keys(override?.plugins ?? config?.plugins ?? {}).length === 0
+    const configuredPlugins = override.plugins ?? config.plugins;
+    const plugins = Object.keys(configuredPlugins ?? {}).length === 0
         ? {
             awesome: {
                 options: {},
             },
         }
-        : config.plugins;
+        : configuredPlugins;
     const pluginInstances = await resolvePlugins(plugins);
     return {
         name,
         output,
         open,
         port,
+        hideLabels,
         knownIssuesPath,
         known,
+        environment,
         variables,
         environments,
         appendHistory,
@@ -138,6 +197,7 @@ export const resolveConfig = async (config, override = {}) => {
         defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
         allureService: config.allureService,
+        categories: config.categories,
     };
 };
 export const readConfig = async (cwd = process.cwd(), configPath, override) => {
@@ -165,19 +225,26 @@ export const readConfig = async (cwd = process.cwd(), configPath, override) => {
 export const getPluginInstance = (config, predicate) => {
     return config?.plugins?.find(predicate);
 };
+const isModuleNotFoundError = (err) => {
+    return err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND";
+};
 export const resolvePlugin = async (path) => {
     if (!path.startsWith("@allurereport/plugin-")) {
         try {
             const module = await importWrapper(`@allurereport/plugin-${path}`);
             return module.default;
         }
-        catch (err) { }
+        catch (err) {
+            if (!isModuleNotFoundError(err)) {
+                throw err;
+            }
+        }
     }
     try {
         const module = await importWrapper(path);
         return module.default;
     }
-    catch (err) {
+    catch {
         throw new Error(`Cannot resolve plugin: ${path}`);
     }
 };

package/dist/history.d.ts

@@ -1,4 +1,4 @@
-import type { AllureHistory, HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
+import { type AllureHistory, type HistoryDataPoint, type TestCase, type TestResult } from "@allurereport/core-api";
 export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
 export declare class AllureLocalHistory implements AllureHistory {
     #private;

package/dist/history.js

@@ -3,14 +3,21 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AllureLocalHistory_openFileToReadIfExists, _AllureLocalHistory_ensureFileOpenedToAppend, _AllureLocalHistory_findFirstEntryAddress, _AllureLocalHistory_throwUnexpectedReadError;
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _AllureLocalHistory_cachedHistory, _AllureLocalHistory_openFileToReadIfExists, _AllureLocalHistory_ensureFileOpenedToAppend, _AllureLocalHistory_findFirstEntryAddress, _AllureLocalHistory_throwUnexpectedReadError;
 import { once } from "node:events";
 import { mkdir, open } from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline/promises";
 import { pipeline } from "node:stream/promises";
+import { normalizeHistoryDataPointUrls, } from "@allurereport/core-api";
 import { isFileNotFoundError } from "./utils/misc.js";
-const createHistoryItems = (testResults) => {
+const createHistoryItems = (testResults, remoteUrl) => {
     return testResults
         .filter((tr) => tr.historyId)
         .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
@@ -26,7 +33,7 @@ const createHistoryItems = (testResults) => {
             stop,
             duration,
             labels,
-            url: "",
+            url: remoteUrl,
             historyId: historyId,
             reportLinks: [],
         };
@@ -43,7 +50,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         name: reportName,
         timestamp: new Date().getTime(),
         knownTestCaseIds,
-        testResults: createHistoryItems(testResults),
+        testResults: createHistoryItems(testResults, remoteUrl),
         metrics: {},
         url: remoteUrl,
     };
@@ -51,6 +58,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
 export class AllureLocalHistory {
     constructor(params) {
         this.params = params;
+        _AllureLocalHistory_cachedHistory.set(this, []);
         _AllureLocalHistory_openFileToReadIfExists.set(this, async (filePath) => {
             try {
                 return await open(filePath, "r");
@@ -121,6 +129,9 @@ export class AllureLocalHistory {
         });
     }
     async readHistory() {
+        if (__classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").length > 0) {
+            return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
+        }
         const fullPath = path.resolve(this.params.historyPath);
         const historyFile = await __classPrivateFieldGet(this, _AllureLocalHistory_openFileToReadIfExists, "f").call(this, fullPath);
         if (historyFile === undefined) {
@@ -134,18 +145,20 @@ export class AllureLocalHistory {
                 .createInterface({ input: stream, terminal: false, crlfDelay: Infinity })
                 .on("line", (line) => {
                 if (line && line.trim().length) {
-                    const historyEntry = JSON.parse(line);
+                    const historyEntry = normalizeHistoryDataPointUrls(JSON.parse(line));
                     historyPoints.push(historyEntry);
                 }
             });
             await once(readlineInterface, "close");
-            return historyPoints;
+            __classPrivateFieldSet(this, _AllureLocalHistory_cachedHistory, historyPoints, "f");
+            return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
         }
         finally {
             await historyFile.close();
         }
     }
     async appendHistory(data) {
+        const normalizedData = normalizeHistoryDataPointUrls(data);
         const fullPath = path.resolve(this.params.historyPath);
         const parentDir = path.dirname(fullPath);
         const { limit } = this.params;
@@ -153,22 +166,33 @@ export class AllureLocalHistory {
         const { file: historyFile, exists: historyExists } = await __classPrivateFieldGet(this, _AllureLocalHistory_ensureFileOpenedToAppend, "f").call(this, fullPath);
         try {
             const dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
-            if (limit !== 0) {
-                if (historyExists) {
-                    const start = limit ? await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit - 1) : 0;
-                    const src = historyFile.createReadStream({ start, autoClose: false });
-                    await pipeline(src, dst, { end: false });
-                }
-                const sources = [JSON.stringify(data), Buffer.from([0x0a])];
-                await pipeline(sources, dst);
+            if (limit === 0 && historyExists) {
+                await historyFile.truncate(0);
+                return;
+            }
+            if (limit === 0 && !historyExists) {
+                return;
             }
+            if (historyExists) {
+                const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit ? limit - 1 : undefined);
+                const src = historyFile.createReadStream({ start, autoClose: false });
+                await pipeline(src, dst, { end: false });
+            }
+            const sources = [JSON.stringify(normalizedData), Buffer.from([0x0a])];
+            await pipeline(sources, dst);
             if (historyExists) {
                 await historyFile.truncate(dst.bytesWritten);
             }
         }
         finally {
             await historyFile.close();
+            if (limit !== 0) {
+                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);
+            }
+            if (limit) {
+                __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").splice(limit);
+            }
         }
     }
 }
-_AllureLocalHistory_openFileToReadIfExists = new WeakMap(), _AllureLocalHistory_ensureFileOpenedToAppend = new WeakMap(), _AllureLocalHistory_findFirstEntryAddress = new WeakMap(), _AllureLocalHistory_throwUnexpectedReadError = new WeakMap();
+_AllureLocalHistory_cachedHistory = new WeakMap(), _AllureLocalHistory_openFileToReadIfExists = new WeakMap(), _AllureLocalHistory_ensureFileOpenedToAppend = new WeakMap(), _AllureLocalHistory_findFirstEntryAddress = new WeakMap(), _AllureLocalHistory_throwUnexpectedReadError = new WeakMap();

package/dist/index.d.ts

@@ -4,9 +4,10 @@ export * from "./utils/crypto.js";
 export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
+export * from "./utils/environment.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -3,9 +3,10 @@ export * from "./utils/crypto.js";
 export * from "./utils/path.js";
 export * from "./utils/new.js";
 export * from "./utils/flaky.js";
+export * from "./utils/environment.js";
 export * from "./history.js";
 export * from "./known.js";
 export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/plugin.js

@@ -13,6 +13,7 @@ var _DefaultPluginState_state, _PluginFiles_parent, _PluginFiles_pluginId, _InMe
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { join as joinPosix } from "node:path/posix";
+import { resolvePathUnderOutputRoot } from "./utils/safeOutputPath.js";
 export class DefaultPluginState {
     constructor(state) {
         _DefaultPluginState_state.set(this, void 0);
@@ -58,7 +59,7 @@ export class FileSystemReportFiles {
     constructor(output) {
         _FileSystemReportFiles_output.set(this, void 0);
         this.addFile = async (path, data) => {
-            const targetPath = resolve(__classPrivateFieldGet(this, _FileSystemReportFiles_output, "f"), path);
+            const targetPath = resolvePathUnderOutputRoot(__classPrivateFieldGet(this, _FileSystemReportFiles_output, "f"), path);
             const targetDirPath = dirname(targetPath);
             await mkdir(targetDirPath, { recursive: true });
             await writeFile(targetPath, data, { encoding: "utf-8" });

package/dist/qualityGate/qualityGate.js

@@ -4,7 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state;
-import { DEFAULT_ENVIRONMENT } from "@allurereport/core-api";
 import { gray, red } from "yoctocolors";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
@@ -77,6 +76,7 @@ export class QualityGate {
                     },
                     expected,
                     knownIssues,
+                    environment,
                 });
                 if (result.success) {
                     continue;
@@ -89,7 +89,7 @@ export class QualityGate {
                         actual: result.actual,
                         expected,
                     }),
-                    environment: environment || DEFAULT_ENVIRONMENT,
+                    environment,
                 });
                 if (ruleset.fastFail) {
                     fastFailed = true;

package/dist/qualityGate/rules.d.ts

@@ -3,4 +3,6 @@ export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
 export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
-export declare const qualityGateDefaultRules: QualityGateRule<number>[];
+export declare const allTestsContainEnvRule: QualityGateRule<string>;
+export declare const environmentsTestedRule: QualityGateRule<string[]>;
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string> | QualityGateRule<string[]>)[];

package/dist/qualityGate/rules.js

@@ -1,11 +1,11 @@
-import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+import { filterSuccessful, filterUnknownByKnownIssues, filterUnsuccessful } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
     validate: async ({ trs, knownIssues, expected, state }) => {
-        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
-        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
         const failedTrs = unknown.filter(filterUnsuccessful);
         const actual = failedTrs.length + (state.getResult() ?? 0);
         state.setResult(actual);
@@ -31,8 +31,8 @@ export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
     validate: async ({ trs, knownIssues, expected }) => {
-        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
-        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+        const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
         const passedTrs = unknown.filter(filterSuccessful);
         const rate = passedTrs.length === 0 ? 0 : passedTrs.length / unknown.length;
         return {
@@ -52,4 +52,38 @@ export const maxDurationRule = {
         };
     },
 };
-export const qualityGateDefaultRules = [maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule];
+export const allTestsContainEnvRule = {
+    rule: "allTestsContainEnv",
+    message: ({ actual, expected }) => `Not all tests contain the required environment, ${bold(`"${expected}"`)}; ${bold(actual.length === 1 ? "one" : String(actual))} ${actual.length === 1 ? "test has" : "tests have"} different or missing environment`,
+    validate: async ({ trs, expected }) => {
+        const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
+        const actual = testsWithoutEnv.length;
+        return {
+            success: actual === 0,
+            actual,
+        };
+    },
+};
+export const environmentsTestedRule = {
+    rule: "environmentsTested",
+    message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${expected.join('", "')}"`,
+    validate: async ({ trs, expected, state }) => {
+        const previouslyTested = new Set(state.getResult() ?? []);
+        const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");
+        const testedEnvs = new Set([...previouslyTested, ...batchTested]);
+        state.setResult([...testedEnvs]);
+        const missing = expected.filter((env) => !testedEnvs.has(env));
+        return {
+            success: missing.length === 0,
+            actual: missing,
+        };
+    },
+};
+export const qualityGateDefaultRules = [
+    maxFailuresRule,
+    minTestsCountRule,
+    successRateRule,
+    maxDurationRule,
+    allTestsContainEnvRule,
+    environmentsTestedRule,
+];

package/dist/report.d.ts

@@ -27,6 +27,6 @@ export declare class AllureReport {
     }>;
     start: () => Promise<void>;
     dumpState: () => Promise<void>;
-    restoreState: (stages: string[]) => Promise<void>;
+    restoreState: (dumps: string[]) => Promise<void>;
     done: () => Promise<void>;
 }