projen-pipelines 0.2.11 → 0.2.13

package/lib/versioning/computation.d.ts

@@ -0,0 +1,63 @@
+import { VersioningStrategy } from './strategy';
+import { IVersioningStrategy } from './types';
+import { VersionInfo } from './version-info';
+/**
+ * Git information extracted from repository
+ */
+export interface GitInfo {
+    readonly commitHash: string;
+    readonly commitHashShort: string;
+    readonly branch: string;
+    readonly tag?: string;
+    readonly commitsSinceTag?: number;
+    readonly commitCount: number;
+    readonly packageVersion?: string;
+}
+/**
+ * Context for version computation
+ */
+export interface ComputationContext {
+    readonly gitInfo: GitInfo;
+    readonly environment: string;
+    readonly deployedBy: string;
+    readonly buildNumber?: string;
+    readonly repository?: string;
+    readonly pipelineVersion?: string;
+}
+/**
+ * Base class for version computation strategies
+ */
+export declare abstract class VersionComputationStrategy {
+    readonly strategy: VersioningStrategy;
+    protected constructor(strategy: VersioningStrategy);
+    /**
+     * Compute version string from context
+     */
+    abstract computeVersion(context: ComputationContext): string;
+    /**
+     * Create VersionInfo from context
+     */
+    createVersionInfo(context: ComputationContext): VersionInfo;
+}
+/**
+ * Composite version computation that combines multiple strategies
+ */
+export declare class CompositeComputation extends VersionComputationStrategy {
+    constructor(strategy: VersioningStrategy);
+    computeVersion(context: ComputationContext): string;
+}
+/**
+ * Main version computer that handles strategy selection
+ */
+export declare class VersionComputer {
+    private readonly strategy;
+    constructor(strategy: IVersioningStrategy);
+    /**
+     * Compute version info from context
+     */
+    computeVersionInfo(context: ComputationContext): Promise<VersionInfo>;
+    /**
+     * Create strategy instance from configuration
+     */
+    private createStrategy;
+}

package/lib/versioning/computation.js

