fireflyy 4.0.0-dev.df58d2b → 4.0.0-dev.fc28987

package/dist/{result.utilities-CdBL5noX.js → result.utilities-DXSJU70_.js}

@@ -1,4 +1,4 @@
-import { f as validationErrAsync, i as FireflyOkAsync, m as createFireflyError, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
+import { f as validationErrAsync, i as FireflyOkAsync, m as createFireflyError, v as toFireflyError } from "./result.constructors-DoAoYdfF.js";
 import { ResultAsync } from "neverthrow";
 
 //#region src/core/result/result.utilities.ts
@@ -17,16 +17,6 @@ function wrapPromise(promise) {
 function ensureNotAsync(condition, errorOpts) {
 	return condition ? validationErrAsync(errorOpts) : FireflyOkAsync(void 0);
 }
-/**
-* Async version of zip3.
-*/
-function zip3Async(resultA, resultB, resultC) {
-	return ResultAsync.combine([
-		resultA,
-		resultB,
-		resultC
-	]);
-}
 
 //#endregion
-export { wrapPromise as n, zip3Async as r, ensureNotAsync as t };
+export { wrapPromise as n, ensureNotAsync as t };

package/dist/{schema.utilities-BOJqWEey.js → schema.utilities-C1yimTtB.js}

@@ -1,4 +1,4 @@
-import { m as createFireflyError, r as FireflyOk, t as FireflyErr, v as toFireflyError } from "./result.constructors-D9jmQ0uj.js";
+import { m as createFireflyError, r as FireflyOk, t as FireflyErr, v as toFireflyError } from "./result.constructors-DoAoYdfF.js";
 import { ResultAsync } from "neverthrow";
 import z$1 from "zod";
 

package/dist/version-DJuocyXy.js

@@ -0,0 +1,164 @@
+import { r as FireflyOk, s as invalidErr } from "./result.constructors-DoAoYdfF.js";
+import semver from "semver";
+
+//#region src/domain/semver/version.ts
+/**
+* Represents a parsed semantic version with immutable access.
+*
+* @example
+* ```ts
+* const result = Version.from("1.2.3-alpha.1");
+* if (result.isOk()) {
+*   console.log(result.value.major); // 1
+*   console.log(result.value.isPrerelease); // true
+* }
+* ```
+*/
+var Version = class Version {
+	_raw;
+	_parsed;
+	constructor(version, parsed) {
+		this._raw = version;
+		this._parsed = parsed;
+	}
+	/**
+	* Creates a Version from any valid semver string.
+	* Handles cleaning (removing 'v' prefix, etc.).
+	*/
+	static from(input) {
+		const cleaned = semver.clean(input);
+		if (!cleaned) return invalidErr({ message: `"${input}" is not a valid semantic version.` });
+		const parsed = semver.parse(cleaned);
+		if (!parsed) return invalidErr({ message: `Failed to parse semantic version "${cleaned}".` });
+		return FireflyOk(new Version(cleaned, parsed));
+	}
+	/**
+	* Creates a Version from an already-clean semver string.
+	* Use when you know the input is already normalized.
+	*/
+	static fromClean(cleanVersion) {
+		const parsed = semver.parse(cleanVersion);
+		if (!parsed) return invalidErr({ message: `Expected clean version but got invalid: ${cleanVersion}` });
+		return FireflyOk(new Version(cleanVersion, parsed));
+	}
+	/**
+	* The raw version string.
+	*/
+	get raw() {
+		return this._raw;
+	}
+	/**
+	* Major version number.
+	*/
+	get major() {
+		return this._parsed.major;
+	}
+	/**
+	* Minor version number.
+	*/
+	get minor() {
+		return this._parsed.minor;
+	}
+	/**
+	* Patch version number.
+	*/
+	get patch() {
+		return this._parsed.patch;
+	}
+	/**
+	* Whether this version has prerelease identifiers.
+	*/
+	get isPrerelease() {
+		return this._parsed.prerelease.length > 0;
+	}
+	/**
+	* Prerelease identifiers (e.g., ["alpha", 1] for "1.0.0-alpha.1").
+	*/
+	get prerelease() {
+		return this._parsed.prerelease;
+	}
+	/**
+	* The prerelease identifier (e.g., "alpha" from "1.0.0-alpha.1").
+	*/
+	get preReleaseId() {
+		if (!this.isPrerelease) return null;
+		const first = this._parsed.prerelease[0];
+		return typeof first === "string" ? first : null;
+	}
+	/**
+	* The prerelease number (e.g., 1 from "1.0.0-alpha.1").
+	*/
+	get prereleaseNumber() {
+		if (!this.isPrerelease) return null;
+		const last = this._parsed.prerelease.at(-1);
+		return typeof last === "number" ? last : null;
+	}
+	/**
+	* Build metadata identifiers.
+	*/
+	get build() {
+		return this._parsed.build;
+	}
+	/**
+	* Returns the raw version string.
+	*/
+	toString() {
+		return this._raw;
+	}
+	/**
+	* Checks equality with another Version.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if equal, false otherwise
+	*/
+	equals(other) {
+		return semver.eq(this._raw, other._raw);
+	}
+	/**
+	* Compares with another Version: -1 (less), 0 (equal), 1 (greater).
+	*
+	* @param other - The other Version to compare with
+	* @returns -1, 0, or 1 based on comparison
+	*/
+	compare(other) {
+		return semver.compare(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is greater than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is greater, false otherwise
+	*/
+	isGreaterThan(other) {
+		return semver.gt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version is less than another.
+	*
+	* @param other - The other Version to compare with
+	* @returns True if this version is less, false otherwise
+	*/
+	isLessThan(other) {
+		return semver.lt(this._raw, other._raw);
+	}
+	/**
+	* Checks if this version satisfies a semver range.
+	*
+	* @param range - The semver range to check against
+	* @returns True if it satisfies the range, false otherwise
+	*/
+	satisfies(range) {
+		return semver.satisfies(this._raw, range);
+	}
+	/**
+	* Converts a prerelease version to its stable form.
+	* "1.2.3-alpha.1" → "1.2.3"
+	*/
+	toStable() {
+		const stableVersion = `${this.major}.${this.minor}.${this.patch}`;
+		return Version.fromClean(stableVersion);
+	}
+};
+
+//#endregion
+export { Version as t };

package/dist/version-bumper.service-glxzf9Qm.js

@@ -0,0 +1,171 @@
+import { c as invalidErrAsync, i as FireflyOkAsync, n as FireflyErrAsync, r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-DoAoYdfF.js";
+import { t as Version } from "./version-DJuocyXy.js";
+import semver from "semver";
+
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, preReleaseId, preReleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") {
+			const result = this.bumpStandard(currentVersion, releaseType);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") {
+			const result = this.bumpPreStandard(currentVersion, releaseType, preReleaseId, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "prerelease") {
+			const result = this.bumpPrerelease(currentVersion, preReleaseId, preReleaseBase);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		if (releaseType === "graduate") {
+			const result = this.graduatePrerelease(currentVersion);
+			return result.isOk() ? FireflyOkAsync(result.value) : FireflyErrAsync(result.error);
+		}
+		return invalidErrAsync({
+			message: `Unsupported release type: ${releaseType}`,
+			source: "services/version-bumper"
+		});
+	}
+	/**
+	* Normalizes the prerelease base to a string "0" or "1".
+	*
+	* @param base - The prerelease base to normalize
+	* @returns The normalized base or an error if invalid
+	*/
+	normalizeBase(base) {
+		if (base === void 0 || base === null) return FireflyOk(void 0);
+		if (base === "0" || base === "1") return FireflyOk(base);
+		if (typeof base === "number" && (base === 0 || base === 1)) return FireflyOk(base.toString());
+		return invalidErr({ message: `Invalid preReleaseBase '${base}'. Must be "0", "1", 0, or 1.` });
+	}
+	/**
+	* Determines if the prerelease identifier is complex (contains dots).
+	*
+	* @param identifier - The prerelease identifier to check
+	* @returns True if the identifier is complex, false otherwise
+	*/
+	isComplexIdentifier(identifier) {
+		return typeof identifier === "string" && identifier.includes(".");
+	}
+	/**
+	* Bumps a version with a complex prerelease identifier (e.g., "canary.abc123").
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - The complex prerelease identifier
+	* @returns The new version with the complex identifier
+	*/
+	bumpWithComplexIdentifier(currentVersion, identifier) {
+		if (!identifier) return semver.inc(currentVersion.raw, "prerelease", void 0, "0");
+		return semver.inc(currentVersion.raw, "prerelease", identifier, false);
+	}
+	/**
+	* Bumps an existing prerelease version.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier
+	* @returns The new prerelease version
+	*/
+	bumpExistingPrerelease(currentVersion, identifier) {
+		return identifier ? semver.inc(currentVersion.raw, "prerelease", identifier) : semver.inc(currentVersion.raw, "prerelease");
+	}
+	/**
+	* Bumps a standard version (major, minor, patch) according to the provided release type.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of standard release
+	* @returns The new standard version
+	*/
+	bumpStandard(currentVersion, releaseType) {
+		let baseVersionString = currentVersion.raw;
+		if (currentVersion.isPrerelease) {
+			const stableResult = currentVersion.toStable();
+			if (stableResult.isErr()) return FireflyErr(stableResult.error);
+			baseVersionString = stableResult.value.raw;
+		}
+		const newVersionString = semver.inc(baseVersionString, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${baseVersionString}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a pre-standard version (premajor, preminor, prepatch) according to the provided options.
+	*
+	* @param currentVersion - The current version to bump
+	* @param releaseType - The type of pre-standard release
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new pre-standard version
+	*/
+	bumpPreStandard(currentVersion, releaseType, preReleaseId, preReleaseBase) {
+		const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = preReleaseId ? semver.inc(currentVersion.raw, releaseType, preReleaseId, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = preReleaseId ? semver.inc(currentVersion.raw, releaseType, preReleaseId) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${preReleaseId}' and base '${preReleaseBase}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Bumps a prerelease version according to the provided options.
+	* Handles complex identifiers, explicit bases, continuing existing
+	* prereleases, and starting new prereleases from stable versions.
+	*
+	* @param currentVersion - The current version to bump
+	* @param identifier - Optional prerelease identifier (e.g., "alpha", "beta")
+	* @param base - Optional base number for the prerelease
+	* @returns The new prerelease version
+	*/
+	bumpPrerelease(currentVersion, preReleaseId, preReleaseBase) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(preReleaseId)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, preReleaseId);
+		else if (preReleaseBase !== void 0 && preReleaseBase !== null) {
+			const normalizedBaseResult = this.normalizeBase(preReleaseBase);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = preReleaseId ? semver.inc(currentVersion.raw, "prerelease", preReleaseId, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, preReleaseId);
+		else {
+			const defaultIdentifier = preReleaseId || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${preReleaseId}' and base '${preReleaseBase}'.`,
+			source: "services/version-bumper"
+		});
+		return Version.fromClean(newVersionString);
+	}
+	/**
+	* Graduates a prerelease version to its stable counterpart.
+	*
+	* @param currentVersion - The current prerelease version
+	* @returns The stable version
+	*/
+	graduatePrerelease(currentVersion) {
+		if (!currentVersion.isPrerelease) return invalidErr({
+			message: `Cannot graduate non-prerelease version '${currentVersion.raw}'. Only prerelease versions can be graduated.`,
+			source: "services/version-bumper"
+		});
+		const stableVersionResult = currentVersion.toStable();
+		if (stableVersionResult.isErr()) return FireflyErr(stableVersionResult.error);
+		return FireflyOk(stableVersionResult.value);
+	}
+};
+/**
+* Creates a version bumper service instance.
+*/
+function createVersionBumperService() {
+	return new DefaultVersionBumperService();
+}
+
+//#endregion
+export { createVersionBumperService };

package/dist/{version-strategy.service-vh5KeNCA.js → version-strategy.service-Dln42gxC.js}

@@ -1,6 +1,6 @@
-import { t as logger } from "./main.js";
-import { g as invalidError, r as FireflyOk, t as FireflyErr } from "./result.constructors-D9jmQ0uj.js";
-import { Result } from "neverthrow";
+import { g as invalidError, i as FireflyOkAsync, n as FireflyErrAsync } from "./result.constructors-DoAoYdfF.js";
+import { t as logger } from "./logging-Bpk2RzGc.js";
+import { ResultAsync } from "neverthrow";
 
 //#region src/services/implementations/version-strategy.service.ts
 const TRANSITION_KEYWORDS = [
@@ -55,6 +55,9 @@ const VERSION_DESCRIPTIONS = {
 	prerelease: "Unstable pre-release continuation. Increments the pre-release number or changes identifier.",
 	graduate: "Promote pre-release to stable. Removes pre-release identifiers to create a stable version."
 };
+/**
+* Default implementation of the version strategy service.
+*/
 var DefaultVersionStrategyService = class {
 	bumper;
 	constructor(bumper) {
@@ -80,19 +83,19 @@ var DefaultVersionStrategyService = class {
 			return this.bumper.bump({
 				currentVersion: options.currentVersion,
 				releaseType: options.releaseType,
-				prereleaseIdentifier: options.prereleaseIdentifier,
-				prereleaseBase: options.prereleaseBase
+				preReleaseId: options.preReleaseId,
+				preReleaseBase: options.preReleaseBase
 			});
 		}
-		return FireflyErr(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
+		return FireflyErrAsync(invalidError({ message: "Cannot determine next version: no release type or recommendation provided" }));
 	}
 	generateChoices(options) {
 		logger.verbose(`DefaultVersionStrategyService: Creating version choices for '${options.currentVersion.raw}'...`);
-		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.prereleaseIdentifier, options.prereleaseBase));
-		const combinedResult = Result.combine(choicesResults);
-		if (combinedResult.isErr()) return FireflyErr(combinedResult.error);
-		logger.verbose(`DefaultVersionStrategyService: Created ${combinedResult.value.length} version choices.`);
-		return FireflyOk(combinedResult.value);
+		const choicesResults = this.determineAvailableVersionTypes(options.currentVersion, options.releaseType).map((releaseType) => this.createSingleChoice(options.currentVersion, releaseType, options.preReleaseId, options.preReleaseBase));
+		return ResultAsync.combine(choicesResults).map((choices) => {
+			logger.verbose(`DefaultVersionStrategyService: Created ${choices.length} version choices.`);
+			return choices;
+		});
 	}
 	/**
 	* Analyzes the current version and recommendation to determine pre-release context.
@@ -104,7 +107,7 @@ var DefaultVersionStrategyService = class {
 	analyzePreReleaseContext(currentVersion, recommendation) {
 		return {
 			isCurrentPreRelease: currentVersion.isPrerelease,
-			prereleaseIdentifier: currentVersion.prereleaseIdentifier,
+			preReleaseId: currentVersion.preReleaseId,
 			hasStableTransition: this.detectStableTransition(recommendation)
 		};
 	}
@@ -131,8 +134,8 @@ var DefaultVersionStrategyService = class {
 		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType: "prerelease",
-			prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
-			prereleaseBase: options.prereleaseBase
+			preReleaseId: options.preReleaseId ?? context.preReleaseId ?? "alpha",
+			preReleaseBase: options.preReleaseBase
 		});
 	}
 	/**
@@ -143,26 +146,25 @@ var DefaultVersionStrategyService = class {
 	* @returns A result containing the new stable version or an error
 	*/
 	handlePreReleaseToStableTransition(options, recommendation) {
-		if (!recommendation) return FireflyErr(invalidError({
+		if (!recommendation) return FireflyErrAsync(invalidError({
 			message: "Cannot transition to stable version without recommendation",
 			source: "services/version-strategy"
 		}));
-		const graduateResult = this.bumper.bump({
+		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType: "graduate"
+		}).andThen((stableVersion) => {
+			if (recommendation.level < 2) {
+				logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
+				const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+				return this.bumper.bump({
+					currentVersion: stableVersion,
+					releaseType
+				});
+			}
+			logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
+			return FireflyOkAsync(stableVersion);
 		});
-		if (graduateResult.isErr()) return FireflyErr(graduateResult.error);
-		const stableVersion = graduateResult.value;
-		if (recommendation.level < 2) {
-			logger.verbose("DefaultVersionStrategyService: Further bumping after graduation...");
-			const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
-			return this.bumper.bump({
-				currentVersion: stableVersion,
-				releaseType
-			});
-		}
-		logger.verbose("DefaultVersionStrategyService: Graduated to stable version:", stableVersion.raw);
-		return FireflyOk(stableVersion);
 	}
 	/**
 	* Creates a new version based on the provided recommendation and pre-release context.
@@ -178,8 +180,8 @@ var DefaultVersionStrategyService = class {
 			return this.bumper.bump({
 				currentVersion: options.currentVersion,
 				releaseType: "prerelease",
-				prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
-				prereleaseBase: options.prereleaseBase
+				preReleaseId: options.preReleaseId ?? context.preReleaseId ?? "alpha",
+				preReleaseBase: options.preReleaseBase
 			});
 		}
 		const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
@@ -187,8 +189,8 @@ var DefaultVersionStrategyService = class {
 		return this.bumper.bump({
 			currentVersion: options.currentVersion,
 			releaseType,
-			prereleaseIdentifier: options.prereleaseIdentifier,
-			prereleaseBase: options.prereleaseBase
+			preReleaseId: options.preReleaseId,
+			preReleaseBase: options.preReleaseBase
 		});
 	}
 	/**
@@ -225,25 +227,22 @@ var DefaultVersionStrategyService = class {
 	*
 	* @param currentVersion - The current version
 	* @param releaseType - The type of release to create
-	* @param prereleaseIdentifier - Optional pre-release identifier
-	* @param prereleaseBase - Optional base for pre-release
+	* @param preReleaseId - Optional pre-release identifier
+	* @param preReleaseBase - Optional base for pre-release
 	* @returns A result containing the version choice or an error
 	*/
-	createSingleChoice(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase) {
+	createSingleChoice(currentVersion, releaseType, preReleaseId, preReleaseBase) {
 		const bumpOptions = {
 			currentVersion,
 			releaseType,
-			prereleaseIdentifier,
-			prereleaseBase
+			preReleaseId,
+			preReleaseBase
 		};
-		const newVersionResult = this.bumper.bump(bumpOptions);
-		if (newVersionResult.isErr()) return FireflyErr(newVersionResult.error);
-		const newVersion = newVersionResult.value;
-		return FireflyOk({
+		return this.bumper.bump(bumpOptions).map((newVersion) => ({
 			label: `${releaseType} (${newVersion.raw})`,
 			hint: this.getVersionDescription(releaseType),
 			value: newVersion.raw
-		});
+		}));
 	}
 };
 /**
@@ -255,4 +254,4 @@ function createVersionStrategyService(bumper) {
 }
 
 //#endregion
-export { TRANSITION_KEYWORDS as n, createVersionStrategyService as r, DefaultVersionStrategyService as t };
+export { TRANSITION_KEYWORDS, createVersionStrategyService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.df58d2b",
+  "version": "4.0.0-dev.fc28987",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -65,9 +65,9 @@
     "@biomejs/biome": "2.3.8",
     "@types/bun": "^1.3.3",
     "@types/semver": "^7.7.1",
-    "tsdown": "^0.17.0-beta.5",
+    "tsdown": "^0.17.0",
     "typescript": "^5.9.3",
-    "ultracite": "6.3.8"
+    "ultracite": "6.3.9"
   },
   "keywords": [
     "cli",

package/dist/index.d.ts

@@ -1,79 +0,0 @@
-import z from "zod";
-
-//#region src/cli/config/config.schema.d.ts
-
-/**
- * Complete Firefly configuration schema.
- * Combines global options with command-specific configuration sections.
- */
-declare const FireflyConfigSchema: z.ZodObject<{
-  release: z.ZodOptional<z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    scope: z.ZodOptional<z.ZodString>;
-    base: z.ZodDefault<z.ZodString>;
-    branch: z.ZodOptional<z.ZodString>;
-    changelogPath: z.ZodDefault<z.ZodString>;
-    bumpStrategy: z.ZodDefault<z.ZodUnion<[z.ZodEnum<{
-      auto: "auto";
-      manual: "manual";
-    }>, z.ZodLiteral<"">]>>;
-    releaseType: z.ZodOptional<z.ZodEnum<{
-      major: "major";
-      minor: "minor";
-      patch: "patch";
-      prerelease: "prerelease";
-      premajor: "premajor";
-      preminor: "preminor";
-      prepatch: "prepatch";
-      graduate: "graduate";
-    }>>;
-    preReleaseId: z.ZodOptional<z.ZodString>;
-    preReleaseBase: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"0">, z.ZodLiteral<"1">]>>;
-    releaseNotes: z.ZodDefault<z.ZodString>;
-    commitMessage: z.ZodDefault<z.ZodString>;
-    tagName: z.ZodDefault<z.ZodString>;
-    skipBump: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    skipChangelog: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    skipPush: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    skipGitHubRelease: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    skipGit: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    skipPreflightCheck: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    releaseTitle: z.ZodDefault<z.ZodString>;
-    releaseLatest: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    releasePreRelease: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-    releaseDraft: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-  }, z.core.$strip>>;
-  cwd: z.ZodOptional<z.ZodString>;
-  dryRun: z.ZodOptional<z.ZodBoolean>;
-  verbose: z.ZodOptional<z.ZodBoolean>;
-  enableRollback: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-/**
- * TypeScript type for Firefly configuration.
- * Use this type when you need to reference the configuration shape without runtime validation.
- */
-type FireflyConfig = z.infer<typeof FireflyConfigSchema>;
-//#endregion
-//#region src/config/index.d.ts
-/**
- * Helper function to define a type-safe Firefly configuration.
- *
- * Provides IntelliSense autocompletion and type checking for config files.
- *
- * @param options - The configuration options
- * @returns The same options (identity function for type inference)
- *
- * @example
- * ```ts
- * export default defineConfig({
- *     verbose: true,
- *     release: {
- *         bumpStrategy: "conventional",
- *         releaseType: "github",
- *     },
- * });
- * ```
- */
-declare function defineConfig<T extends FireflyConfig>(options: T): T;
-//#endregion
-export { defineConfig };