@celonis/content-cli 1.13.1 → 1.14.0

package/commands/configuration-management/branch/branch-export-import.command.service.js

@@ -0,0 +1,276 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "node:fs", "node:os", "node:path", "uuid", "adm-zip", "node:path", "../../../core/utils/file-service", "../../../core/utils/logger", "../../../core/git-profile/git/git.service", "../api/single-package-export-api", "../api/single-package-import-api", "../single-package-import.service", "./api/branch.api", "../../../core/utils/branches"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BranchExportImportCommandService = void 0;
+    const fs = require("node:fs");
+    const os = require("node:os");
+    const path = require("node:path");
+    const uuid_1 = require("uuid");
+    const AdmZip = require("adm-zip");
+    const node_path_1 = require("node:path");
+    const file_service_1 = require("../../../core/utils/file-service");
+    const logger_1 = require("../../../core/utils/logger");
+    const git_service_1 = require("../../../core/git-profile/git/git.service");
+    const single_package_export_api_1 = require("../api/single-package-export-api");
+    const single_package_import_api_1 = require("../api/single-package-import-api");
+    const single_package_import_service_1 = require("../single-package-import.service");
+    const branch_api_1 = require("./api/branch.api");
+    const branches_1 = require("../../../core/utils/branches");
+    const PACKAGE_FILE = "package.json";
+    class BranchExportImportCommandService {
+        constructor(context) {
+            this.singlePackageExportApi = new single_package_export_api_1.SinglePackageExportApi(context);
+            this.singlePackageImportApi = new single_package_import_api_1.SinglePackageImportApi(context);
+            this.branchApi = new branch_api_1.BranchApi(context);
+            this.gitService = new git_service_1.GitService(context);
+        }
+        exportBranch(packageKey, branchKey, options = {}) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const jsonResponse = !!options.jsonResponse;
+                if (options.gitEnabled) {
+                    const pushedKey = yield this.pushBranchToGit(packageKey, branchKey);
+                    if (jsonResponse) {
+                        BranchExportImportCommandService.writeJson({ packageKey: pushedKey, branchName: branchKey });
+                    }
+                    else {
+                        logger_1.logger.info(`Exported ${pushedKey} to Git branch '${branchKey}'.`);
+                    }
+                    return;
+                }
+                const branchPackageKey = branches_1.BranchUtils.constructBranchKey(packageKey, branchKey);
+                const sourceDir = yield this.exportRewrittenPackageDir(branchPackageKey);
+                try {
+                    const message = this.writeLocalArtifact(sourceDir, packageKey, !!options.zip);
+                    if (jsonResponse) {
+                        BranchExportImportCommandService.writeJson({ packageKey: branchPackageKey, branchName: branchKey });
+                    }
+                    else {
+                        logger_1.logger.info(message);
+                    }
+                }
+                finally {
+                    this.removeDir(sourceDir);
+                }
+            });
+        }
+        exportAll(packageKey, jsonResponse = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const mainKey = branches_1.BranchUtils.extractProjectKey(packageKey);
+                const branches = yield this.branchApi.listBranches(mainKey);
+                const synced = [];
+                yield this.pushMainPackage(mainKey);
+                synced.push(mainKey);
+                // listBranches also reports the main package itself, whose packageKey carries no
+                // branch suffix. It is already pushed above, and it has no '<mainKey>@<branchKey>'
+                // package to export, so exporting it as a branch would fail. A branch keyed 'main'
+                // is skipped as well: it would push over the main package's mirror above.
+                for (const branch of branches.filter(entry => BranchExportImportCommandService.isExportableBranch(entry))) {
+                    const pushedKey = yield this.pushBranchToGit(mainKey, branch.branchKey);
+                    synced.push(pushedKey);
+                    if (!jsonResponse) {
+                        logger_1.logger.info(`Exported ${pushedKey} to Git branch '${branch.branchKey}'.`);
+                    }
+                }
+                const summary = { packageKey: mainKey, branchName: branches_1.BranchUtils.MAIN_BRANCH_KEY, synced };
+                if (jsonResponse) {
+                    BranchExportImportCommandService.writeJson(summary);
+                }
+                else {
+                    logger_1.logger.info(`Exported Git mirror for ${mainKey}: ${synced.length} package(s) pushed.`);
+                }
+            });
+        }
+        importBranch(packageKey, branchKey, options = {}) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchPackageKey = branches_1.BranchUtils.constructBranchKey(packageKey, branchKey);
+                const workingDir = options.gitEnabled
+                    ? yield this.gitService.pullFromBranch(branchKey)
+                    : this.prepareLocalWorkingDir(options.file, options.directory);
+                try {
+                    this.restoreBranchKey(workingDir, packageKey, branchPackageKey);
+                    yield this.importPackageSourceDir(workingDir, !!options.overwrite);
+                    if (options.jsonResponse) {
+                        BranchExportImportCommandService.writeJson({ packageKey: branchPackageKey, branchName: branchKey });
+                    }
+                    else {
+                        const origin = options.gitEnabled ? `Git branch '${branchKey}'` : ((_a = options.file) !== null && _a !== void 0 ? _a : options.directory);
+                        logger_1.logger.info(`Imported ${origin} into ${branchPackageKey}.`);
+                    }
+                }
+                finally {
+                    this.removeDir(workingDir);
+                }
+            });
+        }
+        pushBranchToGit(mainKey, branchKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchPackageKey = branches_1.BranchUtils.constructBranchKey(mainKey, branchKey);
+                const sourceDir = yield this.exportRewrittenPackageDir(branchPackageKey);
+                try {
+                    yield this.gitService.pushToBranch(sourceDir, branchKey);
+                    return branchPackageKey;
+                }
+                finally {
+                    this.removeDir(sourceDir);
+                }
+            });
+        }
+        pushMainPackage(mainKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const packageData = yield this.singlePackageExportApi.exportPackage(mainKey);
+                const extractedDir = file_service_1.fileService.extractZipBufferToTempDirectory(packageData);
+                try {
+                    yield this.gitService.pushToBranch(extractedDir, branches_1.BranchUtils.MAIN_BRANCH_KEY);
+                }
+                finally {
+                    this.removeDir(extractedDir);
+                }
+            });
+        }
+        exportRewrittenPackageDir(branchPackageKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const packageData = yield this.singlePackageExportApi.exportPackage(branchPackageKey);
+                const extractedDir = file_service_1.fileService.extractZipBufferToTempDirectory(packageData);
+                const projectKey = branches_1.BranchUtils.extractProjectKey(branchPackageKey);
+                this.normalizeToProjectKey(extractedDir, branchPackageKey, projectKey);
+                return extractedDir;
+            });
+        }
+        writeLocalArtifact(sourceDir, packageKey, zip) {
+            if (zip) {
+                const zipPath = file_service_1.fileService.zipDirectoryAsSinglePackage(sourceDir);
+                try {
+                    const fileName = `${packageKey}.zip`;
+                    file_service_1.fileService.writeBufferToFileWithGivenName(fs.readFileSync(zipPath), (0, node_path_1.resolve)(process.cwd(), fileName));
+                    return file_service_1.FileService.fileDownloadedMessage + fileName;
+                }
+                finally {
+                    fs.rmSync(zipPath, { force: true });
+                }
+            }
+            const targetDir = (0, node_path_1.resolve)(process.cwd(), packageKey);
+            fs.rmSync(targetDir, { recursive: true, force: true });
+            fs.cpSync(sourceDir, targetDir, { recursive: true });
+            return `Successful export. Exported directory: ${packageKey}`;
+        }
+        prepareLocalWorkingDir(file, directory) {
+            const workingDir = fs.mkdtempSync(path.join(os.tmpdir(), "content-cli-"));
+            if (directory) {
+                if (!file_service_1.fileService.isDirectory(directory)) {
+                    fs.rmSync(workingDir, { recursive: true, force: true });
+                    throw new logger_1.FatalError("The --directory option accepts only directories.");
+                }
+                fs.cpSync(directory, workingDir, { recursive: true });
+                return workingDir;
+            }
+            if (file_service_1.fileService.isDirectory(file)) {
+                fs.rmSync(workingDir, { recursive: true, force: true });
+                throw new logger_1.FatalError("The --file option accepts only zip files.");
+            }
+            const packageZip = new AdmZip(file);
+            try {
+                single_package_import_service_1.SinglePackageImportService.assertUncompressedSizeWithinLimit(packageZip, file);
+                packageZip.extractAllTo(workingDir, true);
+            }
+            catch (error) {
+                fs.rmSync(workingDir, { recursive: true, force: true });
+                throw error;
+            }
+            return workingDir;
+        }
+        importPackageSourceDir(sourceDir, overwrite) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const zipPath = file_service_1.fileService.zipDirectoryAsSinglePackage(sourceDir);
+                try {
+                    const formData = single_package_import_service_1.SinglePackageImportService.buildBodyForImport(new AdmZip(zipPath), zipPath);
+                    yield this.singlePackageImportApi.importPackage(formData, overwrite);
+                }
+                finally {
+                    fs.rmSync(zipPath, { force: true });
+                }
+            });
+        }
+        // The export source is a fresh Pacman export of the branch package, so a key that does not
+        // match is a no-op rather than a failure: the worst case is a mirror diff that still carries
+        // the branch suffix, and nothing outside the local working copy is touched.
+        normalizeToProjectKey(dir, from, to) {
+            if (from === to) {
+                return;
+            }
+            const filePath = path.join(dir, PACKAGE_FILE);
+            if (!fs.existsSync(filePath)) {
+                return;
+            }
+            const raw = fs.readFileSync(filePath, { encoding: "utf-8" });
+            const json = JSON.parse(raw);
+            if (json.key !== from) {
+                return;
+            }
+            const updated = this.replaceFieldValue(raw, "key", from, to);
+            if (updated !== raw) {
+                fs.writeFileSync(filePath, updated, { encoding: "utf-8" });
+            }
+        }
+        // The import source is caller-supplied and the import endpoint derives the target package
+        // solely from package.json#key, so a key that is neither the project key nor the branch key
+        // must abort rather than silently import into whatever package the source names.
+        restoreBranchKey(dir, projectKey, branchPackageKey) {
+            const filePath = path.join(dir, PACKAGE_FILE);
+            if (!fs.existsSync(filePath)) {
+                throw new logger_1.FatalError(`The import source does not contain a ${PACKAGE_FILE} file.`);
+            }
+            const raw = fs.readFileSync(filePath, { encoding: "utf-8" });
+            const sourceKey = JSON.parse(raw).key;
+            if (sourceKey === branchPackageKey) {
+                return;
+            }
+            if (sourceKey !== projectKey) {
+                throw new logger_1.FatalError(`The import source declares package key '${sourceKey}', but importing into '${branchPackageKey}' requires '${projectKey}' or '${branchPackageKey}'. Nothing was imported.`);
+            }
+            const updated = this.replaceFieldValue(raw, "key", projectKey, branchPackageKey);
+            if (updated === raw) {
+                throw new logger_1.FatalError(`Could not rewrite the package key in ${PACKAGE_FILE} from '${projectKey}' to '${branchPackageKey}'. Nothing was imported.`);
+            }
+            fs.writeFileSync(filePath, updated, { encoding: "utf-8" });
+        }
+        replaceFieldValue(content, field, from, to) {
+            const pattern = new RegExp(String.raw `("${this.escapeRegExp(field)}"\s*:\s*)"${this.escapeRegExp(from)}"`);
+            return content.replace(pattern, `$1"${to}"`);
+        }
+        escapeRegExp(value) {
+            return value.replace(/[.*+?^${}()|[\]\\]/g, match => "\\" + match);
+        }
+        removeDir(dir) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        static isExportableBranch(branch) {
+            var _a;
+            return branches_1.BranchUtils.isBranchPackageKey(branch.packageKey)
+                && ((_a = branch.branchKey) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== branches_1.BranchUtils.MAIN_BRANCH_KEY;
+        }
+        static writeJson(payload) {
+            const filename = `${(0, uuid_1.v4)()}.json`;
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(payload, null, 2), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+    }
+    exports.BranchExportImportCommandService = BranchExportImportCommandService;
+});

