@fjall/deploy-core 0.89.2

package/dist/src/types/deployment/DeploymentTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/deployment/cloudformation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Individual CloudFormation stack output (matches AWS CloudFormation Output structure)
+ */
+export interface StackOutput {
+    OutputKey: string;
+    OutputValue: string;
+    Description?: string;
+    ExportName?: string;
+}
+/**
+ * Stack outputs as a record for convenient access
+ * Values can be string, number, or boolean based on common CloudFormation output types
+ */
+export type StackOutputsRecord = Record<string, string | number | boolean>;

package/dist/src/types/deployment/cloudformation.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/deployment/index.d.ts

@@ -0,0 +1,5 @@
+export type { StackOutput, StackOutputsRecord } from "./cloudformation.js";
+export type { DeploymentContext, StepOutput } from "./DeploymentTypes.js";
+export type { ApplicationDeploymentContext, CallerIdentity, ValidationResult } from "./DeploymentServiceTypes.js";
+export type { ParallelDeploymentResult, ParallelDeployGroup, ParallelOperation, ParallelOperationType, ParallelOperationState } from "./parallel.js";
+export { PARALLEL_OPERATION_TYPES } from "./parallel.js";

package/dist/src/types/deployment/index.js

@@ -0,0 +1 @@
+export { PARALLEL_OPERATION_TYPES } from "./parallel.js";

package/dist/src/types/deployment/parallel.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Type definitions for parallel deployment operations
+ */
+import type { ApplicationStack } from "../operations.js";
+/**
+ * Special parallel operations that aren't CloudFormation stacks
+ */
+export declare const PARALLEL_OPERATION_TYPES: {
+    readonly BUILD: "build";
+    readonly DOCKER: "docker";
+};
+export type ParallelOperationType = (typeof PARALLEL_OPERATION_TYPES)[keyof typeof PARALLEL_OPERATION_TYPES];
+/**
+ * Union type for all operations that can run in parallel
+ */
+export type ParallelOperation = ApplicationStack | ParallelOperationType;
+/**
+ * A group of stacks that can be deployed in parallel within a phase
+ */
+export interface ParallelDeployGroup {
+    phase: number;
+    stacks: readonly ApplicationStack[];
+    description: string;
+}
+/**
+ * Result of deploying a single stack within a parallel group
+ */
+export interface ParallelDeploymentResult {
+    stack: ApplicationStack;
+    success: boolean;
+    error?: Error;
+    duration: number;
+    outputs?: Record<string, string | number | boolean>;
+}
+/**
+ * State of a parallel operation for UI tracking.
+ * operationId is a string to support both ApplicationStack and arbitrary keys.
+ */
+export interface ParallelOperationState {
+    operationId: string;
+    status: "pending" | "running" | "complete" | "failed";
+    events: unknown[];
+    startTime?: number;
+    endTime?: number;
+    error?: string;
+}

package/dist/src/types/deployment/parallel.js

@@ -0,0 +1,10 @@
+/**
+ * Type definitions for parallel deployment operations
+ */
+/**
+ * Special parallel operations that aren't CloudFormation stacks
+ */
+export const PARALLEL_OPERATION_TYPES = {
+    BUILD: "build",
+    DOCKER: "docker"
+};

package/dist/src/types/errors/CdkError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CDK-specific error types
+ */
+import { BaseServiceError } from "./ServiceError.js";
+/**
+ * CDK operation error
+ */
+export declare class CdkError extends BaseServiceError {
+    readonly errorType: "command_failed" | "bootstrap_required" | "bootstrap_failed" | "synthesis_failed" | "deployment_failed" | "destruction_failed" | "diff_failed" | "timeout" | "cancelled" | "invalid_state" | "permission_denied" | "stack_not_found" | "unknown";
+    readonly stackName?: string | undefined;
+    readonly exitCode?: number | undefined;
+    readonly output?: string | undefined;
+    constructor(message: string, errorType: "command_failed" | "bootstrap_required" | "bootstrap_failed" | "synthesis_failed" | "deployment_failed" | "destruction_failed" | "diff_failed" | "timeout" | "cancelled" | "invalid_state" | "permission_denied" | "stack_not_found" | "unknown", stackName?: string | undefined, exitCode?: number | undefined, output?: string | undefined, details?: unknown, recoverable?: boolean);
+}

