@wpelevator/wp-release 0.4.1 → 0.6.0

package/dist/commands/changeset-args.js

@@ -0,0 +1,139 @@
+import { ValidationError } from "../errors.js";
+import { CHANGESET_BUMPS } from "../changesets.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+/** Parse-args options for `changeset-add`. */
+export const changesetAddArgs = {
+    package: { type: 'string', multiple: true },
+    bump: { type: 'string', multiple: true },
+    summary: { type: 'string' },
+    empty: { type: 'boolean' },
+    name: { type: 'string' },
+};
+/**
+ * Parse and validate the `changeset-add` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized changeset input.
+ * @throws {ValidationError} If required options are missing or conflicting.
+ */
+export function parseChangesetAddArgs(values) {
+    const names = getStrings(values, 'package');
+    const bumps = getStrings(values, 'bump');
+    const summary = getString(values, 'summary')?.trim();
+    const empty = getBoolean(values, 'empty');
+    const name = getString(values, 'name');
+    if (empty && (names.length || bumps.length || summary)) {
+        throw new ValidationError('--empty cannot be combined with --package, --bump or --summary.');
+    }
+    if (!empty && (!names.length || names.length !== bumps.length)) {
+        throw new ValidationError('Pass matching repeated --package <name> and --bump <patch|minor|major> options, or use --empty.');
+    }
+    if (!empty && !summary) {
+        throw new ValidationError('--summary <text> is required unless --empty is set.');
+    }
+    if (name && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+        throw new ValidationError('--name must contain only letters, numbers, dots, underscores or hyphens.');
+    }
+    const packages = {};
+    names.forEach((packageName, index) => {
+        const bump = bumps[index];
+        if (Object.hasOwn(packages, packageName)) {
+            throw new ValidationError(`Package "${packageName}" was passed more than once.`);
+        }
+        if (!CHANGESET_BUMPS.includes(bump)) {
+            throw new ValidationError(`Invalid bump "${bump}" for package "${packageName}"; expected patch, minor or major.`);
+        }
+        packages[packageName] = bump;
+    });
+    return {
+        packages,
+        summary: summary ?? '',
+        empty,
+        ...(name ? { name } : {}),
+    };
+}
+/** Parse-args options for `changeset-status`. */
+export const changesetStatusArgs = {
+    since: { type: 'string' },
+};
+/**
+ * Parse the `changeset-status` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized status input.
+ * @throws {ValidationError} If --since is empty.
+ */
+export function parseChangesetStatusArgs(values) {
+    const since = getString(values, 'since');
+    if ('' === since?.trim()) {
+        throw new ValidationError('--since <ref> must not be empty.');
+    }
+    return since ? { since } : {};
+}
+/** Parse-args options for `changeset-version`. */
+export const changesetVersionArgs = {
+    'dry-run': { type: 'boolean' },
+    date: { type: 'string' },
+};
+/**
+ * Validate and normalize a release date option.
+ *
+ * @param  value Value from --date.
+ * @return A validated ISO date or undefined.
+ * @throws {ValidationError} If the date is not a real YYYY-MM-DD date.
+ */
+export function parseChangesetDate(value) {
+    if (undefined === value) {
+        return undefined;
+    }
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    if (!match ||
+        Number.isNaN(parsed.getTime()) ||
+        parsed.toISOString().slice(0, 10) !== value) {
+        throw new ValidationError(`Invalid release date "${value}"; expected a real date in YYYY-MM-DD format.`);
+    }
+    return value;
+}
+/**
+ * Parse the `changeset-version` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized versioning input.
+ * @throws {ValidationError} If --date is invalid.
+ */
+export function parseChangesetVersionArgs(values) {
+    const date = parseChangesetDate(getString(values, 'date'));
+    return {
+        dryRun: getBoolean(values, 'dry-run'),
+        ...(date ? { date } : {}),
+    };
+}
+/** Parse-args options for `changeset-tag`. */
+export const changesetTagArgs = {
+    push: { type: 'boolean' },
+    'dry-run': { type: 'boolean' },
+    'github-release': { type: 'boolean' },
+    since: { type: 'string' },
+};
+/**
+ * Parse the `changeset-tag` options.
+ *
+ * @param values Parsed CLI options.
+ * @return Normalized tag input.
+ */
+export function parseChangesetTagArgs(values) {
+    const args = {
+        push: getBoolean(values, 'push'),
+        dryRun: getBoolean(values, 'dry-run'),
+        githubRelease: getBoolean(values, 'github-release'),
+        since: getString(values, 'since'),
+    };
+    if ('' === args.since?.trim()) {
+        throw new ValidationError('--since <ref> must not be empty.');
+    }
+    if (args.githubRelease && !args.push) {
+        throw new ValidationError('--github-release requires --push.');
+    }
+    return args;
+}