package/commands/configuration-management/branch/branch.command.service.js

@@ -0,0 +1,178 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "uuid", "../../../core/utils/file-service", "../../../core/utils/logger", "./api/branch.api", "./interfaces/branch.interfaces"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BranchCommandService = void 0;
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../../../core/utils/file-service");
+    const logger_1 = require("../../../core/utils/logger");
+    const branch_api_1 = require("./api/branch.api");
+    const branch_interfaces_1 = require("./interfaces/branch.interfaces");
+    class BranchCommandService {
+        constructor(context) {
+            this.branchApi = new branch_api_1.BranchApi(context);
+        }
+        setBranchingEnabled(packageKey, enabled, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const transport = { branchingEnabled: enabled };
+                const result = yield this.branchApi.configureBranchingSettings(packageKey, transport);
+                if (jsonResponse) {
+                    BranchCommandService.writeJson(result);
+                }
+                else {
+                    logger_1.logger.info(`Branching ${result.branchingEnabled ? "enabled" : "disabled"} for package ${packageKey}.`);
+                }
+                return result;
+            });
+        }
+        createBranch(packageKey, branchKey, sourceVersion, validate, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const transport = { branchKey, version: sourceVersion };
+                const result = yield this.branchApi.createBranch(packageKey, transport, validate);
+                if (validate) {
+                    logger_1.logger.info(`Validation successful for branch '${branchKey}' from ${packageKey}@${sourceVersion}.`);
+                    return;
+                }
+                if (jsonResponse) {
+                    BranchCommandService.writeJson(result);
+                }
+                else if (result) {
+                    BranchCommandService.printBranch(result);
+                }
+                return result;
+            });
+        }
+        listBranches(packageKey, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branches = yield this.branchApi.listBranches(packageKey);
+                if (jsonResponse) {
+                    BranchCommandService.writeJson(branches);
+                }
+                else if (branches.length === 0) {
+                    logger_1.logger.info(`No branches found for ${packageKey}.`);
+                }
+                else {
+                    branches.forEach(branch => {
+                        logger_1.logger.info(`${branch.branchKey} (package: ${branch.packageKey}, source: ${branch.sourcePackageKey}@${branch.sourceVersion})`);
+                    });
+                }
+                return branches;
+            });
+        }
+        deleteBranch(packageKey, branchKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchPackageKey = `${packageKey}@${branchKey}`;
+                yield this.branchApi.deleteBranch(branchPackageKey);
+                logger_1.logger.info(`Branch ${branchPackageKey} deleted.`);
+            });
+        }
+        mergePreview(targetPackageKey, sourceKey, sourceVersion, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const transport = { sourceKey, sourceVersion };
+                const preview = yield this.branchApi.mergePreview(targetPackageKey, transport);
+                if (jsonResponse) {
+                    BranchCommandService.writeJson(preview);
+                }
+                else {
+                    BranchCommandService.printPreviewSummary(targetPackageKey, sourceKey, sourceVersion, preview);
+                }
+                return preview;
+            });
+        }
+        mergeApply(targetPackageKey, options) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const rawBody = options.file
+                    ? JSON.parse(file_service_1.fileService.readFile(options.file))
+                    : {};
+                const effectiveSourceKey = (_a = options.sourceKey) !== null && _a !== void 0 ? _a : rawBody.sourceKey;
+                const effectiveSourceVersion = (_b = options.sourceVersion) !== null && _b !== void 0 ? _b : rawBody.sourceVersion;
+                const versionCreate = BranchCommandService.buildVersionCreate(rawBody.versionCreate, options.bump, options.version, options.summary, effectiveSourceKey, effectiveSourceVersion);
+                const transport = Object.assign(Object.assign({}, rawBody), { sourceKey: effectiveSourceKey, sourceVersion: effectiveSourceVersion, versionCreate });
+                const result = yield this.branchApi.merge(targetPackageKey, transport);
+                if (options.jsonResponse) {
+                    BranchCommandService.writeJson(result);
+                }
+                else {
+                    logger_1.logger.info(`Merge applied: published ${result.packageKey}@${result.version} from ${effectiveSourceKey}@${effectiveSourceVersion}.`);
+                }
+                return result;
+            });
+        }
+        static buildVersionCreate(fromFile, flagBump, flagVersion, flagSummary, sourceKey, sourceVersion) {
+            const versionCreate = fromFile ? Object.assign({}, fromFile) : {};
+            if (flagVersion !== undefined) {
+                versionCreate.version = flagVersion;
+                versionCreate.versionBumpOption = undefined;
+            }
+            else if (flagBump !== undefined) {
+                versionCreate.versionBumpOption = flagBump.toUpperCase();
+                versionCreate.version = undefined;
+            }
+            else if (!versionCreate.version && !versionCreate.versionBumpOption) {
+                versionCreate.versionBumpOption = branch_interfaces_1.VersionBumpOption.PATCH;
+            }
+            if (flagSummary !== undefined) {
+                versionCreate.summaryOfChanges = flagSummary;
+            }
+            else if (!versionCreate.summaryOfChanges && sourceKey && sourceVersion) {
+                versionCreate.summaryOfChanges = `Merge ${sourceKey}@${sourceVersion}`;
+            }
+            return versionCreate;
+        }
+        static writeJson(payload) {
+            const filename = `${(0, uuid_1.v4)()}.json`;
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(payload, null, 2), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+        static printBranch(branch) {
+            logger_1.logger.info(`Main Package Key: ${branch.projectKey}`);
+            logger_1.logger.info(`Branch Key: ${branch.branchKey}`);
+            logger_1.logger.info(`Package Key: ${branch.packageKey}`);
+            logger_1.logger.info(`Source Package Key: ${branch.sourcePackageKey}`);
+            logger_1.logger.info(`Source Version: ${branch.sourceVersion}`);
+        }
+        static printPreviewSummary(targetPackageKey, sourceKey, sourceVersion, preview) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            logger_1.logger.info(`Preview: merge ${sourceKey}@${sourceVersion} into ${targetPackageKey}`);
+            logger_1.logger.info(`Common ancestor: ${preview.commonPackageKey}@${preview.commonVersion}`);
+            const totalNodes = (_b = (_a = preview.nodeChanges) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+            const packageConflictPaths = BranchCommandService.countConflictPaths((_c = preview.packageChanges) === null || _c === void 0 ? void 0 : _c.changes);
+            const nodeConflictPaths = (_e = (_d = preview.nodeChanges) === null || _d === void 0 ? void 0 : _d.reduce((sum, node) => sum + BranchCommandService.countConflictPaths(node.changes), 0)) !== null && _e !== void 0 ? _e : 0;
+            const conflicts = packageConflictPaths + nodeConflictPaths;
+            const nodesNeedingResolution = (_g = (_f = preview.nodeChanges) === null || _f === void 0 ? void 0 : _f.filter(node => BranchCommandService.isInConflict(node.changes)).length) !== null && _g !== void 0 ? _g : 0;
+            logger_1.logger.info(`Nodes touched: ${totalNodes}, conflicting paths: ${conflicts}, nodes needing resolution: ${nodesNeedingResolution}.`);
+            if (BranchCommandService.isInConflict((_h = preview.packageChanges) === null || _h === void 0 ? void 0 : _h.changes)) {
+                logger_1.logger.info("The package's own configuration or metadata is in conflict. Supply 'resolvedPackageConflict' before applying.");
+            }
+            if (nodesNeedingResolution > 0 && nodeConflictPaths === 0) {
+                logger_1.logger.info("The conflicts above are structural (a node exists on one side only), so no path-level diff is reported. Supply a resolution for each node before applying.");
+            }
+        }
+        static countConflictPaths(changes) {
+            var _a, _b, _c, _d, _e, _f;
+            return ((_c = (_b = (_a = changes === null || changes === void 0 ? void 0 : changes.configuration) === null || _a === void 0 ? void 0 : _a.conflicts) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) + ((_f = (_e = (_d = changes === null || changes === void 0 ? void 0 : changes.metadata) === null || _d === void 0 ? void 0 : _d.conflicts) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0);
+        }
+        static isInConflict(changes) {
+            var _a, _b;
+            return ((_a = changes === null || changes === void 0 ? void 0 : changes.configuration) === null || _a === void 0 ? void 0 : _a.status) === branch_interfaces_1.MergeStatus.CONFLICT || ((_b = changes === null || changes === void 0 ? void 0 : changes.metadata) === null || _b === void 0 ? void 0 : _b.status) === branch_interfaces_1.MergeStatus.CONFLICT;
+        }
+    }
+    exports.BranchCommandService = BranchCommandService;
+});