@@ -0,0 +1,121 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionComputer = exports.CompositeComputation = exports.VersionComputationStrategy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const version_info_1 = require("./version-info");
+/**
+ * Base class for version computation strategies
+ */
+class VersionComputationStrategy {
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * Create VersionInfo from context
+     */
+    createVersionInfo(context) {
+        const version = this.computeVersion(context);
+        return version_info_1.VersionInfo.create({
+            version,
+            commitHash: context.gitInfo.commitHash,
+            commitHashShort: context.gitInfo.commitHashShort,
+            branch: context.gitInfo.branch,
+            tag: context.gitInfo.tag,
+            commitsSinceTag: context.gitInfo.commitsSinceTag,
+            commitCount: context.gitInfo.commitCount,
+            packageVersion: context.gitInfo.packageVersion,
+            deployedAt: new Date().toISOString(),
+            deployedBy: context.deployedBy,
+            buildNumber: context.buildNumber,
+            environment: context.environment,
+            repository: context.repository,
+            pipelineVersion: context.pipelineVersion,
+        });
+    }
+}
+exports.VersionComputationStrategy = VersionComputationStrategy;
+_a = JSII_RTTI_SYMBOL_1;
+VersionComputationStrategy[_a] = { fqn: "projen-pipelines.VersionComputationStrategy", version: "0.2.13" };
+/**
+ * Composite version computation that combines multiple strategies
+ */
+class CompositeComputation extends VersionComputationStrategy {
+    constructor(strategy) {
+        super(strategy);
+    }
+    computeVersion(context) {
+        let result = this.strategy.format;
+        const { gitInfo } = context;
+        // Replace git tag variables
+        if (this.strategy.components.gitTag) {
+            let tagValue = gitInfo.tag ?? '0.0.0';
+            if (this.strategy.components.gitTag.stripPrefix && gitInfo.tag) {
+                tagValue = gitInfo.tag.replace(new RegExp(`^${this.strategy.components.gitTag.stripPrefix}`), '');
+            }
+            result = result.replace('{git-tag}', tagValue);
+        }
+        // Replace package version
+        if (this.strategy.components.packageJson) {
+            const packageValue = gitInfo.packageVersion ?? '0.0.0';
+            result = result.replace('{package-version}', packageValue);
+        }
+        // Replace commit count
+        if (this.strategy.components.commitCount) {
+            let countValue;
+            if (this.strategy.components.commitCount.countFrom === 'since-tag' && gitInfo.commitsSinceTag !== undefined) {
+                countValue = gitInfo.commitsSinceTag.toString();
+            }
+            else {
+                // Default to total commit count for 'all' or undefined
+                countValue = gitInfo.commitCount.toString();
+            }
+            if (this.strategy.components.commitCount.padding) {
+                countValue = countValue.padStart(this.strategy.components.commitCount.padding, '0');
+            }
+            result = result.replace('{commit-count}', countValue);
+        }
+        // Replace commit hash
+        result = result.replace('{commit-hash}', gitInfo.commitHash);
+        result = result.replace('{commit-hash:8}', gitInfo.commitHashShort);
+        // Replace branch
+        result = result.replace('{branch}', gitInfo.branch);
+        // Replace build number
+        if (context.buildNumber) {
+            result = result.replace('{build-number}', context.buildNumber);
+        }
+        return result;
+    }
+}
+exports.CompositeComputation = CompositeComputation;
+_b = JSII_RTTI_SYMBOL_1;
+CompositeComputation[_b] = { fqn: "projen-pipelines.CompositeComputation", version: "0.2.13" };
+/**
+ * Main version computer that handles strategy selection
+ */
+class VersionComputer {
+    constructor(strategy) {
+        this.strategy = this.createStrategy(strategy);
+    }
+    /**
+     * Compute version info from context
+     */
+    async computeVersionInfo(context) {
+        try {
+            return this.strategy.createVersionInfo(context);
+        }
+        catch (error) {
+            throw new Error(`Strategy '${this.strategy.strategy.format}' failed: ${error}`);
+        }
+    }
+    /**
+     * Create strategy instance from configuration
+     */
+    createStrategy(strategy) {
+        return new CompositeComputation(strategy);
+    }
+}
+exports.VersionComputer = VersionComputer;
+_c = JSII_RTTI_SYMBOL_1;
+VersionComputer[_c] = { fqn: "projen-pipelines.VersionComputer", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computation.js","sourceRoot":"","sources":["../../src/versioning/computation.ts"],"names":[],"mappings":";;;;;AAEA,iDAA6C;AA2B7C;;GAEG;AACH,MAAsB,0BAA0B;IAC9C,YAAsC,QAA4B;QAA5B,aAAQ,GAAR,QAAQ,CAAoB;IAAI,CAAC;IAOvE;;OAEG;IACI,iBAAiB,CAAC,OAA2B;QAClD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAE7C,OAAO,0BAAW,CAAC,MAAM,CAAC;YACxB,OAAO;YACP,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU;YACtC,eAAe,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe;YAChD,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,MAAM;YAC9B,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG;YACxB,eAAe,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe;YAChD,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,WAAW;YACxC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,cAAc;YAC9C,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACpC,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,eAAe,EAAE,OAAO,CAAC,eAAe;SACzC,CAAC,CAAC;IACL,CAAC;;AA9BH,gEA+BC;;;AAGD;;GAEG;AACH,MAAa,oBAAqB,SAAQ,0BAA0B;IAClE,YACE,QAA4B;QAE5B,KAAK,CAAC,QAAQ,CAAC,CAAC;IAClB,CAAC;IAEM,cAAc,CAAC,OAA2B;QAC/C,IAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QAClC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAE5B,4BAA4B;QAC5B,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YACpC,IAAI,QAAQ,GAAG,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC;YACtC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;gBAC/D,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;YACpG,CAAC;YACD,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACjD,CAAC;QAED,0BAA0B;QAC1B,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;YACzC,MAAM,YAAY,GAAG,OAAO,CAAC,cAAc,IAAI,OAAO,CAAC;YACvD,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAC;QAC7D,CAAC;QAED,uBAAuB;QACvB,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;YACzC,IAAI,UAAkB,CAAC;YACvB,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,KAAK,WAAW,IAAI,OAAO,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;gBAC5G,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;YAClD,CAAC;iBAAM,CAAC;gBACN,uDAAuD;gBACvD,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;YAC9C,CAAC;YACD,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;gBACjD,UAAU,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YACtF,CAAC;YACD,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;QACxD,CAAC;QAED,sBAAsB;QACtB,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,eAAe,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QAC7D,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,iBAAiB,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;QAEpE,iBAAiB;QACjB,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAEpD,uBAAuB;QACvB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACxB,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QACjE,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;;AAtDH,oDAuDC;;;AAED;;GAEG;AACH,MAAa,eAAe;IAG1B,YACE,QAA6B;QAE7B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,kBAAkB,CAAC,OAA2B;QACzD,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAClD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,aAAa,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,aAAa,KAAK,EAAE,CAAC,CAAC;QAClF,CAAC;IACH,CAAC;IAED;;OAEG;IACK,cAAc,CAAC,QAA6B;QAClD,OAAO,IAAI,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;;AAzBH,0CA0BC","sourcesContent":["import { VersioningStrategy } from './strategy';\nimport { IVersioningStrategy } from './types';\nimport { VersionInfo } from './version-info';\n\n/**\n * Git information extracted from repository\n */\nexport interface GitInfo {\n  readonly commitHash: string;\n  readonly commitHashShort: string;\n  readonly branch: string;\n  readonly tag?: string;\n  readonly commitsSinceTag?: number;\n  readonly commitCount: number;\n  readonly packageVersion?: string;\n}\n\n/**\n * Context for version computation\n */\nexport interface ComputationContext {\n  readonly gitInfo: GitInfo;\n  readonly environment: string;\n  readonly deployedBy: string;\n  readonly buildNumber?: string;\n  readonly repository?: string;\n  readonly pipelineVersion?: string;\n}\n\n/**\n * Base class for version computation strategies\n */\nexport abstract class VersionComputationStrategy {\n  protected constructor(public readonly strategy: VersioningStrategy) { }\n\n  /**\n   * Compute version string from context\n   */\n  abstract computeVersion(context: ComputationContext): string;\n\n  /**\n   * Create VersionInfo from context\n   */\n  public createVersionInfo(context: ComputationContext): VersionInfo {\n    const version = this.computeVersion(context);\n\n    return VersionInfo.create({\n      version,\n      commitHash: context.gitInfo.commitHash,\n      commitHashShort: context.gitInfo.commitHashShort,\n      branch: context.gitInfo.branch,\n      tag: context.gitInfo.tag,\n      commitsSinceTag: context.gitInfo.commitsSinceTag,\n      commitCount: context.gitInfo.commitCount,\n      packageVersion: context.gitInfo.packageVersion,\n      deployedAt: new Date().toISOString(),\n      deployedBy: context.deployedBy,\n      buildNumber: context.buildNumber,\n      environment: context.environment,\n      repository: context.repository,\n      pipelineVersion: context.pipelineVersion,\n    });\n  }\n}\n\n\n/**\n * Composite version computation that combines multiple strategies\n */\nexport class CompositeComputation extends VersionComputationStrategy {\n  constructor(\n    strategy: VersioningStrategy,\n  ) {\n    super(strategy);\n  }\n\n  public computeVersion(context: ComputationContext): string {\n    let result = this.strategy.format;\n    const { gitInfo } = context;\n\n    // Replace git tag variables\n    if (this.strategy.components.gitTag) {\n      let tagValue = gitInfo.tag ?? '0.0.0';\n      if (this.strategy.components.gitTag.stripPrefix && gitInfo.tag) {\n        tagValue = gitInfo.tag.replace(new RegExp(`^${this.strategy.components.gitTag.stripPrefix}`), '');\n      }\n      result = result.replace('{git-tag}', tagValue);\n    }\n\n    // Replace package version\n    if (this.strategy.components.packageJson) {\n      const packageValue = gitInfo.packageVersion ?? '0.0.0';\n      result = result.replace('{package-version}', packageValue);\n    }\n\n    // Replace commit count\n    if (this.strategy.components.commitCount) {\n      let countValue: string;\n      if (this.strategy.components.commitCount.countFrom === 'since-tag' && gitInfo.commitsSinceTag !== undefined) {\n        countValue = gitInfo.commitsSinceTag.toString();\n      } else {\n        // Default to total commit count for 'all' or undefined\n        countValue = gitInfo.commitCount.toString();\n      }\n      if (this.strategy.components.commitCount.padding) {\n        countValue = countValue.padStart(this.strategy.components.commitCount.padding, '0');\n      }\n      result = result.replace('{commit-count}', countValue);\n    }\n\n    // Replace commit hash\n    result = result.replace('{commit-hash}', gitInfo.commitHash);\n    result = result.replace('{commit-hash:8}', gitInfo.commitHashShort);\n\n    // Replace branch\n    result = result.replace('{branch}', gitInfo.branch);\n\n    // Replace build number\n    if (context.buildNumber) {\n      result = result.replace('{build-number}', context.buildNumber);\n    }\n\n    return result;\n  }\n}\n\n/**\n * Main version computer that handles strategy selection\n */\nexport class VersionComputer {\n  private readonly strategy: VersionComputationStrategy;\n\n  constructor(\n    strategy: IVersioningStrategy,\n  ) {\n    this.strategy = this.createStrategy(strategy);\n  }\n\n  /**\n   * Compute version info from context\n   */\n  public async computeVersionInfo(context: ComputationContext): Promise<VersionInfo> {\n    try {\n      return this.strategy.createVersionInfo(context);\n    } catch (error) {\n      throw new Error(`Strategy '${this.strategy.strategy.format}' failed: ${error}`);\n    }\n  }\n\n  /**\n   * Create strategy instance from configuration\n   */\n  private createStrategy(strategy: IVersioningStrategy): VersionComputationStrategy {\n    return new CompositeComputation(strategy);\n  }\n}\n"]}

package/lib/versioning/config.d.ts

@@ -0,0 +1,41 @@
+import { VersioningConfig, IVersioningStrategy, StandardConfigOptions, VersioningOutputConfig, StageOverrides } from './types';
+export interface CustomVersioningConfig {
+    readonly enabled?: boolean;
+    readonly strategy: IVersioningStrategy;
+    readonly outputs: VersioningOutputConfig;
+    readonly stageOverrides?: StageOverrides;
+}
+/**
+ * Main versioning configuration class with factory methods
+ */
+export declare class VersioningConfigurations {
+    /**
+     * Standard configuration with commit count strategy
+     */
+    static standard(options?: StandardConfigOptions): VersioningConfig;
+    /**
+     * Minimal configuration for testing
+     */
+    static minimal(): VersioningConfig;
+    /**
+     * Create a custom configuration
+     */
+    static custom(config: CustomVersioningConfig): VersioningConfig;
+}
+/**
+ * Utility functions for versioning configuration
+ */
+export declare class VersioningConfigUtils {
+    /**
+     * Resolve configuration for a specific stage
+     */
+    static resolveForStage(config: VersioningConfig, stage: string): VersioningConfig;
+    /**
+     * Validate configuration
+     */
+    static validate(config: VersioningConfig): string[];
+    /**
+     * Get default configuration
+     */
+    static default(): VersioningConfig;
+}

package/lib/versioning/config.js

@@ -0,0 +1,91 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningConfigUtils = exports.VersioningConfigurations = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const outputs_1 = require("./outputs");
+const strategy_1 = require("./strategy");
+/**
+ * Main versioning configuration class with factory methods
+ */
+class VersioningConfigurations {
+    /**
+     * Standard configuration with commit count strategy
+     */
+    static standard(options) {
+        return {
+            enabled: true,
+            strategy: strategy_1.VersioningStrategy.commitCount(),
+            outputs: outputs_1.VersioningOutputs.standard({
+                parameterName: typeof options?.parameterStore === 'string' ? options.parameterStore : undefined,
+                format: options?.format,
+            }),
+        };
+    }
+    /**
+     * Minimal configuration for testing
+     */
+    static minimal() {
+        return {
+            enabled: true,
+            strategy: strategy_1.VersioningStrategy.commitHash(),
+            outputs: outputs_1.VersioningOutputs.minimal(),
+        };
+    }
+    /**
+     * Create a custom configuration
+     */
+    static custom(config) {
+        return {
+            enabled: config.enabled ?? true,
+            strategy: config.strategy,
+            outputs: config.outputs,
+            stageOverrides: config.stageOverrides,
+        };
+    }
+}
+exports.VersioningConfigurations = VersioningConfigurations;
+_a = JSII_RTTI_SYMBOL_1;
+VersioningConfigurations[_a] = { fqn: "projen-pipelines.VersioningConfigurations", version: "0.2.13" };
+/**
+ * Utility functions for versioning configuration
+ */
+class VersioningConfigUtils {
+    /**
+     * Resolve configuration for a specific stage
+     */
+    static resolveForStage(config, stage) {
+        const stageOverride = config.stageOverrides?.[stage];
+        if (!stageOverride) {
+            return config;
+        }
+        return {
+            ...config,
+            ...stageOverride,
+            outputs: stageOverride.outputs ? { ...config.outputs, ...stageOverride.outputs } : config.outputs,
+        };
+    }
+    /**
+     * Validate configuration
+     */
+    static validate(config) {
+        const errors = [];
+        if (!config.strategy) {
+            errors.push('Strategy is required');
+        }
+        if (!config.outputs) {
+            errors.push('Outputs configuration is required');
+        }
+        return errors;
+    }
+    /**
+     * Get default configuration
+     */
+    static default() {
+        return VersioningConfigurations.standard();
+    }
+}
+exports.VersioningConfigUtils = VersioningConfigUtils;
+_b = JSII_RTTI_SYMBOL_1;
+VersioningConfigUtils[_b] = { fqn: "projen-pipelines.VersioningConfigUtils", version: "0.2.13" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/versioning/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export { VersionInfo, VersionInfoBuilder } from './version-info';
+export { VersioningStrategy, } from './strategy';
+export { OutputConfigBase, CloudFormationOutput, ParameterStoreOutput, OutputFormat, VersioningOutputs, } from './outputs';
+export { GitInfo, ComputationContext, VersionComputationStrategy, CompositeComputation, VersionComputer, } from './computation';
+export { CustomVersioningConfig, VersioningConfigurations, VersioningConfigUtils, } from './config';
+export { VersioningSetup, } from './setup';

package/lib/versioning/index.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersioningSetup = exports.VersioningConfigUtils = exports.VersioningConfigurations = exports.VersionComputer = exports.CompositeComputation = exports.VersionComputationStrategy = exports.VersioningOutputs = exports.OutputFormat = exports.ParameterStoreOutput = exports.CloudFormationOutput = exports.OutputConfigBase = exports.VersioningStrategy = exports.VersionInfoBuilder = exports.VersionInfo = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Version Information
+var version_info_1 = require("./version-info");
+Object.defineProperty(exports, "VersionInfo", { enumerable: true, get: function () { return version_info_1.VersionInfo; } });
+Object.defineProperty(exports, "VersionInfoBuilder", { enumerable: true, get: function () { return version_info_1.VersionInfoBuilder; } });
+// Strategies
+var strategy_1 = require("./strategy");
+Object.defineProperty(exports, "VersioningStrategy", { enumerable: true, get: function () { return strategy_1.VersioningStrategy; } });
+// Outputs
+var outputs_1 = require("./outputs");
+Object.defineProperty(exports, "OutputConfigBase", { enumerable: true, get: function () { return outputs_1.OutputConfigBase; } });
+Object.defineProperty(exports, "CloudFormationOutput", { enumerable: true, get: function () { return outputs_1.CloudFormationOutput; } });
+Object.defineProperty(exports, "ParameterStoreOutput", { enumerable: true, get: function () { return outputs_1.ParameterStoreOutput; } });
+Object.defineProperty(exports, "OutputFormat", { enumerable: true, get: function () { return outputs_1.OutputFormat; } });
+Object.defineProperty(exports, "VersioningOutputs", { enumerable: true, get: function () { return outputs_1.VersioningOutputs; } });
+// Computation
+var computation_1 = require("./computation");
+Object.defineProperty(exports, "VersionComputationStrategy", { enumerable: true, get: function () { return computation_1.VersionComputationStrategy; } });
+Object.defineProperty(exports, "CompositeComputation", { enumerable: true, get: function () { return computation_1.CompositeComputation; } });
+Object.defineProperty(exports, "VersionComputer", { enumerable: true, get: function () { return computation_1.VersionComputer; } });
+// Configuration
+var config_1 = require("./config");
+Object.defineProperty(exports, "VersioningConfigurations", { enumerable: true, get: function () { return config_1.VersioningConfigurations; } });
+Object.defineProperty(exports, "VersioningConfigUtils", { enumerable: true, get: function () { return config_1.VersioningConfigUtils; } });
+// Setup
+var setup_1 = require("./setup");
+Object.defineProperty(exports, "VersioningSetup", { enumerable: true, get: function () { return setup_1.VersioningSetup; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdmVyc2lvbmluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLFFBQVE7QUFDUiwwQ0FBd0I7QUFFeEIsc0JBQXNCO0FBQ3RCLCtDQUFpRTtBQUF4RCwyR0FBQSxXQUFXLE9BQUE7QUFBRSxrSEFBQSxrQkFBa0IsT0FBQTtBQUV4QyxhQUFhO0FBQ2IsdUNBRW9CO0FBRGxCLDhHQUFBLGtCQUFrQixPQUFBO0FBR3BCLFVBQVU7QUFDVixxQ0FNbUI7QUFMakIsMkdBQUEsZ0JBQWdCLE9BQUE7QUFDaEIsK0dBQUEsb0JBQW9CLE9BQUE7QUFDcEIsK0dBQUEsb0JBQW9CLE9BQUE7QUFDcEIsdUdBQUEsWUFBWSxPQUFBO0FBQ1osNEdBQUEsaUJBQWlCLE9BQUE7QUFHbkIsY0FBYztBQUNkLDZDQU11QjtBQUhyQix5SEFBQSwwQkFBMEIsT0FBQTtBQUMxQixtSEFBQSxvQkFBb0IsT0FBQTtBQUNwQiw4R0FBQSxlQUFlLE9BQUE7QUFHakIsZ0JBQWdCO0FBQ2hCLG1DQUlrQjtBQUZoQixrSEFBQSx3QkFBd0IsT0FBQTtBQUN4QiwrR0FBQSxxQkFBcUIsT0FBQTtBQUd2QixRQUFRO0FBQ1IsaUNBRWlCO0FBRGYsd0dBQUEsZUFBZSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gVHlwZXNcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuXG4vLyBWZXJzaW9uIEluZm9ybWF0aW9uXG5leHBvcnQgeyBWZXJzaW9uSW5mbywgVmVyc2lvbkluZm9CdWlsZGVyIH0gZnJvbSAnLi92ZXJzaW9uLWluZm8nO1xuXG4vLyBTdHJhdGVnaWVzXG5leHBvcnQge1xuICBWZXJzaW9uaW5nU3RyYXRlZ3ksXG59IGZyb20gJy4vc3RyYXRlZ3knO1xuXG4vLyBPdXRwdXRzXG5leHBvcnQge1xuICBPdXRwdXRDb25maWdCYXNlLFxuICBDbG91ZEZvcm1hdGlvbk91dHB1dCxcbiAgUGFyYW1ldGVyU3RvcmVPdXRwdXQsXG4gIE91dHB1dEZvcm1hdCxcbiAgVmVyc2lvbmluZ091dHB1dHMsXG59IGZyb20gJy4vb3V0cHV0cyc7XG5cbi8vIENvbXB1dGF0aW9uXG5leHBvcnQge1xuICBHaXRJbmZvLFxuICBDb21wdXRhdGlvbkNvbnRleHQsXG4gIFZlcnNpb25Db21wdXRhdGlvblN0cmF0ZWd5LFxuICBDb21wb3NpdGVDb21wdXRhdGlvbixcbiAgVmVyc2lvbkNvbXB1dGVyLFxufSBmcm9tICcuL2NvbXB1dGF0aW9uJztcblxuLy8gQ29uZmlndXJhdGlvblxuZXhwb3J0IHtcbiAgQ3VzdG9tVmVyc2lvbmluZ0NvbmZpZyxcbiAgVmVyc2lvbmluZ0NvbmZpZ3VyYXRpb25zLFxuICBWZXJzaW9uaW5nQ29uZmlnVXRpbHMsXG59IGZyb20gJy4vY29uZmlnJztcblxuLy8gU2V0dXBcbmV4cG9ydCB7XG4gIFZlcnNpb25pbmdTZXR1cCxcbn0gZnJvbSAnLi9zZXR1cCc7XG4iXX0=

package/lib/versioning/outputs.d.ts

@@ -0,0 +1,87 @@
+import { CloudFormationOutputConfig, ParameterStoreConfig, VersioningOutputConfig, StandardOutputOptions, CloudFormationOnlyOptions, HierarchicalParametersOptions } from './types';
+/**
+ * Base class for output configurations
+ */
+export declare abstract class OutputConfigBase {
+    readonly type: string;
+    protected constructor(type: string);
+    /**
+     * Convert to configuration object
+     */
+    abstract toConfig(): any;
+}
+/**
+ * CloudFormation output configuration
+ */
+export declare class CloudFormationOutput extends OutputConfigBase {
+    private readonly config?;
+    static readonly TYPE = "cloudformation";
+    /**
+     * Enable CloudFormation outputs with default configuration
+     */
+    static enabled(): CloudFormationOutput;
+    /**
+     * Disable CloudFormation outputs
+     */
+    static disabled(): CloudFormationOutput;
+    /**
+     * Configure CloudFormation outputs with custom settings
+     */
+    static withConfig(config: CloudFormationOutputConfig): CloudFormationOutput;
+    private constructor();
+    toConfig(): any;
+}
+/**
+ * SSM Parameter Store output configuration
+ */
+export declare class ParameterStoreOutput extends OutputConfigBase {
+    private readonly config?;
+    static readonly TYPE = "parameterStore";
+    /**
+     * Enable Parameter Store outputs with parameter name
+     */
+    static enabled(parameterName: string): ParameterStoreOutput;
+    /**
+     * Disable Parameter Store outputs
+     */
+    static disabled(): ParameterStoreOutput;
+    /**
+     * Configure Parameter Store outputs with custom settings
+     */
+    static withConfig(config: ParameterStoreConfig): ParameterStoreOutput;
+    /**
+     * Configure Parameter Store with hierarchical parameters
+     */
+    static hierarchical(basePath: string, options?: HierarchicalParametersOptions): ParameterStoreOutput;
+    private constructor();
+    toConfig(): any;
+}
+/**
+ * Output format types
+ */
+export declare class OutputFormat {
+    static readonly PLAIN: "plain";
+    static readonly STRUCTURED: "structured";
+    private constructor();
+}
+/**
+ * Factory class for output configurations
+ */
+export declare class VersioningOutputs {
+    /**
+     * Create output configuration with CloudFormation and SSM Parameter Store
+     */
+    static standard(options?: StandardOutputOptions): VersioningOutputConfig;
+    /**
+     * Create output configuration with only CloudFormation
+     */
+    static cloudFormationOnly(options?: CloudFormationOnlyOptions): VersioningOutputConfig;
+    /**
+     * Create output configuration with hierarchical SSM parameters
+     */
+    static hierarchicalParameters(basePath: string, options?: HierarchicalParametersOptions): VersioningOutputConfig;
+    /**
+     * Create minimal output configuration (CloudFormation only, plain format)
+     */
+    static minimal(): VersioningOutputConfig;
+}