fireflyy 4.0.0-dev.4721ae4 → 4.0.0-dev.5da9e52

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

@@ -0,0 +1,318 @@
+import { r as FireflyOk, s as invalidErr, t as FireflyErr } from "./result.constructors-D9jmQ0uj.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 prereleaseIdentifier() {
+		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
+//#region src/services/implementations/version-bumper.service.ts
+/**
+* Default implementation of the version bumper service.
+*/
+var DefaultVersionBumperService = class {
+	bump(options) {
+		const { currentVersion, releaseType, prereleaseIdentifier, prereleaseBase } = options;
+		if (releaseType === "major" || releaseType === "minor" || releaseType === "patch") return this.bumpStandard(currentVersion, releaseType);
+		if (releaseType === "premajor" || releaseType === "preminor" || releaseType === "prepatch") return this.bumpPreStandard(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "prerelease") return this.bumpPrerelease(currentVersion, prereleaseIdentifier, prereleaseBase);
+		if (releaseType === "graduate") return this.graduatePrerelease(currentVersion);
+		return invalidErr({
+			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 prerelease base '${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, identifier, base) {
+		const normalizedBaseResult = this.normalizeBase(base);
+		if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+		const normalizedBase = normalizedBaseResult.value;
+		let newVersionString = null;
+		if (normalizedBase !== void 0) newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier, normalizedBase) : semver.inc(currentVersion.raw, releaseType, void 0, normalizedBase);
+		else newVersionString = identifier ? semver.inc(currentVersion.raw, releaseType, identifier) : semver.inc(currentVersion.raw, releaseType);
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump ${releaseType} version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			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, identifier, base) {
+		let newVersionString = null;
+		if (this.isComplexIdentifier(identifier)) newVersionString = this.bumpWithComplexIdentifier(currentVersion, identifier);
+		else if (base !== void 0 && base !== null) {
+			const normalizedBaseResult = this.normalizeBase(base);
+			if (normalizedBaseResult.isErr()) return FireflyErr(normalizedBaseResult.error);
+			const normalizedBase = normalizedBaseResult.value;
+			newVersionString = identifier ? semver.inc(currentVersion.raw, "prerelease", identifier, normalizedBase) : semver.inc(currentVersion.raw, "prerelease", void 0, normalizedBase);
+		} else if (currentVersion.isPrerelease) newVersionString = this.bumpExistingPrerelease(currentVersion, identifier);
+		else {
+			const defaultIdentifier = identifier || "alpha";
+			newVersionString = semver.inc(currentVersion.raw, "prerelease", defaultIdentifier);
+		}
+		if (!newVersionString) return invalidErr({
+			message: `Failed to bump prerelease version from '${currentVersion.raw}' with identifier '${identifier}' and base '${base}'.`,
+			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-Ds4mvlDC.js

@@ -0,0 +1,258 @@
+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";
+
+//#region src/services/implementations/version-strategy.service.ts
+const TRANSITION_KEYWORDS = [
+	"general availability",
+	"promote to stable",
+	"move to stable"
+];
+const LEVEL_TO_RELEASE_TYPE = {
+	0: "major",
+	1: "minor",
+	2: "patch"
+};
+/**
+* Version type categories for organizing choices.
+*/
+const VERSION_TYPES = {
+	RELEASE: [
+		"patch",
+		"minor",
+		"major"
+	],
+	PRERELEASE: [
+		"prepatch",
+		"preminor",
+		"premajor"
+	],
+	CONTINUATION: ["prerelease"],
+	GRADUATION: ["graduate"]
+};
+/**
+* Pre-configured choice sets for different scenarios.
+*/
+const VERSION_CHOICE_SETS = {
+	latestIsPreRelease: [
+		...VERSION_TYPES.CONTINUATION,
+		...VERSION_TYPES.GRADUATION,
+		...VERSION_TYPES.RELEASE
+	],
+	preRelease: VERSION_TYPES.PRERELEASE,
+	default: [...VERSION_TYPES.RELEASE, ...VERSION_TYPES.PRERELEASE]
+};
+/**
+* Human-readable descriptions for each release type.
+*/
+const VERSION_DESCRIPTIONS = {
+	patch: "Fixes and minor enhancements without breaking compatibility. Suitable for bug fixes and small improvements.",
+	minor: "New, backward-compatible functionality. Adds features that do not break existing APIs.",
+	major: "Incompatible API changes. Introduces breaking changes or removes deprecated features.",
+	prepatch: "Unstable patch release candidate. Used for testing patch changes before a stable release.",
+	preminor: "Unstable minor release candidate. Used for previewing new features before a minor release.",
+	premajor: "Unstable major release candidate. Used for testing breaking changes before a major release.",
+	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."
+};
+var DefaultVersionStrategyService = class {
+	bumper;
+	constructor(bumper) {
+		this.bumper = bumper;
+	}
+	resolveVersion(options, recommendation) {
+		logger.verbose("DefaultVersionStrategyService: Deciding next version...");
+		const preReleaseContext = this.analyzePreReleaseContext(options.currentVersion, recommendation);
+		if (options.releaseType === "prerelease") {
+			logger.verbose("DefaultVersionStrategyService: Handling prerelease request...");
+			return this.handlePreReleaseRequest(options, preReleaseContext);
+		}
+		if (preReleaseContext.isCurrentPreRelease && preReleaseContext.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Handling pre-release to stable transition...");
+			return this.handlePreReleaseToStableTransition(options, recommendation);
+		}
+		if (recommendation) {
+			logger.verbose("DefaultVersionStrategyService: Handling recommendation-based versioning...");
+			return this.createRecommendationBasedVersion(options, recommendation, preReleaseContext);
+		}
+		if (options.releaseType) {
+			logger.verbose("DefaultVersionStrategyService: Handling explicit release type...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: options.releaseType,
+				prereleaseIdentifier: options.prereleaseIdentifier,
+				prereleaseBase: options.prereleaseBase
+			});
+		}
+		return FireflyErr(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);
+	}
+	/**
+	* Analyzes the current version and recommendation to determine pre-release context.
+	*
+	* @param currentVersion - The current version
+	* @param recommendation - The version recommendation
+	* @returns The pre-release context
+	*/
+	analyzePreReleaseContext(currentVersion, recommendation) {
+		return {
+			isCurrentPreRelease: currentVersion.isPrerelease,
+			prereleaseIdentifier: currentVersion.prereleaseIdentifier,
+			hasStableTransition: this.detectStableTransition(recommendation)
+		};
+	}
+	/**
+	* Detects if the recommendation indicates a transition to a stable version.
+	*
+	* @param recommendation - The version recommendation
+	* @returns True if a stable transition is detected, false otherwise
+	*/
+	detectStableTransition(recommendation) {
+		if (!recommendation) return false;
+		const reason = recommendation.reason.toLowerCase();
+		return TRANSITION_KEYWORDS.some((keyword) => reason.includes(keyword));
+	}
+	/**
+	* Handles explicit requests for pre-release versions.
+	*
+	* @param options - The version resolution options
+	* @param context - The pre-release context
+	* @returns A result containing the new pre-release version or an error
+	*/
+	handlePreReleaseRequest(options, context) {
+		logger.verbose("DefaultVersionStrategyService: Bumping to prerelease version...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "prerelease",
+			prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
+			prereleaseBase: options.prereleaseBase
+		});
+	}
+	/**
+	* Handles the transition from a pre-release version to a stable version.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @returns A result containing the new stable version or an error
+	*/
+	handlePreReleaseToStableTransition(options, recommendation) {
+		if (!recommendation) return FireflyErr(invalidError({
+			message: "Cannot transition to stable version without recommendation",
+			source: "services/version-strategy"
+		}));
+		const graduateResult = this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType: "graduate"
+		});
+		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.
+	*
+	* @param options - The version resolution options
+	* @param recommendation - The version recommendation
+	* @param context - The pre-release context
+	* @returns A result containing the new version or an error
+	*/
+	createRecommendationBasedVersion(options, recommendation, context) {
+		if (context.isCurrentPreRelease && !context.hasStableTransition) {
+			logger.verbose("DefaultVersionStrategyService: Continuing prerelease versioning...");
+			return this.bumper.bump({
+				currentVersion: options.currentVersion,
+				releaseType: "prerelease",
+				prereleaseIdentifier: options.prereleaseIdentifier ?? context.prereleaseIdentifier ?? "alpha",
+				prereleaseBase: options.prereleaseBase
+			});
+		}
+		const releaseType = LEVEL_TO_RELEASE_TYPE[recommendation.level];
+		logger.verbose("DefaultVersionStrategyService: Bumping version based on recommendation...");
+		return this.bumper.bump({
+			currentVersion: options.currentVersion,
+			releaseType,
+			prereleaseIdentifier: options.prereleaseIdentifier,
+			prereleaseBase: options.prereleaseBase
+		});
+	}
+	/**
+	* Determines the available version types based on current version and optional release type.
+	*
+	* @param currentVersion - The current version
+	* @param releaseType - Optional specific release type
+	* @returns An array of available release types
+	*/
+	determineAvailableVersionTypes(currentVersion, releaseType) {
+		if (releaseType !== void 0) return this.getVersionTypesForReleaseType(releaseType);
+		return currentVersion.isPrerelease ? VERSION_CHOICE_SETS.latestIsPreRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the version types applicable for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns An array of applicable release types
+	*/
+	getVersionTypesForReleaseType(releaseType) {
+		return releaseType === "prerelease" ? VERSION_CHOICE_SETS.preRelease : VERSION_CHOICE_SETS.default;
+	}
+	/**
+	* Retrieves the description for a given release type.
+	*
+	* @param releaseType - The type of release
+	* @returns The description string for the release type
+	*/
+	getVersionDescription(releaseType) {
+		return VERSION_DESCRIPTIONS[releaseType] ?? "";
+	}
+	/**
+	* Creates a single version choice based on the provided parameters.
+	*
+	* @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
+	* @returns A result containing the version choice or an error
+	*/
+	createSingleChoice(currentVersion, releaseType, prereleaseIdentifier, prereleaseBase) {
+		const bumpOptions = {
+			currentVersion,
+			releaseType,
+			prereleaseIdentifier,
+			prereleaseBase
+		};
+		const newVersionResult = this.bumper.bump(bumpOptions);
+		if (newVersionResult.isErr()) return FireflyErr(newVersionResult.error);
+		const newVersion = newVersionResult.value;
+		return FireflyOk({
+			label: `${releaseType} (${newVersion.raw})`,
+			hint: this.getVersionDescription(releaseType),
+			value: newVersion.raw
+		});
+	}
+};
+/**
+* Creates a version strategy service instance.
+* @param bumper - The version bumper service to use
+*/
+function createVersionStrategyService(bumper) {
+	return new DefaultVersionStrategyService(bumper);
+}
+
+//#endregion
+export { TRANSITION_KEYWORDS, createVersionStrategyService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fireflyy",
-  "version": "4.0.0-dev.4721ae4",
+  "version": "4.0.0-dev.5da9e52",
   "description": " CLI orchestrator for automatic semantic versioning, changelog generation, and creating releases. Built for my own use cases.",
   "type": "module",
   "license": "MIT",
@@ -65,7 +65,7 @@
     "@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-beta.6",
     "typescript": "^5.9.3",
     "ultracite": "6.3.8"
   },

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 };