package/commands/configuration-management/branch/interfaces/branch.interfaces.js

@@ -0,0 +1,41 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VersionBumpOption = exports.ChangeType = exports.MergeStatus = exports.MergeResolution = void 0;
+    var MergeResolution;
+    (function (MergeResolution) {
+        MergeResolution["CUSTOM"] = "CUSTOM";
+        MergeResolution["ACCEPT_SOURCE"] = "ACCEPT_SOURCE";
+        MergeResolution["ACCEPT_TARGET"] = "ACCEPT_TARGET";
+    })(MergeResolution || (exports.MergeResolution = MergeResolution = {}));
+    var MergeStatus;
+    (function (MergeStatus) {
+        MergeStatus["UNKNOWN"] = "UNKNOWN";
+        MergeStatus["UNCHANGED"] = "UNCHANGED";
+        MergeStatus["SOURCE_ONLY"] = "SOURCE_ONLY";
+        MergeStatus["TARGET_ONLY"] = "TARGET_ONLY";
+        MergeStatus["AUTO_MERGE"] = "AUTO_MERGE";
+        MergeStatus["CONFLICT"] = "CONFLICT";
+    })(MergeStatus || (exports.MergeStatus = MergeStatus = {}));
+    var ChangeType;
+    (function (ChangeType) {
+        ChangeType["UNKNOWN"] = "UNKNOWN";
+        ChangeType["ADDED"] = "ADDED";
+        ChangeType["DELETED"] = "DELETED";
+        ChangeType["CHANGED"] = "CHANGED";
+        ChangeType["UNCHANGED"] = "UNCHANGED";
+    })(ChangeType || (exports.ChangeType = ChangeType = {}));
+    var VersionBumpOption;
+    (function (VersionBumpOption) {
+        VersionBumpOption["NONE"] = "NONE";
+        VersionBumpOption["PATCH"] = "PATCH";
+    })(VersionBumpOption || (exports.VersionBumpOption = VersionBumpOption = {}));
+});