@fjall/deploy-core 0.89.5 → 0.89.6

package/dist/src/types/patternDetection.js

@@ -1,19 +1,16 @@
 /**
- * Pattern detection types and functions.
+ * Filesystem-based pattern detection functions.
  *
- * Contains both pure predicates used by operations.ts and
- * filesystem-based detection functions used by orchestration services.
+ * Pure types and predicates live in patternTypes.ts (browser-safe).
+ * This file contains only functions that require Node fs access.
  */
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
-import { logger, getErrorMessage } from "@fjall/util";
+import { logger } from "@fjall/util/logger";
+import { getErrorMessage } from "@fjall/util";
 import { APPLICATION_STACKS } from "./operations.js";
 import { INFRASTRUCTURE_FILENAME } from "./constants.js";
-const OPENNEXT_PATTERNS_ARRAY = ["payload", "nextjs"];
-export const OPENNEXT_PATTERNS = new Set(OPENNEXT_PATTERNS_ARRAY);
-export function isOpenNextPattern(pattern) {
-    return (pattern !== undefined && pattern !== null && OPENNEXT_PATTERNS.has(pattern));
-}
+export { OPENNEXT_PATTERNS, isOpenNextPattern } from "./patternTypes.js";
 /** Derive resource flags from manifest stack names (authoritative, post-synth) */
 export function deriveResourcesFromManifestStacks(stackNames) {
     const has = (suffix) => stackNames.some((s) => s.endsWith(suffix));
@@ -30,7 +27,7 @@ export function deriveResourcesFromManifestStacks(stackNames) {
  * Read infrastructure.ts content from an app path.
  * Returns null if file doesn't exist or can't be read.
  */
-function readInfrastructureContent(appPath) {
+export function readInfrastructureContent(appPath) {
     try {
         const filePath = join(appPath, INFRASTRUCTURE_FILENAME);
         if (!existsSync(filePath))
@@ -52,6 +49,9 @@ function readInfrastructureContent(appPath) {
  * project files like package.json. This ensures accurate detection even
  * when multiple apps coexist in the same project directory.
  *
+ * @deprecated Use FrameworkRegistry.resolve() instead. This function is retained
+ * for backwards compatibility with consumers that have not yet migrated.
+ *
  * @param appPath - The fjall app path (e.g., "fjall/app8" or absolute path)
  */
 export function detectPattern(appPath) {
@@ -76,17 +76,13 @@ export function detectPattern(appPath) {
  * Detect if infrastructure.ts contains a Payload CMS pattern.
  */
 export function detectPayloadPattern(appPath) {
-    const content = readInfrastructureContent(appPath);
-    if (!content)
-        return false;
-    return (content.includes("PatternFactory") && content.includes('type: "payload"'));
+    const { pattern } = detectPattern(appPath);
+    return pattern === "payload";
 }
 /**
  * Detect if infrastructure.ts contains a database resource.
  */
 export function detectDatabase(appPath) {
-    const content = readInfrastructureContent(appPath);
-    if (!content)
-        return false;
-    return content.includes("DatabaseFactory.build(");
+    const { hasDatabase } = detectPattern(appPath);
+    return hasDatabase;
 }

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

@@ -0,0 +1,19 @@
+/**
+ * Pure pattern types and predicates — no filesystem dependencies.
+ *
+ * These are safe for browser bundles. Filesystem-based detection functions
+ * remain in patternDetection.ts.
+ */
+declare const OPENNEXT_PATTERNS_ARRAY: readonly ["payload", "nextjs"];
+export type OpenNextPattern = (typeof OPENNEXT_PATTERNS_ARRAY)[number];
+export declare const OPENNEXT_PATTERNS: ReadonlySet<string>;
+export declare function isOpenNextPattern(pattern: string | undefined | null): pattern is OpenNextPattern;
+export interface AppResourceFlags {
+    hasNetwork: boolean;
+    hasCompute: boolean;
+    hasDatabase: boolean;
+    hasStorage: boolean;
+    hasMessaging: boolean;
+    hasCdn: boolean;
+}
+export {};

package/dist/src/types/patternTypes.js

@@ -0,0 +1 @@
+const e=["payload","nextjs"],t=new Set(e);function N(n){return n!=null&&t.has(n)}export{t as OPENNEXT_PATTERNS,N as isOpenNextPattern};

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

@@ -0,0 +1,163 @@
+/**
+ * Canonical step definitions for all deployment types.
+ *
+ * These constants and types define the deployment step metadata shared
+ * across CLI, webapp worker, and any other consumer. The filtering and
+ * registry logic (which steps to show, conditional visibility) lives
+ * in steps/stepRegistry.ts — this file is the data layer.
+ */
+import type { PatternType } from "@fjall/generator";
+import type { AppResourceFlags } from "./patternTypes.js";
+/**
+ * Step IDs used throughout the deployment process.
+ * Centralised here to avoid magic strings and enable type safety.
+ */
+export declare const STEP_IDS: {
+    readonly AUTH: "auth";
+    readonly DETECT_CONFIG: "detect-config";
+    readonly BOOTSTRAP: "bootstrap";
+    readonly CFN_CHECK: "cfn-check";
+    readonly DIFF: "diff";
+    readonly DEPLOY: "deploy";
+    readonly DESTROY: "destroy";
+    readonly VERIFY: "verify";
+    readonly OPENNEXT_BUILD: "opennext-build";
+    readonly CDK_SYNTH: "cdk-synth";
+    readonly DOCKER_OPERATIONS: "docker-operations";
+    readonly ECR_INIT: "ecr-init";
+    readonly DOCKER_DEPLOY: "docker-deploy";
+    readonly TAG_ECR_IMAGES: "tag-ecr-images";
+    readonly ECS_UPDATE: "ecs-update";
+    readonly ECS_MONITOR: "ecs-monitor";
+    readonly ORG_SETUP: "org-setup";
+    readonly ORG_ENSURE: "org-ensure";
+    readonly ORG_POLICY_TYPES: "policy-types";
+    readonly ORG_SERVICE_ACCESS: "service-access";
+    readonly ORG_CREATE_ACCOUNTS: "create-accounts";
+    readonly ORG_ENSURE_OUS: "ensure-ous";
+    readonly ORG_PLACE_ACCOUNTS: "place-accounts";
+    readonly IDENTITY_CENTRE: "identity-centre";
+    readonly ORG_ACCOUNTS: "accounts";
+    readonly ORG_COST_TAGS: "cost-tags";
+    readonly ORG_PROFILES: "profiles";
+    /** Organisation-level prepare (synth + hash-compare). For infra, use PREPARE_ENVIRONMENT. */
+    readonly PREPARE: "prepare";
+    readonly PREPARE_ENVIRONMENT: "prepare-environment";
+    readonly PLATFORM_ACCOUNT: "platform-account";
+    readonly ACCOUNT_CONTEXT: "account-context";
+    readonly CONNECT: "connect";
+    readonly MONITORING: "monitoring";
+    readonly ORG_DEPLOY: "organisation-deploy";
+    readonly ORG_DESTROY: "organisation-destroy";
+    readonly CASCADE_PLATFORM: "cascade-platform";
+    readonly CASCADE_DOMAINS: "cascade-domains";
+    readonly CASCADE_ACCOUNTS: "cascade-accounts";
+    readonly NETWORK: "network";
+    readonly STORAGE: "storage";
+    readonly MESSAGING: "messaging";
+    readonly DATABASE: "database";
+    readonly COMPUTE: "compute";
+    readonly CDN: "cdn";
+    readonly NETWORK_DESTROY: "network-destroy";
+    readonly STORAGE_DESTROY: "storage-destroy";
+    readonly MESSAGING_DESTROY: "messaging-destroy";
+    readonly DATABASE_DESTROY: "database-destroy";
+    readonly COMPUTE_DESTROY: "compute-destroy";
+    readonly CDN_DESTROY: "cdn-destroy";
+};
+export type StepId = (typeof STEP_IDS)[keyof typeof STEP_IDS];
+/**
+ * Human-readable step names paired with STEP_IDS.
+ * Extracted because these strings are used at 3+ call sites.
+ */
+export declare const STEP_NAMES: {
+    readonly AUTH: "Authenticating with AWS";
+    readonly PREPARE_DEPLOY: "Preparing deployment";
+    readonly PREPARE_DESTROY: "Preparing destruction";
+    readonly BOOTSTRAP: "Bootstrapping AWS environment";
+    readonly CHECK_INFRA_STATE: "Checking infrastructure state";
+};
+/**
+ * Canonical step names emitted by infrastructure deployments (platform/account).
+ * The webapp's onboarding timeline and deployment detail page import these
+ * directly, replacing the previous fragile string duplication.
+ */
+export declare const INFRASTRUCTURE_STEP_NAMES: readonly ["Connect securely", "Prepare environment", "Deploy infrastructure", "Enable monitoring"];
+/** Named access for specific step names (avoids fragile positional indices) */
+export declare const INFRA_STEP_NAME: {
+    readonly CONNECT: "Connect securely";
+    readonly PREPARE: "Prepare environment";
+    readonly DEPLOY: "Deploy infrastructure";
+    readonly MONITORING: "Enable monitoring";
+};
+export type InfrastructureStepName = (typeof INFRASTRUCTURE_STEP_NAMES)[number];
+export interface StepDefinition {
+    id: StepId;
+    name: string;
+    conditions?: {
+        requiresInfra?: boolean;
+        requiresDocker?: boolean;
+        requiresECS?: boolean;
+        requiresImageTagging?: boolean;
+        skipForInfraOnly?: boolean;
+        excludeForManagedAccount?: boolean;
+        excludeWhenHasDockerfile?: boolean;
+        requiresNetwork?: boolean;
+        requiresCompute?: boolean;
+        requiresDatabase?: boolean;
+        requiresStorage?: boolean;
+        requiresMessaging?: boolean;
+        requiresCdn?: boolean;
+        requiresMemberAccounts?: boolean;
+        requiresPlatformAccount?: boolean;
+        requiresOrgChanges?: boolean;
+        requiresPlatformChanges?: boolean;
+        requiresAccountChanges?: boolean;
+        requiresDomainConfiguration?: boolean;
+        requiresDomainChanges?: boolean;
+    };
+}
+/**
+ * Deployment type for step context.
+ *
+ * Named StepDeploymentType to avoid collision with the 2-value
+ * DeploymentType in params.ts ("application" | "organisation").
+ * This 4-value union covers all deployment targets including
+ * platform and account sub-deployments.
+ */
+export type StepDeploymentType = "application" | "organisation" | "platform" | "account";
+export type Operation = "deploy" | "destroy";
+export interface StepContext {
+    deploymentType: StepDeploymentType;
+    operation: Operation;
+    deployOnly?: boolean;
+    infraOnly?: boolean;
+    isManagedAccount?: boolean;
+    hasDockerfile?: boolean;
+    hasDifferences?: boolean;
+    pattern?: PatternType | null;
+    /** Name of the framework builder that resolved this app (e.g. "opennext", "docker"). */
+    builderName?: string;
+    openNextOutput?: {
+        serverFunction?: string;
+        imageOptimisationFunction?: string;
+        revalidationFunction?: string;
+        warmerFunction?: string;
+        assets?: string;
+        cache?: string;
+    };
+    /** Build configuration for pattern apps */
+    build?: {
+        requiresDatabase: boolean;
+        databaseEnvVar: string;
+    };
+    /** Post-synth resource detection from manifest */
+    resources?: AppResourceFlags;
+    hasMemberAccounts?: boolean;
+    hasPlatformAccount?: boolean;
+    hasOrgChanges?: boolean;
+    hasPlatformChanges?: boolean;
+    hasAccountChanges?: boolean;
+    hasDomainConfiguration?: boolean;
+    hasDomainChanges?: boolean;
+}

package/dist/src/types/stepDefinitions.js

@@ -0,0 +1,98 @@
+/**
+ * Step IDs used throughout the deployment process.
+ * Centralised here to avoid magic strings and enable type safety.
+ */
+export const STEP_IDS = {
+    // Common steps
+    AUTH: "auth",
+    DETECT_CONFIG: "detect-config",
+    BOOTSTRAP: "bootstrap",
+    CFN_CHECK: "cfn-check",
+    DIFF: "diff",
+    DEPLOY: "deploy",
+    DESTROY: "destroy",
+    VERIFY: "verify",
+    // OpenNext steps
+    OPENNEXT_BUILD: "opennext-build",
+    CDK_SYNTH: "cdk-synth",
+    // Docker/ECS steps
+    DOCKER_OPERATIONS: "docker-operations",
+    ECR_INIT: "ecr-init",
+    DOCKER_DEPLOY: "docker-deploy",
+    TAG_ECR_IMAGES: "tag-ecr-images",
+    ECS_UPDATE: "ecs-update",
+    ECS_MONITOR: "ecs-monitor",
+    // Organisation-specific steps
+    ORG_SETUP: "org-setup",
+    ORG_ENSURE: "org-ensure",
+    ORG_POLICY_TYPES: "policy-types",
+    ORG_SERVICE_ACCESS: "service-access",
+    ORG_CREATE_ACCOUNTS: "create-accounts",
+    ORG_ENSURE_OUS: "ensure-ous",
+    ORG_PLACE_ACCOUNTS: "place-accounts",
+    IDENTITY_CENTRE: "identity-centre",
+    ORG_ACCOUNTS: "accounts",
+    ORG_COST_TAGS: "cost-tags",
+    ORG_PROFILES: "profiles",
+    /** Organisation-level prepare (synth + hash-compare). For infra, use PREPARE_ENVIRONMENT. */
+    PREPARE: "prepare",
+    // Infrastructure-level prepare (platform/account deploy)
+    PREPARE_ENVIRONMENT: "prepare-environment",
+    // Platform-specific steps
+    PLATFORM_ACCOUNT: "platform-account",
+    // Account-specific steps
+    ACCOUNT_CONTEXT: "account-context",
+    // Infrastructure lifecycle steps (platform/account deploy)
+    CONNECT: "connect",
+    MONITORING: "monitoring",
+    // Organisation deploy/destroy steps
+    ORG_DEPLOY: "organisation-deploy",
+    ORG_DESTROY: "organisation-destroy",
+    // Cascade steps
+    CASCADE_PLATFORM: "cascade-platform",
+    CASCADE_DOMAINS: "cascade-domains",
+    CASCADE_ACCOUNTS: "cascade-accounts",
+    // Infrastructure stack steps (deploy)
+    NETWORK: "network",
+    STORAGE: "storage",
+    MESSAGING: "messaging",
+    DATABASE: "database",
+    COMPUTE: "compute",
+    CDN: "cdn",
+    // Infrastructure stack steps (destroy)
+    NETWORK_DESTROY: "network-destroy",
+    STORAGE_DESTROY: "storage-destroy",
+    MESSAGING_DESTROY: "messaging-destroy",
+    DATABASE_DESTROY: "database-destroy",
+    COMPUTE_DESTROY: "compute-destroy",
+    CDN_DESTROY: "cdn-destroy"
+};
+/**
+ * Human-readable step names paired with STEP_IDS.
+ * Extracted because these strings are used at 3+ call sites.
+ */
+export const STEP_NAMES = {
+    AUTH: "Authenticating with AWS",
+    PREPARE_DEPLOY: "Preparing deployment",
+    PREPARE_DESTROY: "Preparing destruction",
+    BOOTSTRAP: "Bootstrapping AWS environment",
+    CHECK_INFRA_STATE: "Checking infrastructure state"
+};
+/**
+ * Canonical step names emitted by infrastructure deployments (platform/account).
+ * The webapp's onboarding timeline and deployment detail page import these
+ * directly, replacing the previous fragile string duplication.
+ */
+export const INFRASTRUCTURE_STEP_NAMES = [
+    "Connect securely",
+    "Prepare environment",
+    "Deploy infrastructure",
+    "Enable monitoring"
+];
+/** Named access for specific step names (avoids fragile positional indices) */
+export const INFRA_STEP_NAME = {
+    CONNECT: INFRASTRUCTURE_STEP_NAMES[0],
+    PREPARE: INFRASTRUCTURE_STEP_NAMES[1],
+    DEPLOY: INFRASTRUCTURE_STEP_NAMES[2],
+    MONITORING: INFRASTRUCTURE_STEP_NAMES[3]
+};

package/dist/src/types/validation.js

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

package/dist/src/util/dockerfileDetection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Check whether a Dockerfile exists in the given directory.
+ * Matches any file starting with "Dockerfile" (e.g. Dockerfile, Dockerfile.prod).
+ */
+export declare function hasDockerfile(appPath: string): boolean;

package/dist/src/util/dockerfileDetection.js

@@ -0,0 +1 @@
+import{readdirSync as t}from"fs";import{logger as i}from"@fjall/util/logger";function s(e){try{return t(e).some(o=>o.startsWith("Dockerfile"))}catch(r){return i.debug("dockerfileDetection","Failed to check for Dockerfile",{appPath:e,error:r instanceof Error?r.message:String(r)}),!1}}export{s as hasDockerfile};

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

@@ -1,3 +1,4 @@
-export { DANGEROUS_ENV_VARS, filterDangerousEnvVars, maskSensitiveOutput, parseShellArgs } from "./securityHelpers.js";
-export { sleep } from "./sleep.js";
-export { singleton } from "./singleton.js";
+export { DANGEROUS_ENV_VARS, filterDangerousEnvVars, maskSensitiveOutput, parseShellArgs, sleep, singleton } from "@fjall/util";
+export { hasDockerfile } from "./dockerfileDetection.js";
+export { createSequencedCallbacks } from "./sequencedCallbacks.js";
+export type { CallbackMetadata, SequencedCallbackEvent, SequencedCallbacksResult } from "./sequencedCallbacks.js";

package/dist/src/util/index.js

@@ -1,3 +1 @@
-export { DANGEROUS_ENV_VARS, filterDangerousEnvVars, maskSensitiveOutput, parseShellArgs } from "./securityHelpers.js";
-export { sleep } from "./sleep.js";
-export { singleton } from "./singleton.js";
+import{DANGEROUS_ENV_VARS as s,filterDangerousEnvVars as o,maskSensitiveOutput as t,parseShellArgs as a,sleep as l,singleton as n}from"@fjall/util";import{hasDockerfile as f}from"./dockerfileDetection.js";import{createSequencedCallbacks as S}from"./sequencedCallbacks.js";export{s as DANGEROUS_ENV_VARS,S as createSequencedCallbacks,o as filterDangerousEnvVars,f as hasDockerfile,t as maskSensitiveOutput,a as parseShellArgs,n as singleton,l as sleep};

package/dist/src/util/sequencedCallbacks.d.ts

@@ -0,0 +1,44 @@
+import type { DeployCallbacks } from "../types/callbacks.js";
+/**
+ * Metadata attached to each sequenced callback invocation.
+ */
+export interface CallbackMetadata {
+    /** Monotonically increasing sequence number, starting at 1. */
+    sequence: number;
+    /** ISO 8601 timestamp of when the callback was invoked. */
+    timestamp: string;
+}
+/**
+ * A recorded callback event for replay or ordering analysis.
+ */
+export interface SequencedCallbackEvent {
+    /** Name of the callback that was invoked (e.g. "onLog", "onProgress"). */
+    callbackName: string;
+    /** Arguments passed to the callback. */
+    args: unknown[];
+    /** Sequence and timing metadata. */
+    metadata: CallbackMetadata;
+}
+/**
+ * Result of createSequencedCallbacks — the wrapped callbacks plus
+ * accessors for the recorded event log.
+ */
+export interface SequencedCallbacksResult {
+    /** DeployCallbacks-conforming wrapper that records invocations. */
+    callbacks: DeployCallbacks;
+    /** Returns a copy of all recorded events in invocation order. */
+    getEvents: () => SequencedCallbackEvent[];
+    /** Clears the event log without resetting the sequence counter. */
+    clearEvents: () => void;
+}
+/**
+ * Wraps a DeployCallbacks object so that every callback invocation is
+ * recorded with a monotonically increasing sequence number and an ISO
+ * timestamp. The original callback is called through with its original
+ * arguments, and return values (including Promises) are preserved.
+ *
+ * Only callbacks that exist on the inner object are wrapped — missing
+ * callbacks remain undefined on the wrapper so that optional-chaining
+ * call sites behave identically.
+ */
+export declare function createSequencedCallbacks(inner: DeployCallbacks): SequencedCallbacksResult;

package/dist/src/util/sequencedCallbacks.js

@@ -0,0 +1 @@
+const l=new Set(["verbose"]);function u(t){let a=0;const n=[],c={};for(const e of Object.keys(t)){if(l.has(e)){c[e]=t[e];continue}const o=t[e];typeof o=="function"&&(c[e]=(...s)=>{a+=1;const r={sequence:a,timestamp:new Date().toISOString()};return n.push({callbackName:e,args:[...s],metadata:r}),o(...s)})}return{callbacks:c,getEvents:()=>[...n],clearEvents:()=>{n.length=0}}}export{u as createSequencedCallbacks};

package/package.json

@@ -1,17 +1,56 @@
 {
   "name": "@fjall/deploy-core",
-  "version": "0.89.5",
+  "version": "0.89.6",
   "description": "Shared deployment engine for Fjall — used by CLI and webapp worker",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./types": {
+      "types": "./dist/src/types/index.d.ts",
+      "default": "./dist/src/types/index.js"
+    },
+    "./events": {
+      "types": "./dist/src/events/index.d.ts",
+      "default": "./dist/src/events/index.js"
+    },
+    "./aws": {
+      "types": "./dist/src/aws/index.d.ts",
+      "default": "./dist/src/aws/index.js"
+    },
+    "./orchestration": {
+      "types": "./dist/src/orchestration/index.d.ts",
+      "default": "./dist/src/orchestration/index.js"
+    },
+    "./services": {
+      "types": "./dist/src/services/index.d.ts",
+      "default": "./dist/src/services/index.js"
+    },
+    "./util": {
+      "types": "./dist/src/util/index.d.ts",
+      "default": "./dist/src/util/index.js"
+    },
+    "./steps": {
+      "types": "./dist/src/steps/index.d.ts",
+      "default": "./dist/src/steps/index.js"
+    },
+    "./__test-utils__": {
+      "types": "./dist/src/__test-utils__/index.d.ts",
+      "default": "./dist/src/__test-utils__/index.js"
+    }
+  },
   "files": [
     "dist/"
   ],
   "scripts": {
-    "clean": "rm -rf ./dist",
-    "build": "npm run clean && tsc",
+    "clean": "rm -rf ./dist ./sourcemaps",
+    "build": "npm run clean && tsc && node ../scripts/minify-dist.mjs dist",
     "watch": "npm run build && tsc --watch --preserveWatchOutput",
+    "watch:only": "tsc --watch --preserveWatchOutput",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -20,9 +59,9 @@
     "lint": "eslint src/"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   },
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "dependencies": {
     "@aws-sdk/client-backup": "^3.1009.0",
     "@aws-sdk/client-cloudformation": "^3.1009.0",
@@ -30,14 +69,16 @@
     "@aws-sdk/client-ec2": "^3.1009.0",
     "@aws-sdk/client-organizations": "^3.1009.0",
     "@aws-sdk/client-ram": "^3.1009.0",
+    "@aws-sdk/client-s3": "^3.1009.0",
     "@aws-sdk/client-sso-admin": "^3.1009.0",
     "@aws-sdk/client-sts": "^3.1009.0",
-    "@fjall/generator": "^0.89.5",
-    "@fjall/util": "^0.89.5",
+    "@fjall/generator": "^0.89.6",
+    "@fjall/util": "^0.89.6",
+    "@smithy/node-http-handler": "^4.5.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "vitest": "^3.2.3"
   },
-  "gitHead": "1680c1a0be16950e9e10e571163ccc42198f6a8e"
+  "gitHead": "fb309fa904991ac4f23c49b3bed1be146f738900"
 }

package/dist/src/aws/utils/CloudFormationFailureAnalyser.d.ts

@@ -1,32 +0,0 @@
-import { type ResourceEvent } from "./cloudformationEvents.js";
-export interface RootCause {
-    resource: ResourceEvent;
-    reason: string;
-    category: "permissions" | "validation" | "dependency" | "limit" | "network" | "unknown";
-    isDirectCause: boolean;
-}
-export interface FailureAnalysis {
-    rootCause: RootCause;
-    affectedResources: ResourceEvent[];
-    dependencyChain: string[];
-    summary: string;
-    remediation: string[];
-    errorPattern?: string;
-}
-/**
- * CloudFormationFailureAnalyser provides intelligent analysis of deployment failures
- * It identifies root causes, dependency chains, and provides actionable remediation
- */
-export declare class CloudFormationFailureAnalyser {
-    private knownErrorPatterns;
-    analyseFailure(eventHistory: Map<string, ResourceEvent[]>): FailureAnalysis | null;
-    private findFailedResources;
-    private findRootCause;
-    private categoriseError;
-    private isDirectCause;
-    private buildDependencyChain;
-    private generateRemediation;
-    private generateSummary;
-    private simplifyResourceType;
-    private isFailedStatus;
-}