package/dist/commands/changeset-status.d.ts

@@ -0,0 +1,43 @@
+export interface ChangesetStatusResult {
+    changesets: Array<{
+        fileName: string;
+        packages: Record<string, string>;
+        summary: string;
+    }>;
+    releases: Array<{
+        package: string;
+        bump: string;
+        currentVersion: string;
+        nextVersion: string;
+    }>;
+    changedPackages: string[];
+    changedPackageFiles: Record<string, string[]>;
+    missingChangesets: string[];
+}
+declare const _default: {
+    name: string;
+    usage: string;
+    summary: string;
+    help: string;
+    options: {
+        readonly since: {
+            readonly type: "string";
+        };
+    };
+    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            releases: {
+                package: string;
+                bump: "patch" | "minor" | "major";
+                currentVersion: string;
+                nextVersion: string;
+            }[];
+            changesets: import("../changesets.ts").Changeset[];
+            changedPackages: string[];
+            changedPackageFiles: Record<string, string[]>;
+            missingChangesets: string[];
+        };
+    }>;
+};
+export default _default;

package/dist/commands/changeset-status.js

@@ -0,0 +1,65 @@
+import { getChangesetStatus } from "../changeset-release.js";
+import { changesetStatusArgs, parseChangesetStatusArgs, } from "./changeset-args.js";
+export default {
+    name: 'changeset-status',
+    usage: 'changeset-status [--since <ref>]',
+    summary: 'Show pending releases and check changed packages for changesets.',
+    help: `Options:
+  --since <ref>          Compare changed files with this git ref (for CI)
+
+Exit status is 2 when a changed package has no changeset added since the comparison base.
+An empty changeset added since the comparison base counts as an explicit no-release decision.`,
+    options: changesetStatusArgs,
+    async run({ values, cwd, configFile, logger }) {
+        const { since } = parseChangesetStatusArgs(values);
+        const result = await getChangesetStatus({
+            cwd,
+            ...(configFile ? { configFile } : {}),
+            ...(since ? { since } : {}),
+        });
+        logger.summary(() => {
+            const rows = result.changedPackages.map((name) => {
+                let status = 'no release requested';
+                if (result.releases.some((release) => release.package.name === name)) {
+                    status = 'changeset found';
+                }
+                if (result.missingChangesets.includes(name)) {
+                    status = 'missing changeset';
+                }
+                return [name, status];
+            });
+            return [
+                '### Changeset status',
+                '',
+                '| Package | Status |',
+                '| --- | --- |',
+                ...rows.map((row) => `| ${row.join(' | ')} |`),
+            ].join('\n');
+        });
+        result.releases.forEach((release) => logger.info(`${release.package.name}: ${release.currentVersion} → ${release.nextVersion} (${release.bump})`));
+        if (result.missingChangesets.length) {
+            result.missingChangesets.forEach((name) => {
+                const file = result.changedPackageFiles[name]?.[0];
+                logger.error(`Changed package "${name}" has no changeset.`, {
+                    file,
+                    title: 'Missing changeset',
+                });
+            });
+        }
+        else if (!result.releases.length) {
+            logger.info('No pending package releases.');
+        }
+        return {
+            exitCode: result.missingChangesets.length ? 2 : 0,
+            result: {
+                ...result,
+                releases: result.releases.map((item) => ({
+                    package: item.package.name,
+                    bump: item.bump,
+                    currentVersion: item.currentVersion,
+                    nextVersion: item.nextVersion,
+                })),
+            },
+        };
+    },
+};