package/dist/src/types/errors/CdkError.js

@@ -0,0 +1,20 @@
+/**
+ * CDK-specific error types
+ */
+import { BaseServiceError } from "./ServiceError.js";
+/**
+ * CDK operation error
+ */
+export class CdkError extends BaseServiceError {
+    errorType;
+    stackName;
+    exitCode;
+    output;
+    constructor(message, errorType, stackName, exitCode, output, details, recoverable = false) {
+        super(`CDK_${errorType.toUpperCase()}`, message, details, recoverable);
+        this.errorType = errorType;
+        this.stackName = stackName;
+        this.exitCode = exitCode;
+        this.output = output;
+    }
+}

package/dist/src/types/errors/ServiceError.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Standardised error details type used across all services.
+ */
+export type ServiceErrorDetails = Error | Record<string, unknown> | string | unknown | undefined;
+/**
+ * Base service error with full context
+ */
+export interface ServiceError {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: unknown;
+    readonly stack?: string;
+    readonly recoverable?: boolean;
+    readonly cause?: Error;
+}
+/**
+ * Base implementation of ServiceError
+ */
+export declare class BaseServiceError extends Error implements ServiceError {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    readonly recoverable: boolean;
+    readonly cause?: Error | undefined;
+    constructor(code: string, message: string, details?: unknown | undefined, recoverable?: boolean, cause?: Error | undefined);
+}
+/**
+ * Validation-specific errors
+ */
+export declare class ValidationError extends BaseServiceError {
+    readonly fields?: string[] | undefined;
+    readonly rules?: string[] | undefined;
+    constructor(message: string, fields?: string[] | undefined, rules?: string[] | undefined, details?: unknown);
+}
+/**
+ * Authentication/Authorization errors
+ */
+export declare class AuthError extends BaseServiceError {
+    readonly account?: string | undefined;
+    readonly reason?: string | undefined;
+    constructor(message: string, account?: string | undefined, reason?: string | undefined, details?: unknown);
+}
+/**
+ * AWS-specific errors
+ */
+export declare class AwsError extends BaseServiceError {
+    readonly service?: string | undefined;
+    readonly operation?: string | undefined;
+    readonly awsErrorCode?: string | undefined;
+    constructor(message: string, service?: string | undefined, operation?: string | undefined, awsErrorCode?: string | undefined, details?: unknown, recoverable?: boolean);
+}
+/**
+ * CDK/CloudFormation errors
+ */
+export declare class DeploymentError extends BaseServiceError {
+    readonly stackName?: string | undefined;
+    readonly deploymentPhase?: string | undefined;
+    constructor(message: string, stackName?: string | undefined, deploymentPhase?: string | undefined, details?: unknown, recoverable?: boolean);
+}
+/**
+ * Network/connectivity errors
+ */
+export declare class NetworkError extends BaseServiceError {
+    readonly endpoint?: string | undefined;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, endpoint?: string | undefined, statusCode?: number | undefined, cause?: Error);
+}
+/**
+ * File system errors
+ */
+export declare class FileSystemError extends BaseServiceError {
+    readonly path?: string | undefined;
+    readonly operation?: "read" | "write" | "delete" | "exists" | undefined;
+    constructor(message: string, path?: string | undefined, operation?: "read" | "write" | "delete" | "exists" | undefined, cause?: Error);
+}
+/**
+ * Configuration errors
+ */
+export declare class ConfigError extends BaseServiceError {
+    readonly configKey?: string | undefined;
+    readonly configPath?: string | undefined;
+    constructor(message: string, configKey?: string | undefined, configPath?: string | undefined, details?: unknown);
+}
+/**
+ * Convert unknown errors to ServiceError
+ */
+export declare function toServiceError(error: unknown, code?: string): ServiceError;

package/dist/src/types/errors/ServiceError.js

