release-please 12.3.0 → 13.0.0-candidate.0

package/build/src/util/pull-request-title.js

@@ -14,6 +14,8 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PullRequestTitle = exports.generateMatchPattern = void 0;
+const logger_1 = require("./logger");
+const version_1 = require("../version");
 // cannot import from '..' - transpiled code references to RELEASE_PLEASE
 // at the script level are undefined, they are only defined inside function
 // or instance methods/properties.
@@ -21,17 +23,18 @@ const DEFAULT_PR_TITLE_PATTERN = 'chore${scope}: release${component} ${version}'
 function generateMatchPattern(pullRequestTitlePattern) {
     if (pullRequestTitlePattern &&
         pullRequestTitlePattern.search(/\$\{scope\}/) === -1)
-        throw Error("pullRequestTitlePattern miss the part of '${scope}'");
+        logger_1.logger.warn("pullRequestTitlePattern miss the part of '${scope}'");
     if (pullRequestTitlePattern &&
         pullRequestTitlePattern.search(/\$\{component\}/) === -1)
-        throw Error("pullRequestTitlePattern miss the part of '${component}'");
+        logger_1.logger.warn("pullRequestTitlePattern miss the part of '${component}'");
     if (pullRequestTitlePattern &&
         pullRequestTitlePattern.search(/\$\{version\}/) === -1)
-        throw Error("pullRequestTitlePattern miss the part of '${version}'");
+        logger_1.logger.warn("pullRequestTitlePattern miss the part of '${version}'");
     return new RegExp(`^${(pullRequestTitlePattern || DEFAULT_PR_TITLE_PATTERN)
         .replace('${scope}', '(\\((?<branch>[\\w-.]+)\\))?')
         .replace('${component}', ' ?(?<component>[\\w-.]*)?')
-        .replace('${version}', 'v?(?<version>[0-9].*)')}$`);
+        .replace('${version}', 'v?(?<version>[0-9].*)')
+        .replace('${branch}', '(?<branch>[\\w-.]+)?')}$`);
 }
 exports.generateMatchPattern = generateMatchPattern;
 class PullRequestTitle {
@@ -48,7 +51,9 @@ class PullRequestTitle {
         const match = title.match(matchPattern);
         if (match === null || match === void 0 ? void 0 : match.groups) {
             return new PullRequestTitle({
-                version: match.groups['version'],
+                version: match.groups['version']
+                    ? version_1.Version.parse(match.groups['version'])
+                    : undefined,
                 component: match.groups['component'],
                 targetBranch: match.groups['branch'],
                 pullRequestTitlePattern: pullRequestTitlePattern,
@@ -77,6 +82,12 @@ class PullRequestTitle {
             pullRequestTitlePattern,
         });
     }
+    static ofTargetBranch(targetBranch, pullRequestTitlePattern) {
+        return new PullRequestTitle({
+            targetBranch,
+            pullRequestTitlePattern,
+        });
+    }
     getTargetBranch() {
         return this.targetBranch;
     }
@@ -87,12 +98,15 @@ class PullRequestTitle {
         return this.version;
     }
     toString() {
+        var _a;
         const scope = this.targetBranch ? `(${this.targetBranch})` : '';
         const component = this.component ? ` ${this.component}` : '';
+        const version = (_a = this.version) !== null && _a !== void 0 ? _a : '';
         return this.pullRequestTitlePattern
             .replace('${scope}', scope)
             .replace('${component}', component)
-            .replace('${version}', this.getVersion());
+            .replace('${version}', version.toString())
+            .trim();
     }
 }
 exports.PullRequestTitle = PullRequestTitle;

package/build/src/util/tag-name.d.ts

@@ -0,0 +1,9 @@
+import { Version } from '../version';
+export declare class TagName {
+    component?: string;
+    version: Version;
+    separator: string;
+    constructor(version: Version, component?: string, separator?: string);
+    static parse(tagName: string): TagName | undefined;
+    toString(): string;
+}

package/build/src/util/tag-name.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagName = void 0;
+const version_1 = require("../version");
+const TAG_PATTERN = /^((?<component>.*)(?<separator>[^a-zA-Z]))?v(?<version>\d+\.\d+\.\d+.*)$/;
+const DEFAULT_SEPARATOR = '-';
+class TagName {
+    constructor(version, component, separator = DEFAULT_SEPARATOR) {
+        this.version = version;
+        this.component = component;
+        this.separator = separator;
+    }
+    static parse(tagName) {
+        const match = tagName.match(TAG_PATTERN);
+        if (match === null || match === void 0 ? void 0 : match.groups) {
+            return new TagName(version_1.Version.parse(match.groups.version), match.groups.component, match.groups.separator);
+        }
+        return;
+    }
+    toString() {
+        if (this.component) {
+            return `${this.component}${this.separator}v${this.version.toString()}`;
+        }
+        return `v${this.version.toString()}`;
+    }
+}
+exports.TagName = TagName;
+//# sourceMappingURL=tag-name.js.map

package/build/src/version.d.ts

@@ -0,0 +1,11 @@
+export declare class Version {
+    major: number;
+    minor: number;
+    patch: number;
+    preRelease?: string;
+    build?: string;
+    constructor(major: number, minor: number, patch: number, preRelease?: string, build?: string);
+    static parse(versionString: string): Version;
+    toString(): string;
+}
+export declare type VersionsMap = Map<string, Version>;

package/build/src/version.js

@@ -0,0 +1,45 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+const VERSION_REGEX = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(-(?<preRelease>[^+]+))?(\+(?<build>.*))?/;
+class Version {
+    constructor(major, minor, patch, preRelease, build) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.preRelease = preRelease;
+        this.build = build;
+    }
+    static parse(versionString) {
+        const match = versionString.match(VERSION_REGEX);
+        if (!(match === null || match === void 0 ? void 0 : match.groups)) {
+            throw Error(`unable to parse version string: ${versionString}`);
+        }
+        const major = Number(match.groups.major);
+        const minor = Number(match.groups.minor);
+        const patch = Number(match.groups.patch);
+        const preRelease = match.groups.preRelease;
+        const build = match.groups.build;
+        return new Version(major, minor, patch, preRelease, build);
+    }
+    toString() {
+        const preReleasePart = this.preRelease ? `-${this.preRelease}` : '';
+        const buildPart = this.build ? `+${this.build}` : '';
+        return `${this.major}.${this.minor}.${this.patch}${preReleasePart}${buildPart}`;
+    }
+}
+exports.Version = Version;
+//# sourceMappingURL=version.js.map

package/build/src/versioning-strategies/always-bump-patch.d.ts

@@ -0,0 +1,7 @@
+import { Version } from '../version';
+import { ConventionalCommit } from '../commit';
+import { DefaultVersioningStrategy } from './default';
+import { VersionUpdater } from '../versioning-strategy';
+export declare class AlwaysBumpPatch extends DefaultVersioningStrategy {
+    determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
+}

package/build/src/{updaters/package-lock-json.js → versioning-strategies/always-bump-patch.js}

@@ -13,16 +13,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackageLockJson = void 0;
-const package_json_1 = require("./package-json");
-class PackageLockJson extends package_json_1.PackageJson {
-    updateVersion(parsed) {
-        super.updateVersion(parsed);
-        if (parsed.lockfileVersion === 2) {
-            const lockFileV2 = parsed;
-            lockFileV2.packages[''].version = this.version;
-        }
+exports.AlwaysBumpPatch = void 0;
+const default_1 = require("./default");
+const versioning_strategy_1 = require("../versioning-strategy");
+class AlwaysBumpPatch extends default_1.DefaultVersioningStrategy {
+    determineReleaseType(_version, _commits) {
+        return new versioning_strategy_1.PatchVersionUpdate();
     }
 }
-exports.PackageLockJson = PackageLockJson;
-//# sourceMappingURL=package-lock-json.js.map
+exports.AlwaysBumpPatch = AlwaysBumpPatch;
+//# sourceMappingURL=always-bump-patch.js.map

package/build/src/versioning-strategies/default.d.ts

@@ -0,0 +1,15 @@
+import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
+import { ConventionalCommit } from '../commit';
+import { Version } from '../version';
+interface DefaultVersioningStrategyOptions {
+    bumpMinorPreMajor?: boolean;
+    bumpPatchForMinorPreMajor?: boolean;
+}
+export declare class DefaultVersioningStrategy implements VersioningStrategy {
+    readonly bumpMinorPreMajor: boolean;
+    readonly bumpPatchForMinorPreMajor: boolean;
+    constructor(options?: DefaultVersioningStrategyOptions);
+    determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+    bump(version: Version, commits: ConventionalCommit[]): Version;
+}
+export {};

package/build/src/versioning-strategies/default.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultVersioningStrategy = void 0;
+const versioning_strategy_1 = require("../versioning-strategy");
+const version_1 = require("../version");
+class DefaultVersioningStrategy {
+    constructor(options = {}) {
+        this.bumpMinorPreMajor = options.bumpMinorPreMajor === true;
+        this.bumpPatchForMinorPreMajor = options.bumpPatchForMinorPreMajor === true;
+    }
+    determineReleaseType(version, commits) {
+        // iterate through list of commits and find biggest commit type
+        let breaking = 0;
+        let features = 0;
+        let customVersion;
+        for (const commit of commits) {
+            const releaseAs = commit.notes.find(note => note.title === 'RELEASE AS');
+            if (releaseAs) {
+                customVersion = version_1.Version.parse(releaseAs.text);
+            }
+            if (commit.breaking) {
+                breaking++;
+            }
+            else if (commit.type === 'feat' || commit.type === 'feature') {
+                features++;
+            }
+        }
+        if (customVersion) {
+            return new versioning_strategy_1.CustomVersionUpdate(customVersion.toString());
+        }
+        if (breaking > 0) {
+            if (version.major < 1 && this.bumpMinorPreMajor) {
+                return new versioning_strategy_1.MinorVersionUpdate();
+            }
+            else {
+                return new versioning_strategy_1.MajorVersionUpdate();
+            }
+        }
+        else if (features > 0) {
+            if (version.major < 1 && this.bumpPatchForMinorPreMajor) {
+                return new versioning_strategy_1.PatchVersionUpdate();
+            }
+            else {
+                return new versioning_strategy_1.MinorVersionUpdate();
+            }
+        }
+        return new versioning_strategy_1.PatchVersionUpdate();
+    }
+    bump(version, commits) {
+        return this.determineReleaseType(version, commits).bump(version);
+    }
+}
+exports.DefaultVersioningStrategy = DefaultVersioningStrategy;
+//# sourceMappingURL=default.js.map

package/build/src/versioning-strategies/dependency-manifest.d.ts

@@ -0,0 +1,7 @@
+import { Version } from '../version';
+import { ConventionalCommit } from '../commit';
+import { DefaultVersioningStrategy } from './default';
+import { VersionUpdater } from '../versioning-strategy';
+export declare class DependencyManifest extends DefaultVersioningStrategy {
+    determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+}

package/build/src/versioning-strategies/dependency-manifest.js

@@ -0,0 +1,90 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyManifest = void 0;
+const version_1 = require("../version");
+const semver = require("semver");
+const default_1 = require("./default");
+const versioning_strategy_1 = require("../versioning-strategy");
+const DEPENDENCY_UPDATE_REGEX = /^deps: update dependency (.*) to (v.*)(\s\(#\d+\))?$/m;
+class DependencyManifest extends default_1.DefaultVersioningStrategy {
+    determineReleaseType(version, commits) {
+        const regularBump = super.determineReleaseType(version, commits);
+        const dependencyUpdates = buildDependencyUpdates(commits);
+        let breaking = 0;
+        let features = 0;
+        for (const dep in dependencyUpdates) {
+            const version = dependencyUpdates[dep];
+            if (version.patch === 0) {
+                if (version.minor === 0) {
+                    breaking++;
+                }
+                else {
+                    features++;
+                }
+            }
+        }
+        let dependencyBump;
+        if (breaking > 0) {
+            if (version.major < 1 && this.bumpMinorPreMajor) {
+                dependencyBump = new versioning_strategy_1.MinorVersionUpdate();
+            }
+            else {
+                dependencyBump = new versioning_strategy_1.MajorVersionUpdate();
+            }
+        }
+        else if (features > 0) {
+            if (version.major < 1 && this.bumpPatchForMinorPreMajor) {
+                dependencyBump = new versioning_strategy_1.PatchVersionUpdate();
+            }
+            else {
+                dependencyBump = new versioning_strategy_1.MinorVersionUpdate();
+            }
+        }
+        else {
+            dependencyBump = new versioning_strategy_1.PatchVersionUpdate();
+        }
+        if (semver.lte(dependencyBump.bump(version).toString(), regularBump.bump(version).toString())) {
+            return regularBump;
+        }
+        else {
+            return dependencyBump;
+        }
+    }
+}
+exports.DependencyManifest = DependencyManifest;
+function buildDependencyUpdates(commits) {
+    const versionsMap = {};
+    for (const commit of commits) {
+        const match = commit.message.match(DEPENDENCY_UPDATE_REGEX);
+        if (!match)
+            continue;
+        const versionString = match[2];
+        let version;
+        try {
+            version = version_1.Version.parse(versionString);
+        }
+        catch (_a) {
+            version = version_1.Version.parse(`${versionString}.0.0`);
+        }
+        // commits are sorted by latest first, so if there is a collision,
+        // then we've already recorded the latest version
+        if (versionsMap[match[1]])
+            continue;
+        versionsMap[match[1]] = version;
+    }
+    return versionsMap;
+}
+//# sourceMappingURL=dependency-manifest.js.map

package/build/src/versioning-strategies/java-add-snapshot.d.ts

@@ -0,0 +1,9 @@
+import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
+import { Version } from '../version';
+import { ConventionalCommit } from '../commit';
+export declare class JavaAddSnapshot implements VersioningStrategy {
+    strategy: VersioningStrategy;
+    constructor(strategy: VersioningStrategy);
+    determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
+    bump(version: Version, commits: ConventionalCommit[]): Version;
+}

package/build/src/versioning-strategies/java-add-snapshot.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaAddSnapshot = void 0;
+const fakeCommit = {
+    message: 'fix: fake fix',
+    type: 'fix',
+    scope: null,
+    notes: [],
+    references: [],
+    bareMessage: 'fake fix',
+    breaking: false,
+    sha: 'abc123',
+    files: [],
+};
+class AddSnapshotVersionUpdate {
+    constructor(strategy) {
+        this.name = 'java-snapshot';
+        this.strategy = strategy;
+    }
+    bump(version) {
+        const nextPatch = this.strategy.bump(version, [fakeCommit]);
+        nextPatch.preRelease = nextPatch.preRelease
+            ? `${nextPatch.preRelease}-SNAPSHOT`
+            : 'SNAPSHOT';
+        return nextPatch;
+    }
+}
+class JavaAddSnapshot {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    determineReleaseType(_version, _commits) {
+        return new AddSnapshotVersionUpdate(this.strategy);
+    }
+    bump(version, commits) {
+        return this.determineReleaseType(version, commits).bump(version);
+    }
+}
+exports.JavaAddSnapshot = JavaAddSnapshot;
+//# sourceMappingURL=java-add-snapshot.js.map

package/build/src/versioning-strategies/java-snapshot.d.ts

@@ -0,0 +1,9 @@
+import { VersioningStrategy, VersionUpdater } from '../versioning-strategy';
+import { Version } from '../version';
+import { ConventionalCommit } from '../commit';
+export declare class JavaSnapshot implements VersioningStrategy {
+    strategy: VersioningStrategy;
+    constructor(strategy: VersioningStrategy);
+    determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+    bump(version: Version, commits: ConventionalCommit[]): Version;
+}

package/build/src/versioning-strategies/java-snapshot.js

@@ -0,0 +1,67 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaSnapshot = void 0;
+const version_1 = require("../version");
+const fakeCommit = {
+    message: 'fix: fake fix',
+    type: 'fix',
+    scope: null,
+    notes: [],
+    references: [],
+    bareMessage: 'fake fix',
+    breaking: false,
+    sha: 'abc123',
+    files: [],
+};
+class RemoveSnapshotVersionUpdate {
+    constructor(parent) {
+        this.name = 'remove-snapshot';
+        this.parent = parent;
+    }
+    bump(version) {
+        if (this.parent) {
+            version = this.parent.bump(version);
+        }
+        return new version_1.Version(version.major, version.minor, version.patch, version.preRelease
+            ? version.preRelease.replace(/-?SNAPSHOT/, '')
+            : undefined, version.build);
+    }
+}
+class JavaSnapshot {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    determineReleaseType(version, commits) {
+        var _a;
+        const parentBump = this.strategy.determineReleaseType(version, commits);
+        if ((_a = version.preRelease) === null || _a === void 0 ? void 0 : _a.match(/-?SNAPSHOT/)) {
+            const patchBumpVersion = this.strategy
+                .determineReleaseType(version, [fakeCommit])
+                .bump(version);
+            const parentBumpVersion = parentBump.bump(version);
+            if (patchBumpVersion.toString() === parentBumpVersion.toString()) {
+                return new RemoveSnapshotVersionUpdate();
+            }
+            return new RemoveSnapshotVersionUpdate(parentBump);
+        }
+        return parentBump;
+    }
+    bump(version, commits) {
+        return this.determineReleaseType(version, commits).bump(version);
+    }
+}
+exports.JavaSnapshot = JavaSnapshot;
+//# sourceMappingURL=java-snapshot.js.map

package/build/src/versioning-strategies/service-pack.d.ts

@@ -0,0 +1,7 @@
+import { Version } from '../version';
+import { DefaultVersioningStrategy } from './default';
+import { ConventionalCommit } from '../commit';
+import { VersionUpdater } from '../versioning-strategy';
+export declare class ServicePackVersioningStrategy extends DefaultVersioningStrategy {
+    determineReleaseType(_version: Version, _commits: ConventionalCommit[]): VersionUpdater;
+}

package/build/src/versioning-strategies/service-pack.js

@@ -0,0 +1,40 @@
+"use strict";
+// Copyright 2021 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServicePackVersioningStrategy = void 0;
+const version_1 = require("../version");
+const default_1 = require("./default");
+const SERVICE_PACK_PATTERN = /sp\.(\d+)/;
+class ServicePackVersionUpdate {
+    constructor() {
+        this.name = 'service-pack';
+    }
+    bump(version) {
+        var _a;
+        const match = (_a = version.preRelease) === null || _a === void 0 ? void 0 : _a.match(SERVICE_PACK_PATTERN);
+        if (match) {
+            const spNumber = Number(match[1]);
+            return new version_1.Version(version.major, version.minor, version.patch, `sp.${spNumber + 1}`, version.build);
+        }
+        return new version_1.Version(version.major, version.minor, version.patch, 'sp.1', version.build);
+    }
+}
+class ServicePackVersioningStrategy extends default_1.DefaultVersioningStrategy {
+    determineReleaseType(_version, _commits) {
+        return new ServicePackVersionUpdate();
+    }
+}
+exports.ServicePackVersioningStrategy = ServicePackVersioningStrategy;
+//# sourceMappingURL=service-pack.js.map

package/build/src/versioning-strategy.d.ts

@@ -0,0 +1,28 @@
+import { Version } from './version';
+import { ConventionalCommit } from './commit';
+export interface VersionUpdater {
+    bump(version: Version): Version;
+    name: string;
+}
+export declare class MajorVersionUpdate implements VersionUpdater {
+    name: string;
+    bump(version: Version): Version;
+}
+export declare class MinorVersionUpdate implements VersionUpdater {
+    name: string;
+    bump(version: Version): Version;
+}
+export declare class PatchVersionUpdate implements VersionUpdater {
+    name: string;
+    bump(version: Version): Version;
+}
+export declare class CustomVersionUpdate implements VersionUpdater {
+    name: string;
+    private versionString;
+    constructor(versionString: string);
+    bump(_version: Version): Version;
+}
+export interface VersioningStrategy {
+    bump(version: Version, commits: ConventionalCommit[]): Version;
+    determineReleaseType(version: Version, commits: ConventionalCommit[]): VersionUpdater;
+}