package/dist/commands/changeset-tag.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    name: string;
+    usage: string;
+    summary: string;
+    help: string;
+    options: {
+        readonly push: {
+            readonly type: "boolean";
+        };
+        readonly 'dry-run': {
+            readonly type: "boolean";
+        };
+        readonly 'github-release': {
+            readonly type: "boolean";
+        };
+        readonly since: {
+            readonly type: "string";
+        };
+    };
+    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: import("../changeset-release.ts").ChangesetTagResult;
+    }>;
+};
+export default _default;

package/dist/commands/changeset-tag.js

@@ -0,0 +1,27 @@
+import { tagChangesets } from "../changeset-release.js";
+import { parseChangesetTagArgs, changesetTagArgs } from "./changeset-args.js";
+export default {
+    name: 'changeset-tag',
+    usage: 'changeset-tag [--dry-run] [--since <ref>] [--push] [--github-release]',
+    summary: 'Create missing release tags for configured package versions.',
+    help: `Options:
+  --dry-run              List missing tags without creating them
+  --since <ref>          Tag packages changed since this git ref
+  --push                 Push newly created tags to origin
+  --github-release       Create a GitHub Release for each tag
+
+Tags are created only when absent, and GitHub Releases are created only when
+missing, so rerunning after a partial failure is safe. --github-release also
+requires --push.`,
+    options: changesetTagArgs,
+    async run({ values, cwd, configFile, logger }) {
+        const args = parseChangesetTagArgs(values);
+        const result = await tagChangesets({
+            cwd,
+            ...(configFile ? { configFile } : {}),
+            ...args,
+        });
+        result.tags.forEach((item) => logger.info(`${item.created ? 'Created' : 'Exists'} ${item.tag}`));
+        return { exitCode: 0, result };
+    },
+};

package/dist/commands/changeset-version.d.ts

@@ -0,0 +1,38 @@
+export interface ChangesetVersionResult {
+    date: string;
+    changed: boolean;
+    releases: Array<{
+        package: string;
+        bump: string;
+        currentVersion: string;
+        nextVersion: string;
+    }>;
+}
+declare const _default: {
+    name: string;
+    usage: string;
+    summary: string;
+    help: string;
+    options: {
+        readonly 'dry-run': {
+            readonly type: "boolean";
+        };
+        readonly date: {
+            readonly type: "string";
+        };
+    };
+    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            date: string;
+            changed: boolean;
+            releases: {
+                package: string;
+                bump: "patch" | "minor" | "major";
+                currentVersion: string;
+                nextVersion: string;
+            }[];
+        };
+    }>;
+};
+export default _default;

package/dist/commands/changeset-version.js

@@ -0,0 +1,39 @@
+import { versionChangesets } from "../changeset-release.js";
+import { parseChangesetVersionArgs, changesetVersionArgs, } from "./changeset-args.js";
+export default {
+    name: 'changeset-version',
+    usage: 'changeset-version [--dry-run] [--date <YYYY-MM-DD>]',
+    summary: 'Apply pending version bumps and changelog entries.',
+    help: `Options:
+  --dry-run              Print the release plan without writing files
+  --date <YYYY-MM-DD>    Changelog date (default: today)
+
+Updates configured version files, prepends changelog entries and removes the
+applied changeset files.`,
+    options: changesetVersionArgs,
+    async run({ values, cwd, configFile, logger }) {
+        const args = parseChangesetVersionArgs(values);
+        const result = await versionChangesets({
+            cwd,
+            ...(configFile ? { configFile } : {}),
+            ...args,
+        });
+        result.releases.forEach((release) => logger.info(`${release.package.name}: ${release.currentVersion} → ${release.nextVersion} (${release.bump})`));
+        if (!result.releases.length) {
+            logger.info('No pending package releases.');
+        }
+        return {
+            exitCode: 0,
+            result: {
+                date: result.date,
+                changed: result.changed,
+                releases: result.releases.map((item) => ({
+                    package: item.package.name,
+                    bump: item.bump,
+                    currentVersion: item.currentVersion,
+                    nextVersion: item.nextVersion,
+                })),
+            },
+        };
+    },
+};