@@ -0,0 +1,119 @@
+/**
+ * Base implementation of ServiceError
+ */
+export class BaseServiceError extends Error {
+    code;
+    details;
+    recoverable;
+    cause;
+    constructor(code, message, details, recoverable = false, cause) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.recoverable = recoverable;
+        this.cause = cause;
+        this.name = this.constructor.name;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+/**
+ * Validation-specific errors
+ */
+export class ValidationError extends BaseServiceError {
+    fields;
+    rules;
+    constructor(message, fields, rules, details) {
+        super("VALIDATION_ERROR", message, details, false);
+        this.fields = fields;
+        this.rules = rules;
+    }
+}
+/**
+ * Authentication/Authorization errors
+ */
+export class AuthError extends BaseServiceError {
+    account;
+    reason;
+    constructor(message, account, reason, details) {
+        super("AUTH_ERROR", message, details, false);
+        this.account = account;
+        this.reason = reason;
+    }
+}
+/**
+ * AWS-specific errors
+ */
+export class AwsError extends BaseServiceError {
+    service;
+    operation;
+    awsErrorCode;
+    constructor(message, service, operation, awsErrorCode, details, recoverable = false) {
+        super("AWS_ERROR", message, details, recoverable);
+        this.service = service;
+        this.operation = operation;
+        this.awsErrorCode = awsErrorCode;
+    }
+}
+/**
+ * CDK/CloudFormation errors
+ */
+export class DeploymentError extends BaseServiceError {
+    stackName;
+    deploymentPhase;
+    constructor(message, stackName, deploymentPhase, details, recoverable = false) {
+        super("DEPLOYMENT_ERROR", message, details, recoverable);
+        this.stackName = stackName;
+        this.deploymentPhase = deploymentPhase;
+    }
+}
+/**
+ * Network/connectivity errors
+ */
+export class NetworkError extends BaseServiceError {
+    endpoint;
+    statusCode;
+    constructor(message, endpoint, statusCode, cause) {
+        super("NETWORK_ERROR", message, undefined, true, cause);
+        this.endpoint = endpoint;
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * File system errors
+ */
+export class FileSystemError extends BaseServiceError {
+    path;
+    operation;
+    constructor(message, path, operation, cause) {
+        super("FILESYSTEM_ERROR", message, { path, operation }, false, cause);
+        this.path = path;
+        this.operation = operation;
+    }
+}
+/**
+ * Configuration errors
+ */
+export class ConfigError extends BaseServiceError {
+    configKey;
+    configPath;
+    constructor(message, configKey, configPath, details) {
+        super("CONFIG_ERROR", message, details, false);
+        this.configKey = configKey;
+        this.configPath = configPath;
+    }
+}
+/**
+ * Convert unknown errors to ServiceError
+ */
+export function toServiceError(error, code = "UNKNOWN_ERROR") {
+    if (error instanceof BaseServiceError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new BaseServiceError(code, error.message, { name: error.name }, false, error);
+    }
+    return new BaseServiceError(code, String(error), { rawError: error }, false);
+}

package/dist/src/types/events.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Progress event types emitted by the deployment engine.
+ * These flow to the caller via DeployCallbacks.
+ */
+export type ProgressEventType = "step" | "info" | "spinner" | "warning" | "debug" | "error";
+export interface ProgressEvent {
+    type: ProgressEventType;
+    message: string;
+    metadata?: {
+        source?: string;
+        percentage?: number;
+        details?: unknown;
+        stepIndex?: number;
+        totalSteps?: number;
+    };
+}
+export interface ResourceEvent {
+    logicalId: string;
+    physicalId?: string;
+    resourceType: string;
+    status: string;
+    statusReason?: string;
+    timestamp: Date;
+}
+export interface AwsAuthResult {
+    accountId: string;
+    region: string;
+    profileName?: string;
+}
+export interface CascadeDeploymentResult {
+    platformDeployed: boolean;
+    domainsDeployed: boolean;
+    accountsDeployed: number;
+    accountsFailed: number;
+    errors: Array<{
+        accountId: string;
+        error: string;
+    }>;
+}
+export type CascadePhase = "platform" | "domains" | "accounts";

package/dist/src/types/events.js

@@ -0,0 +1,5 @@
+/**
+ * Progress event types emitted by the deployment engine.
+ * These flow to the caller via DeployCallbacks.
+ */
+export {};

package/dist/src/types/index.d.ts

@@ -0,0 +1,20 @@
+export type { AwsCredentials, DeployIdentity } from "./credentials.js";
+export type { DeployCallbacks, StepCompleteStatus } from "./callbacks.js";
+export type { ProgressEvent, ProgressEventType, ResourceEvent, AwsAuthResult, CascadeDeploymentResult, CascadePhase } from "./events.js";
+export type { ApiClientInterface, EntitlementsData } from "./apiClient.js";
+export type { DeployParams, DeployOptions, DeploymentType, DeployResult } from "./params.js";
+export type { OrgConfig, ProviderAccount, SSOSession } from "./orgConfig.js";
+export type { StackOutput, StackOutputsRecord, DeploymentContext, StepOutput, ApplicationDeploymentContext, CallerIdentity } from "./deployment/index.js";
+export type { ValidationResult } from "./validation.js";
+export type { ProgressCallbacks } from "./ProgressEvent.js";
+export { ProgressReporter } from "./ProgressEvent.js";
+export type { ApplicationStack, OrganisationType, DeploymentOperation, ApplicationOperation, OrganisationOperation, DeployOrderOptions, ParallelDeployGroupKey, ParallelDestroyGroupKey } from "./operations.js";
+export { APPLICATION_STACKS, ORGANISATION_TYPES, APPLICATION_DEPLOY_ORDER, APPLICATION_DESTROY_ORDER, OPENNEXT_DEPLOY_ORDER, OPENNEXT_DESTROY_ORDER, PARALLEL_DEPLOY_GROUPS, PARALLEL_DESTROY_GROUPS, OPENNEXT_PARALLEL_GROUPS, isApplicationOperation, isOrganisationOperation, getParallelDeployGroups, getParallelDestroyGroups, getApplicationDeployOrder, getApplicationDestroyOrder, getApplicationStackName, getOrganisationStackName, isApplicationStack, getApplicationStepName, getApplicationStepId, toPascalCase } from "./operations.js";
+export type { ParallelDeploymentResult, ParallelDeployGroup, ParallelOperation, ParallelOperationType, ParallelOperationState } from "./deployment/index.js";
+export { PARALLEL_OPERATION_TYPES } from "./deployment/index.js";
+export type { OpenNextPattern, AppResourceFlags } from "./patternDetection.js";
+export { isOpenNextPattern, OPENNEXT_PATTERNS, detectPattern, detectPayloadPattern, detectDatabase, deriveResourcesFromManifestStacks } from "./patternDetection.js";
+export { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH, INFRASTRUCTURE_FILENAME } from "./constants.js";
+export { ApplicationError, wrapApplicationError, type ApplicationErrorType, type StackDeploymentData, type StackDeploymentOptions, type ApplicationDeploymentData, type ApplicationDestructionData } from "./application/index.js";
+export type { FjallStateFile, TemplateHashEntry } from "./FjallState.js";
+export { FjallStateFileSchema, readStateFile, writeStateFile, createEmptyState, deleteStateFile, updateTemplateHash, getStateFilePath } from "./FjallState.js";

package/dist/src/types/index.js

@@ -0,0 +1,9 @@
+export { ProgressReporter } from "./ProgressEvent.js";
+export { APPLICATION_STACKS, ORGANISATION_TYPES, APPLICATION_DEPLOY_ORDER, APPLICATION_DESTROY_ORDER, OPENNEXT_DEPLOY_ORDER, OPENNEXT_DESTROY_ORDER, PARALLEL_DEPLOY_GROUPS, PARALLEL_DESTROY_GROUPS, OPENNEXT_PARALLEL_GROUPS, isApplicationOperation, isOrganisationOperation, getParallelDeployGroups, getParallelDestroyGroups, getApplicationDeployOrder, getApplicationDestroyOrder, getApplicationStackName, getOrganisationStackName, isApplicationStack, getApplicationStepName, getApplicationStepId, toPascalCase } from "./operations.js";
+export { PARALLEL_OPERATION_TYPES } from "./deployment/index.js";
+export { isOpenNextPattern, OPENNEXT_PATTERNS, detectPattern, detectPayloadPattern, detectDatabase, deriveResourcesFromManifestStacks } from "./patternDetection.js";
+// Constants
+export { STACK_NOT_FOUND_PATTERN, CDK_NO_STACKS_MATCH, INFRASTRUCTURE_FILENAME } from "./constants.js";
+// Application types
+export { ApplicationError, wrapApplicationError } from "./application/index.js";
+export { FjallStateFileSchema, readStateFile, writeStateFile, createEmptyState, deleteStateFile, updateTemplateHash, getStateFilePath } from "./FjallState.js";

package/dist/src/types/operations.d.ts

@@ -0,0 +1,193 @@
+import { type AppResourceFlags } from "./patternDetection.js";
+import { toPascalCase } from "@fjall/util";
+/**
+ * Application infrastructure stacks
+ */
+export declare const APPLICATION_STACKS: {
+    readonly NETWORK: "Network";
+    readonly DATABASE: "Database";
+    readonly STORAGE: "Storage";
+    readonly COMPUTE: "Compute";
+    readonly CDN: "Cdn";
+    readonly MESSAGING: "Messaging";
+};
+export type ApplicationStack = (typeof APPLICATION_STACKS)[keyof typeof APPLICATION_STACKS];
+/**
+ * Organisation infrastructure types
+ * Note: These are deployment types, not stacks - each maps to a single CDK stack
+ */
+export declare const ORGANISATION_TYPES: {
+    readonly ORGANISATION: "organisation";
+    readonly PLATFORM: "platform";
+    readonly ACCOUNT: "account";
+};
+export type OrganisationType = (typeof ORGANISATION_TYPES)[keyof typeof ORGANISATION_TYPES];
+/**
+ * Discriminated union for all deployment operations
+ * Using 'kind' as discriminator for clear type narrowing
+ */
+export type DeploymentOperation = ApplicationOperation | OrganisationOperation;
+export interface ApplicationOperation {
+    kind: "application";
+    appName: string;
+    path: string;
+    hasDockerfile?: boolean;
+    isManagedAccount?: boolean;
+}
+export interface OrganisationOperation {
+    kind: "organisation";
+    type: OrganisationType;
+    target: string;
+    path: string;
+}
+/**
+ * Type guards for safe type narrowing
+ */
+export declare function isApplicationOperation(op: DeploymentOperation): op is ApplicationOperation;
+export declare function isOrganisationOperation(op: DeploymentOperation): op is OrganisationOperation;
+/**
+ * Stack ordering for application deployments
+ */
+export declare const APPLICATION_DEPLOY_ORDER: readonly ApplicationStack[];
+export declare const APPLICATION_DESTROY_ORDER: readonly ApplicationStack[];
+/**
+ * Stack ordering for OpenNext (Next.js/Payload) deployments
+ * These patterns require additional infrastructure: S3, DynamoDB, SQS, CloudFront
+ */
+export declare const OPENNEXT_DEPLOY_ORDER: readonly ApplicationStack[];
+/**
+ * Stack ordering for OpenNext destroy operations (reverse of deploy order)
+ * CDN must be destroyed first as it depends on Compute, then work backwards
+ */
+export declare const OPENNEXT_DESTROY_ORDER: readonly ApplicationStack[];
+/**
+ * Parallel deployment groups for concurrent stack deployment
+ * Stacks within each phase can be deployed in parallel.
+ *
+ * Dependency structure:
+ * - Phase 1: Network (required by all other stacks)
+ * - Phase 2: Storage, Messaging, Database (independent of each other, only need Network)
+ * - Phase 3: Compute (needs Database outputs)
+ * - Phase 4: CDN (needs Compute outputs)
+ */
+export declare const PARALLEL_DEPLOY_GROUPS: {
+    readonly PHASE_1: {
+        readonly phase: 1;
+        readonly stacks: readonly ["Network"];
+        readonly description: "Network infrastructure";
+    };
+    readonly PHASE_2: {
+        readonly phase: 2;
+        readonly stacks: readonly ["Storage", "Messaging", "Database"];
+        readonly description: "Storage and database resources (parallel)";
+    };
+    readonly PHASE_3: {
+        readonly phase: 3;
+        readonly stacks: readonly ["Compute"];
+        readonly description: "Compute resources";
+    };
+    readonly PHASE_4: {
+        readonly phase: 4;
+        readonly stacks: readonly ["Cdn"];
+        readonly description: "CDN distribution";
+    };
+};
+/**
+ * Parallel deployment groups for OpenNext (Next.js/Payload) deployments
+ * Optimised to run BUILD in parallel with infrastructure stacks.
+ */
+export declare const OPENNEXT_PARALLEL_GROUPS: {
+    /** Regular Next.js: BUILD + all Phase 2 stacks in parallel */
+    readonly NEXTJS_PARALLEL: {
+        readonly stacks: readonly ["Storage", "Messaging", "Database"];
+        readonly includeBuild: true;
+        readonly description: "Build + Storage/Messaging/Database (parallel)";
+    };
+    /** Payload: BUILD + remaining stacks (after Database + migrations) */
+    readonly PAYLOAD_PARALLEL: {
+        readonly stacks: readonly ["Storage", "Messaging"];
+        readonly includeBuild: true;
+        readonly description: "Build + Storage/Messaging (parallel)";
+    };
+};
+/**
+ * Type for parallel deploy group keys
+ */
+export type ParallelDeployGroupKey = keyof typeof PARALLEL_DEPLOY_GROUPS;
+/**
+ * Get all parallel deploy groups as an ordered array
+ */
+export declare function getParallelDeployGroups(): ReadonlyArray<(typeof PARALLEL_DEPLOY_GROUPS)[ParallelDeployGroupKey]>;
+/**
+ * Parallel destroy groups for OpenNext destroy operations.
+ * Reverse of deploy order to respect dependencies.
+ */
+export declare const PARALLEL_DESTROY_GROUPS: {
+    readonly PHASE_1: {
+        readonly phase: 1;
+        readonly stacks: readonly ["Cdn"];
+        readonly description: "CDN distribution";
+    };
+    readonly PHASE_2: {
+        readonly phase: 2;
+        readonly stacks: readonly ["Compute"];
+        readonly description: "Compute resources";
+    };
+    readonly PHASE_3: {
+        readonly phase: 3;
+        readonly stacks: readonly ["Database", "Messaging", "Storage"];
+        readonly description: "Database, messaging, and storage (parallel)";
+    };
+    readonly PHASE_4: {
+        readonly phase: 4;
+        readonly stacks: readonly ["Network"];
+        readonly description: "Network infrastructure";
+    };
+};
+/**
+ * Type for parallel destroy group keys
+ */
+export type ParallelDestroyGroupKey = keyof typeof PARALLEL_DESTROY_GROUPS;
+/**
+ * Get all parallel destroy groups as an ordered array
+ */
+export declare function getParallelDestroyGroups(): ReadonlyArray<(typeof PARALLEL_DESTROY_GROUPS)[ParallelDestroyGroupKey]>;
+/**
+ * Options for determining deployment order
+ */
+export interface DeployOrderOptions {
+    pattern?: "payload" | "nextjs" | null;
+    resources?: AppResourceFlags;
+}
+/**
+ * Get deployment order based on application configuration.
+ *
+ * Strategies:
+ * 1. OpenNext (pattern = "payload" or "nextjs"): Predefined order (build orchestration)
+ * 2. Dynamic: Include only detected stacks, ordered by tier
+ * 3. Fallback: Standard order (no manifest available)
+ */
+export declare function getApplicationDeployOrder(options?: DeployOrderOptions): readonly ApplicationStack[];
+/**
+ * Get destroy order based on application configuration.
+ * Destroy order respects dependencies (reverse of deploy order).
+ */
+export declare function getApplicationDestroyOrder(options?: DeployOrderOptions): readonly ApplicationStack[];
+/**
+ * Helper functions for stack operations
+ */
+export { toPascalCase };
+export declare function getApplicationStackName(appName: string, stack: ApplicationStack): string;
+export declare function getOrganisationStackName(type: OrganisationType): string;
+/**
+ * Type guard for ApplicationStack
+ */
+export declare function isApplicationStack(value: string): value is ApplicationStack;
+/**
+ * Step name generators for UI display
+ */
+export declare function getApplicationStepName(stack: ApplicationStack, action: "deploy" | "destroy"): string;
+/**
+ * Step ID generators for tracking
+ */
+export declare function getApplicationStepId(stack: ApplicationStack, action: "deploy" | "destroy"): string;