projen-pipelines 0.2.12 → 0.2.14

package/lib/versioning/setup.js

@@ -0,0 +1,165 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningSetup = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Sets up versioning tasks and integration for a project
+ */
+class VersioningSetup {
+    constructor(project, config) {
+        this.project = project;
+        this.config = config;
+    }
+    /**
+     * Set up all versioning-related tasks and configurations
+     */
+    setup() {
+        // Create version computation task
+        this.createVersionComputeTask();
+        // Create version print task
+        this.createVersionPrintTask();
+        // Add version computation to build process
+        this.integrateWithBuildProcess();
+        // Add version file to gitignore
+        this.project.gitignore.exclude('~version.json');
+    }
+    /**
+     * Create the version:compute task
+     */
+    createVersionComputeTask() {
+        this.project.addTask('version:compute', {
+            description: 'Compute version information from git',
+            steps: [
+                { exec: 'echo "Computing version information..."' },
+                {
+                    exec: this.generateVersionComputeScript(),
+                },
+            ],
+        });
+    }
+    /**
+     * Create the version:print task
+     */
+    createVersionPrintTask() {
+        this.project.addTask('version:print', {
+            description: 'Print version information',
+            steps: [
+                { exec: 'cat ~version.json' },
+            ],
+        });
+    }
+    /**
+     * Integrate version computation with the build process
+     */
+    integrateWithBuildProcess() {
+        const compileTask = this.project.tasks.tryFind('compile');
+        const computeTask = this.project.tasks.tryFind('version:compute');
+        const printTask = this.project.tasks.tryFind('version:print');
+        if (compileTask && computeTask && printTask) {
+            compileTask.prependSpawn(printTask);
+            compileTask.prependSpawn(computeTask);
+        }
+    }
+    /**
+     * Generate the Node.js script for version computation
+     */
+    generateVersionComputeScript() {
+        const strategyJson = JSON.stringify(this.config.strategy).replace(/"/g, '\\"');
+        return `node -e "
+const fs = require('fs');
+const cp = require('child_process');
+
+// Import versioning modules
+const { VersionComputer, VersioningStrategy } = require('projen-pipelines');
+
+try {
+  // Gather git information
+  const commitHash = cp.execSync('git rev-parse HEAD', {encoding: 'utf8'}).trim();
+  const commitHashShort = commitHash.substring(0, 8);
+  const commitCount = parseInt(cp.execSync('git rev-list --count HEAD', {encoding: 'utf8'}).trim());
+  const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', {encoding: 'utf8'}).trim();
+  
+  let tag = '';
+  let commitsSinceTag = 0;
+  try { 
+    tag = cp.execSync('git describe --tags --exact-match --all', {encoding: 'utf8'}).trim();
+  } catch {
+    try {
+      const describeOutput = cp.execSync('git describe --tags --long --all', {encoding: 'utf8'}).trim();
+      const match = describeOutput.match(/^(.+)-(\\\\d+)-g[0-9a-f]+$/);
+      if (match) {
+        tag = match[1];
+        commitsSinceTag = parseInt(match[2]);
+      }
+    } catch {}
+  }
+  
+  let packageVersion = '0.0.0';
+  try {
+    packageVersion = JSON.parse(fs.readFileSync('package.json', 'utf8')).version;
+  } catch {}
+  
+  // Create computation context
+  const context = {
+    gitInfo: {
+      commitHash,
+      commitHashShort,
+      branch,
+      tag,
+      commitsSinceTag,
+      commitCount,
+      packageVersion
+    },
+    environment: process.env.STAGE || process.env.ENVIRONMENT || 'unknown',
+    deployedBy: process.env.GITHUB_ACTOR || process.env.GITLAB_USER_LOGIN || process.env.USER || 'unknown',
+    buildNumber: process.env.BUILD_NUMBER || process.env.GITHUB_RUN_NUMBER,
+    repository: process.env.GITHUB_REPOSITORY || process.env.CI_PROJECT_PATH,
+    pipelineVersion: process.env.PIPELINE_VERSION
+  };
+  
+  // Create strategy from configuration
+  const strategyConfig = ${strategyJson};
+  const strategy = new VersioningStrategy(strategyConfig.format, strategyConfig.components);
+  
+  // Compute version
+  const computer = new VersionComputer(strategy);
+  computer.computeVersionInfo(context).then(versionInfo => {
+    fs.writeFileSync('~version.json', versionInfo.toJson());
+    console.log('Version computed:', versionInfo.version, '(commit:', versionInfo.commitHashShort + ')');
+  }).catch(error => {
+    console.error('Error computing version:', error.message);
+    const fallback = {
+      version: '0.0.0',
+      commitHash: 'unknown',
+      commitHashShort: 'unknown',
+      branch: 'unknown',
+      commitCount: 0,
+      packageVersion: '0.0.0',
+      deployedAt: new Date().toISOString(),
+      deployedBy: 'unknown',
+      environment: 'unknown'
+    };
+    fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));
+  });
+} catch (e) {
+  console.error('Error in version computation:', e.message);
+  const fallback = {
+    version: '0.0.0',
+    commitHash: 'unknown',
+    commitHashShort: 'unknown',
+    branch: 'unknown',
+    commitCount: 0,
+    packageVersion: '0.0.0',
+    deployedAt: new Date().toISOString(),
+    deployedBy: 'unknown',
+    environment: 'unknown'
+  };
+  fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));
+}"`;
+    }
+}
+exports.VersioningSetup = VersioningSetup;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningSetup[_a] = { fqn: "projen-pipelines.VersioningSetup", version: "0.2.14" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup.js","sourceRoot":"","sources":["../../src/versioning/setup.ts"],"names":[],"mappings":";;;;;AAGA;;GAEG;AACH,MAAa,eAAe;IAE1B,YAA6B,OAAgB,EAAmB,MAAwB;QAA3D,YAAO,GAAP,OAAO,CAAS;QAAmB,WAAM,GAAN,MAAM,CAAkB;IACxF,CAAC;IAED;;OAEG;IACI,KAAK;QACV,kCAAkC;QAClC,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEhC,4BAA4B;QAC5B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,2CAA2C;QAC3C,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAEjC,gCAAgC;QAChC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACK,wBAAwB;QAC9B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACtC,WAAW,EAAE,sCAAsC;YACnD,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,yCAAyC,EAAE;gBACnD;oBACE,IAAI,EAAE,IAAI,CAAC,4BAA4B,EAAE;iBAC1C;aACF;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE;YACpC,WAAW,EAAE,2BAA2B;YACxC,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,mBAAmB,EAAE;aAC9B;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAE9D,IAAI,WAAW,IAAI,WAAW,IAAI,SAAS,EAAE,CAAC;YAC5C,WAAW,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACpC,WAAW,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;OAEG;IACK,4BAA4B;QAClC,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAE/E,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAqDgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCpC,CAAC;IACF,CAAC;;AAhKH,0CAiKC","sourcesContent":["import { Project } from 'projen';\nimport { VersioningConfig } from './types';\n\n/**\n * Sets up versioning tasks and integration for a project\n */\nexport class VersioningSetup {\n\n  constructor(private readonly project: Project, private readonly config: VersioningConfig) {\n  }\n\n  /**\n   * Set up all versioning-related tasks and configurations\n   */\n  public setup(): void {\n    // Create version computation task\n    this.createVersionComputeTask();\n\n    // Create version print task\n    this.createVersionPrintTask();\n\n    // Add version computation to build process\n    this.integrateWithBuildProcess();\n\n    // Add version file to gitignore\n    this.project.gitignore.exclude('~version.json');\n  }\n\n  /**\n   * Create the version:compute task\n   */\n  private createVersionComputeTask(): void {\n    this.project.addTask('version:compute', {\n      description: 'Compute version information from git',\n      steps: [\n        { exec: 'echo \"Computing version information...\"' },\n        {\n          exec: this.generateVersionComputeScript(),\n        },\n      ],\n    });\n  }\n\n  /**\n   * Create the version:print task\n   */\n  private createVersionPrintTask(): void {\n    this.project.addTask('version:print', {\n      description: 'Print version information',\n      steps: [\n        { exec: 'cat ~version.json' },\n      ],\n    });\n  }\n\n  /**\n   * Integrate version computation with the build process\n   */\n  private integrateWithBuildProcess(): void {\n    const compileTask = this.project.tasks.tryFind('compile');\n    const computeTask = this.project.tasks.tryFind('version:compute');\n    const printTask = this.project.tasks.tryFind('version:print');\n\n    if (compileTask && computeTask && printTask) {\n      compileTask.prependSpawn(printTask);\n      compileTask.prependSpawn(computeTask);\n    }\n  }\n\n  /**\n   * Generate the Node.js script for version computation\n   */\n  private generateVersionComputeScript(): string {\n    const strategyJson = JSON.stringify(this.config.strategy).replace(/\"/g, '\\\\\"');\n\n    return `node -e \"\nconst fs = require('fs');\nconst cp = require('child_process');\n\n// Import versioning modules\nconst { VersionComputer, VersioningStrategy } = require('projen-pipelines');\n\ntry {\n  // Gather git information\n  const commitHash = cp.execSync('git rev-parse HEAD', {encoding: 'utf8'}).trim();\n  const commitHashShort = commitHash.substring(0, 8);\n  const commitCount = parseInt(cp.execSync('git rev-list --count HEAD', {encoding: 'utf8'}).trim());\n  const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', {encoding: 'utf8'}).trim();\n  \n  let tag = '';\n  let commitsSinceTag = 0;\n  try { \n    tag = cp.execSync('git describe --tags --exact-match --all', {encoding: 'utf8'}).trim();\n  } catch {\n    try {\n      const describeOutput = cp.execSync('git describe --tags --long --all', {encoding: 'utf8'}).trim();\n      const match = describeOutput.match(/^(.+)-(\\\\\\\\d+)-g[0-9a-f]+$/);\n      if (match) {\n        tag = match[1];\n        commitsSinceTag = parseInt(match[2]);\n      }\n    } catch {}\n  }\n  \n  let packageVersion = '0.0.0';\n  try {\n    packageVersion = JSON.parse(fs.readFileSync('package.json', 'utf8')).version;\n  } catch {}\n  \n  // Create computation context\n  const context = {\n    gitInfo: {\n      commitHash,\n      commitHashShort,\n      branch,\n      tag,\n      commitsSinceTag,\n      commitCount,\n      packageVersion\n    },\n    environment: process.env.STAGE || process.env.ENVIRONMENT || 'unknown',\n    deployedBy: process.env.GITHUB_ACTOR || process.env.GITLAB_USER_LOGIN || process.env.USER || 'unknown',\n    buildNumber: process.env.BUILD_NUMBER || process.env.GITHUB_RUN_NUMBER,\n    repository: process.env.GITHUB_REPOSITORY || process.env.CI_PROJECT_PATH,\n    pipelineVersion: process.env.PIPELINE_VERSION\n  };\n  \n  // Create strategy from configuration\n  const strategyConfig = ${strategyJson};\n  const strategy = new VersioningStrategy(strategyConfig.format, strategyConfig.components);\n  \n  // Compute version\n  const computer = new VersionComputer(strategy);\n  computer.computeVersionInfo(context).then(versionInfo => {\n    fs.writeFileSync('~version.json', versionInfo.toJson());\n    console.log('Version computed:', versionInfo.version, '(commit:', versionInfo.commitHashShort + ')');\n  }).catch(error => {\n    console.error('Error computing version:', error.message);\n    const fallback = {\n      version: '0.0.0',\n      commitHash: 'unknown',\n      commitHashShort: 'unknown',\n      branch: 'unknown',\n      commitCount: 0,\n      packageVersion: '0.0.0',\n      deployedAt: new Date().toISOString(),\n      deployedBy: 'unknown',\n      environment: 'unknown'\n    };\n    fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));\n  });\n} catch (e) {\n  console.error('Error in version computation:', e.message);\n  const fallback = {\n    version: '0.0.0',\n    commitHash: 'unknown',\n    commitHashShort: 'unknown',\n    branch: 'unknown',\n    commitCount: 0,\n    packageVersion: '0.0.0',\n    deployedAt: new Date().toISOString(),\n    deployedBy: 'unknown',\n    environment: 'unknown'\n  };\n  fs.writeFileSync('~version.json', JSON.stringify(fallback, null, 2));\n}\"`;\n  }\n}\n"]}

package/lib/versioning/strategy.d.ts

@@ -0,0 +1,21 @@
+import { GitTagConfig, PackageJsonConfig, CommitCountConfig, IVersioningStrategy, VersioningStrategyComponents, BuildNumberConfig } from './types';
+/**
+ * Composite versioning strategy that combines multiple strategies
+ */
+export declare class VersioningStrategy implements IVersioningStrategy {
+    readonly format: string;
+    readonly components: VersioningStrategyComponents;
+    /**
+     * Create a composite strategy with custom format and components
+     */
+    static create(format: string, components: VersioningStrategyComponents): VersioningStrategy;
+    /**
+     * Create a build number based strategy
+     */
+    static buildNumber(config?: BuildNumberConfig): VersioningStrategy;
+    static gitTag(config?: GitTagConfig): VersioningStrategy;
+    static packageJson(config?: PackageJsonConfig): VersioningStrategy;
+    static commitCount(config?: CommitCountConfig): VersioningStrategy;
+    static commitHash(): VersioningStrategy;
+    private constructor();
+}

package/lib/versioning/strategy.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningStrategy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Composite versioning strategy that combines multiple strategies
+ */
+class VersioningStrategy {
+    /**
+     * Create a composite strategy with custom format and components
+     */
+    static create(format, components) {
+        return new VersioningStrategy(format, components);
+    }
+    /**
+     * Create a build number based strategy
+     */
+    static buildNumber(config) {
+        const prefix = config?.prefix ?? 'build';
+        return new VersioningStrategy(`${prefix}-{commit-count}-{commit-hash:8}`, {
+            commitCount: config?.commitCount ?? { countFrom: 'all', padding: 5 },
+        });
+    }
+    static gitTag(config) {
+        return new VersioningStrategy('{git-tag}', {
+            gitTag: config ?? { stripPrefix: 'v' },
+            commitCount: { countFrom: 'all' },
+        });
+    }
+    static packageJson(config) {
+        return new VersioningStrategy('{package-version}', { packageJson: config ?? {} });
+    }
+    static commitCount(config) {
+        return new VersioningStrategy('{commit-count}', {
+            commitCount: config ?? { countFrom: 'all' },
+        });
+    }
+    static commitHash() {
+        return new VersioningStrategy('{commit-hash}', {});
+    }
+    constructor(format, components) {
+        this.format = format;
+        this.components = components;
+        //
+    }
+}
+exports.VersioningStrategy = VersioningStrategy;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningStrategy[_a] = { fqn: "projen-pipelines.VersioningStrategy", version: "0.2.14" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/types.d.ts

@@ -0,0 +1,183 @@
+export type StageOverrides = {
+    [stage: string]: VersioningConfig;
+};
+export interface VersioningConfig {
+    /**
+     * Enable versioning feature
+     * @default true
+     */
+    readonly enabled: boolean;
+    /**
+     * Primary versioning strategy
+     */
+    readonly strategy: IVersioningStrategy;
+    /**
+     * Output configuration
+     */
+    readonly outputs: VersioningOutputConfig;
+    /**
+     * Stage-specific overrides
+     */
+    readonly stageOverrides?: StageOverrides;
+}
+export interface VersioningStrategyComponents {
+    readonly gitTag?: GitTagConfig;
+    readonly packageJson?: PackageJsonConfig;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface IVersioningStrategy {
+    /**
+     * Version format template
+     * Variables: {git-tag}, {package-version}, {commit-count}, {commit-hash},
+     *            {commit-hash:8}, {branch}, {build-number}
+     */
+    readonly format: string;
+    /**
+     * Components to include
+     */
+    readonly components: VersioningStrategyComponents;
+}
+export interface GitTagConfig {
+    /**
+     * Only use annotated tags
+     */
+    readonly annotatedOnly?: boolean;
+    /**
+     * Tag pattern to match
+     */
+    readonly pattern?: string;
+    /**
+     * Strip prefix from tag
+     */
+    readonly stripPrefix?: string;
+    /**
+     * Include commits since tag
+     */
+    readonly includeSinceTag?: boolean;
+}
+export interface PackageJsonConfig {
+    /**
+     * Path to package.json
+     */
+    readonly path?: string;
+    /**
+     * Include pre-release version
+     */
+    readonly includePrerelease?: boolean;
+    /**
+     * Append commit info
+     */
+    readonly appendCommitInfo?: boolean;
+}
+export interface CommitCountConfig {
+    /**
+     * Count from: 'all' | 'branch' | 'since-tag'
+     */
+    readonly countFrom?: 'all' | 'branch' | 'since-tag';
+    /**
+     * Include branch name
+     */
+    readonly includeBranch?: boolean;
+    /**
+     * Reset on major version
+     */
+    readonly resetOnMajor?: boolean;
+    /**
+     * Padding for count
+     */
+    readonly padding?: number;
+}
+export interface VersioningOutputConfig {
+    /**
+     * Output to CloudFormation stack outputs
+     * @default true
+     */
+    readonly cloudFormation: CloudFormationOutputConfig;
+    /**
+     * Output to SSM Parameter Store
+     * @default false
+     */
+    readonly parameterStore: ParameterStoreConfig;
+}
+export interface CloudFormationOutputConfig {
+    readonly enabled: boolean;
+    readonly exportName?: string;
+}
+export interface ParameterStoreConfig {
+    readonly enabled: boolean;
+    readonly parameterName?: string;
+    readonly description?: string;
+    readonly allowOverwrite?: boolean;
+    readonly splitParameters?: boolean;
+    readonly hierarchical?: boolean;
+}
+export interface BuildNumberConfig {
+    readonly prefix?: string;
+    readonly commitCount?: CommitCountConfig;
+}
+export interface GitInfoInput {
+    readonly commitHash: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+}
+export interface DeploymentInfoInput {
+    readonly environment: string;
+    readonly deployedBy?: string;
+    readonly buildNumber?: string;
+}
+export interface StandardConfigOptions {
+    readonly parameterStore?: boolean | string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface CloudFormationOnlyOptions {
+    readonly format?: 'plain' | 'structured';
+    readonly stackOutputName?: string;
+    readonly exportName?: string;
+}
+export interface HierarchicalParametersOptions {
+    readonly includeCloudFormation?: boolean;
+    readonly format?: 'plain' | 'structured';
+}
+export interface StandardOutputOptions {
+    readonly parameterName?: string;
+    readonly format?: 'plain' | 'structured';
+}
+export interface IVersionInfo {
+    /**
+     * Primary version string
+     */
+    readonly version: string;
+    /**
+     * Git information (ALWAYS included)
+     */
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    /**
+     * Optional git tag information
+     */
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    /**
+     * Commit count information
+     */
+    readonly commitCount: number;
+    /**
+     * Package.json information (if applicable)
+     */
+    readonly packageVersion?: string;
+    /**
+     * Deployment metadata
+     */
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    /**
+     * Additional metadata
+     */
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+}

package/lib/versioning/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/version-info.d.ts

@@ -0,0 +1,106 @@
+import { IVersionInfo, GitInfoInput, DeploymentInfoInput } from './types';
+/**
+ * Represents complete version information for a deployment
+ */
+export declare class VersionInfo implements IVersionInfo {
+    /**
+     * Create a VersionInfo instance from raw data
+     */
+    static create(props: IVersionInfo): VersionInfo;
+    /**
+     * Create a VersionInfo instance from environment variables
+     */
+    static fromEnvironment(env: {
+        [key: string]: string;
+    }): VersionInfo;
+    /**
+     * Create a VersionInfo instance from a JSON string
+     */
+    static fromJson(json: string): VersionInfo;
+    readonly version: string;
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+    readonly packageVersion?: string;
+    readonly deployedAt: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly environment: string;
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+    private constructor();
+    /**
+     * Convert to plain version string
+     */
+    toString(): string;
+    /**
+     * Convert to JSON string
+     */
+    toJson(pretty?: boolean): string;
+    /**
+     * Convert to object
+     */
+    toObject(): IVersionInfo;
+    /**
+     * Get formatted version for display
+     */
+    displayVersion(): string;
+    /**
+     * Check if this version is from a tagged release
+     */
+    taggedRelease(): boolean;
+    /**
+     * Check if this version is from the main branch
+     */
+    mainBranch(): boolean;
+    /**
+     * Compare with another version
+     * Returns: -1 if this < other, 0 if equal, 1 if this > other
+     */
+    compare(other: VersionInfo): number;
+    /**
+     * Create a parameter name for SSM Parameter Store
+     */
+    parameterName(template: string): string;
+    /**
+     * Create CloudFormation export name
+     */
+    exportName(template: string): string;
+}
+/**
+ * Builder class for creating VersionInfo instances
+ */
+export declare class VersionInfoBuilder {
+    private props;
+    /**
+     * Set the version string
+     */
+    version(version: string): this;
+    /**
+     * Set git information
+     */
+    gitInfo(info: GitInfoInput): this;
+    /**
+     * Set package version
+     */
+    packageVersion(version: string): this;
+    /**
+     * Set deployment metadata
+     */
+    deploymentInfo(info: DeploymentInfoInput): this;
+    /**
+     * Set repository information
+     */
+    repository(repo: string): this;
+    /**
+     * Set pipeline version
+     */
+    pipelineVersion(version: string): this;
+    /**
+     * Build the VersionInfo instance
+     */
+    create(): VersionInfo;
+}