package/dist/commands/checksums.js

@@ -3,6 +3,7 @@ import { CHECKSUMS_EXTENSION, createChecksums, writeChecksums, } from "../checks
 import { loadFileRules, resolveFileSelection } from "../file-selection.js";
 import { FILENAME_FORMAT, formatFilename } from "../filename.js";
 import { readPackageMeta } from "../package-meta.js";
+import { getChecksumsSummary } from "../summary.js";
 import { checkDirectory, fileSelectionArgs, getFileSelectionInput, getSourceDirArg, ignoreOwnFile, ignoreOwnSignature, resolveOutput, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
 export default {
@@ -71,6 +72,7 @@ matches the ZIP contents.`,
         await writeChecksums(checksumsPath, manifest, getBoolean(values, 'force'));
         logger.debug(`Hashed ${files} files in ${sourceDir}.`);
         logger.info(checksumsPath);
+        logger.summary((context) => getChecksumsSummary(context, { checksumsPath, files }));
         return { exitCode: 0, result: { checksumsPath, files } };
     },
 };

package/dist/commands/command.d.ts

@@ -11,6 +11,8 @@ export interface CommandContext {
     positionals: string[];
     /** Working directory that relative paths resolve against. */
     cwd: string;
+    /** Explicit JavaScript release config path from --config, if supplied. */
+    configFile?: string;
     /** Logger for the command output. */
     logger: Logger;
 }

package/dist/commands/sign.js

@@ -1,6 +1,7 @@
 import { resolve } from 'node:path';
 import { stat } from 'node:fs/promises';
 import { ValidationError } from "../errors.js";
+import { getSignSummary } from "../summary.js";
 import { SIGNING_KEY_ENV, getPublicKey, parseSigningKey, writeSignature, } from "../signing.js";
 import { getBoolean } from "./command.js";
 export default {
@@ -50,6 +51,7 @@ that belongs to the signing key.`,
             logger.info(signaturePath);
             signatures.push(signaturePath);
         }
+        logger.summary((context) => getSignSummary(context, { signatures, publicKey }));
         return { exitCode: 0, result: { signatures, publicKey } };
     },
 };

package/dist/commands/verify.js

@@ -7,6 +7,8 @@ import { downloadFile, isUrl } from "../download.js";
 import { loadFileRules, parseExclude } from "../file-selection.js";
 import { ValidationError } from "../errors.js";
 import { readPackageMeta } from "../package-meta.js";
+import { logProblems } from "../report.js";
+import { getVerifySummary } from "../summary.js";
 import { extractZip, readZipEntries } from "../unzip.js";
 import { SIGNATURE_EXTENSION, parsePublicKey, verifyFileSignature, } from "../signing.js";
 import { checkDirectory, getSourceDirArg, ignoreOwnFile, ignoreOwnSignature, sourceDirArgs, } from "./args.js";
@@ -199,6 +201,46 @@ async function checkEmbeddedCopies(input) {
             : [],
     };
 }
+/**
+ * Get the problems of a verify run. Changed files and files that aren't in
+ * the checksums are reported on the file. Missing files have no file to
+ * report on.
+ *
+ * @param dir                    Checked directory.
+ * @param result                 Differences between the files and the manifest.
+ * @param result.changed         Changed files.
+ * @param result.missing         Missing files.
+ * @param result.extra           Files that aren't in the checksums.
+ * @param result.versionMismatch Manifest and file versions when they differ.
+ * @return Problems.
+ */
+function getVerifyProblems(dir, result) {
+    const { changed, missing, extra, versionMismatch } = result;
+    return [
+        ...changed.map((file) => ({
+            message: `Changed: ${file}`,
+            file: join(dir, file),
+            title: 'Changed file',
+        })),
+        ...missing.map((file) => ({
+            message: `Missing: ${file}`,
+            title: 'Missing file',
+        })),
+        ...extra.map((file) => ({
+            message: `Not in the checksums: ${file}`,
+            file: join(dir, file),
+            title: 'File not in the checksums',
+        })),
+        ...(versionMismatch
+            ? [
+                {
+                    message: `The checksums are for version ${versionMismatch.manifest}, but the files are version ${versionMismatch.files}.`,
+                    title: 'Version mismatch',
+                },
+            ]
+            : []),
+    ];
+}
 /**
  * Compare the version in the manifest with the Version header of the
  * checked files, so that an older signed release can't pass as a newer one.
@@ -253,25 +295,32 @@ async function verifyTarget(input) {
         !copies.differing.length &&
         !copies.missing.length &&
         !versionMismatch;
-    changed.forEach((file) => logger.error(`Changed: ${file}`));
-    missing.forEach((file) => logger.error(`Missing: ${file}`));
-    extra.forEach((file) => logger.error(`Not in the checksums: ${file}`));
-    if (versionMismatch) {
-        logger.error(`The checksums are for version ${versionMismatch.manifest}, but the files are version ${versionMismatch.files}.`);
-    }
-    logger.info(`${matched.length} files match, ${changed.length} changed, ${missing.length} missing and ${extra.length} extra.`);
-    return {
-        exitCode: valid ? 0 : 2,
-        result: {
-            valid,
+    const counts = `${matched.length} files match, ${changed.length} changed, ${missing.length} missing and ${extra.length} extra.`;
+    if (valid) {
+        logger.summary((context) => getVerifySummary(context, {
             checksumsPath,
             matched: matched.length,
+        }));
+    }
+    else {
+        logProblems(logger, 'wp-release verify', getVerifyProblems(dir, {
             changed,
             missing,
             extra,
             versionMismatch,
-        },
+        }), counts);
+    }
+    logger.info(counts);
+    const result = {
+        valid,
+        checksumsPath,
+        matched: matched.length,
+        changed,
+        missing,
+        extra,
+        versionMismatch,
     };
+    return { exitCode: valid ? 0 : 2, result };
 }
 export default {
     name: 'verify',

package/dist/commands/version-check.js

@@ -2,7 +2,9 @@ import { basename, resolve } from 'node:path';
 import { isTagRef } from "../deploy-options.js";
 import { ValidationError } from "../errors.js";
 import { readPackageMeta } from "../package-meta.js";
-import { GIT_TAG_FORMAT, findVersionMismatches } from "../version-check.js";
+import { GIT_TAG_FORMAT, findVersionMismatches, getVersionMismatchProblems, } from "../version-check.js";
+import { logProblems } from "../report.js";
+import { getVersionCheckSummary } from "../summary.js";
 import { checkDirectory, getSourceDirArg, sourceDirArgs } from "./args.js";
 import { getBoolean, getString, getStrings } from "./command.js";
 /**
@@ -68,9 +70,10 @@ no Stable tag, so it's only checked for plugins.`,
             constants: getStrings(values, 'constant'),
             stableTag: !getBoolean(values, 'no-stable-tag'),
         });
-        mismatches.forEach((mismatch) => logger.error(mismatch.message));
+        logProblems(logger, 'wp-release version-check', getVersionMismatchProblems(sourceDir, mismatches));
         if (!mismatches.length) {
             logger.info(`All versions match ${version}.`);
+            logger.summary(() => getVersionCheckSummary(version));
         }
         return {
             exitCode: mismatches.length ? 2 : 0,

package/dist/commands/zip.js

@@ -5,6 +5,7 @@ import { ValidationError } from "../errors.js";
 import { loadFileRules, resolveFileSelection, selectFiles, } from "../file-selection.js";
 import { FILENAME_FORMAT, formatFilename } from "../filename.js";
 import { readPackageMeta } from "../package-meta.js";
+import { getZipSummary } from "../summary.js";
 import { createZip } from "../zip.js";
 import { checkDirectory, fileSelectionArgs, getFileSelectionInput, getSourceDirArg, ignoreOwnFile, ignoreOwnSignature, resolveOutput, sourceDirArgs, } from "./args.js";
 import { getBoolean, getString } from "./command.js";
@@ -126,13 +127,12 @@ always give the same ZIP.`,
             await writeChecksums(checksumsPath, manifest, force);
             logger.info(checksumsPath);
         }
-        return {
-            exitCode: 0,
-            result: {
-                zipPath,
-                ...(checksumsPath ? { checksumsPath } : {}),
-                files: files.length,
-            },
+        const result = {
+            zipPath,
+            ...(checksumsPath ? { checksumsPath } : {}),
+            files: files.length,
         };
+        logger.summary((context) => getZipSummary(context, result));
+        return { exitCode: 0, result };
     },
 };

package/dist/errors.d.ts

@@ -1,9 +1,27 @@
+/**
+ * One failed check, with the file and line it's about when there is one.
+ */
+export interface Problem {
+    /** Description of the problem. */
+    message: string;
+    /** File the problem is in, absolute or relative to the working directory. */
+    file?: string | null;
+    /** Line in the file, starting at 1. */
+    line?: number | null;
+    /** Short title of the kind of problem, like "Version mismatch". */
+    title?: string;
+}
 /**
  * Invalid options or failed release checks, reported with exit code 2.
+ * Failed checks can list their problems, so that each one is reported on its
+ * own file and line.
  */
 export declare class ValidationError extends Error {
     name: string;
     exitCode: number;
+    /** Each failed check, empty when the message is all there is. */
+    readonly problems: Problem[];
+    constructor(message: string, problems?: Problem[]);
 }
 /**
  * Missing SVN credentials or a failed login or permission check, reported

package/dist/errors.js

@@ -1,9 +1,17 @@
 /**
  * Invalid options or failed release checks, reported with exit code 2.
+ * Failed checks can list their problems, so that each one is reported on its
+ * own file and line.
  */
 export class ValidationError extends Error {
     name = 'ValidationError';
     exitCode = 2;
+    /** Each failed check, empty when the message is all there is. */
+    problems;
+    constructor(message, problems = []) {
+        super(message);
+        this.problems = problems;
+    }
 }
 /**
  * Missing SVN credentials or a failed login or permission check, reported

package/dist/github-actions-writer.d.ts

@@ -0,0 +1,52 @@
+import type { Annotation, LogEntry, LogWriter, OutputStream, SummaryBuilder } from './logger.ts';
+export interface GitHubActionsWriterOptions {
+    /** Stream for regular output. */
+    stdout?: OutputStream;
+    /** Stream for warnings and errors. */
+    stderr?: OutputStream;
+    /**
+     * Directory that annotation and summary paths are relative to, defaults
+     * to GITHUB_WORKSPACE or the working directory.
+     */
+    workspace?: string;
+    /**
+     * File that summaries are appended to, defaults to GITHUB_STEP_SUMMARY.
+     * Null turns summaries off.
+     */
+    summaryPath?: string | null;
+}
+/**
+ * Writer that prints GitHub Actions workflow commands, so that notices,
+ * warnings and errors are annotations on the run and on the files they're
+ * about, and appends summaries to the job summary.
+ */
+export declare class GitHubActionsWriter implements LogWriter {
+    readonly stdout: OutputStream;
+    readonly stderr: OutputStream;
+    readonly workspace: string;
+    readonly summaryPath: string | null;
+    constructor({ stdout, stderr, workspace, summaryPath, }?: GitHubActionsWriterOptions);
+    write({ level, message, annotation }: LogEntry): void;
+    startGroup(title: string): void;
+    endGroup(): void;
+    summary(build: SummaryBuilder): void;
+    /**
+     * Format a workflow command like
+     * "::error file=my-plugin.php,line=3,title=Version mismatch::message".
+     *
+     * @param name       Command name.
+     * @param message    Message.
+     * @param annotation File, line and title of the annotation.
+     * @return Workflow command with a line break.
+     */
+    formatCommand(name: string, message: string, annotation?: Annotation): string;
+    /**
+     * Get the path of an annotation file relative to the workspace. GitHub
+     * only links files of the repository, so files outside the workspace,
+     * like an extracted ZIP in a temporary directory, get no file.
+     *
+     * @param file File path, absolute or relative to the working directory.
+     * @return Path with forward slashes, or null when it's outside the workspace.
+     */
+    getAnnotationFile(file?: string | null): string | null;
+}