@fjall/deploy-core 0.89.2

package/dist/src/services/supporting/helpers.d.ts

@@ -0,0 +1,46 @@
+import type { ProgressEvent } from "../../types/events.js";
+/**
+ * Emits a progress event through the callbacks if available.
+ */
+export declare function emitProgress(callbacks: {
+    onProgress?: (event: ProgressEvent) => void;
+} | undefined, message: string, type?: ProgressEvent["type"]): void;
+/** Progress message constants — avoids magic string repetition */
+export declare const PROGRESS_MESSAGES: Readonly<{
+    readonly BUILD: "Building Next.js application";
+    readonly SYNTH: "Synthesising infrastructure";
+    readonly HASH: "Comparing template hashes";
+    readonly DOCKER: "Validating Docker configuration";
+    readonly SECRETS: "Validating SSM secrets";
+}>;
+/**
+ * Parse Next.js/OpenNext build output to extract meaningful phase transitions.
+ * Returns a clean status message for display instead of raw build output.
+ *
+ * Only updates when a meaningful phase change is detected to avoid UI flicker.
+ */
+export declare function parseBuildPhase(message: string, currentPhase: string): string;
+/**
+ * Build the StepContext build configuration from a buildConfig object.
+ * Extracts the database-related fields with defaults.
+ */
+export declare function buildStepContextBuildConfig(buildConfig: {
+    requiresDatabase?: boolean;
+    databaseEnvVar?: string;
+} | undefined): {
+    requiresDatabase: boolean;
+    databaseEnvVar: string;
+} | undefined;
+/**
+ * CloudFormation output shape (matches AWS SDK Output type).
+ */
+export interface CloudFormationOutput {
+    OutputKey?: string;
+    OutputValue?: string;
+    ExportName?: string;
+}
+/**
+ * Convert CloudFormation outputs array to a key-value record.
+ * Filters out outputs without keys and handles undefined values.
+ */
+export declare function convertCloudFormationOutputsToRecord(outputs: CloudFormationOutput[]): Record<string, string | number | boolean>;

package/dist/src/services/supporting/helpers.js

@@ -0,0 +1,81 @@
+/**
+ * Emits a progress event through the callbacks if available.
+ */
+export function emitProgress(callbacks, message, type = "info") {
+    callbacks?.onProgress?.({ type, message });
+}
+/** Progress message constants — avoids magic string repetition */
+export const PROGRESS_MESSAGES = Object.freeze({
+    BUILD: "Building Next.js application",
+    SYNTH: "Synthesising infrastructure",
+    HASH: "Comparing template hashes",
+    DOCKER: "Validating Docker configuration",
+    SECRETS: "Validating SSM secrets"
+});
+/**
+ * Parse Next.js/OpenNext build output to extract meaningful phase transitions.
+ * Returns a clean status message for display instead of raw build output.
+ *
+ * Only updates when a meaningful phase change is detected to avoid UI flicker.
+ */
+export function parseBuildPhase(message, currentPhase) {
+    const lowerMessage = message.toLowerCase();
+    if (lowerMessage.includes("creating next.js build") ||
+        lowerMessage.includes("creating an optimised production build")) {
+        return "Creating production build...";
+    }
+    if (lowerMessage.includes("compiling")) {
+        return "Compiling...";
+    }
+    if (lowerMessage.includes("linting")) {
+        return "Linting...";
+    }
+    if (lowerMessage.includes("checking validity of types")) {
+        return "Type checking...";
+    }
+    if (lowerMessage.includes("collecting page data")) {
+        return "Collecting page data...";
+    }
+    if (lowerMessage.includes("generating static pages")) {
+        return "Generating static pages...";
+    }
+    if (lowerMessage.includes("finalizing page optimization")) {
+        return "Optimising pages...";
+    }
+    if (lowerMessage.includes("open-next build complete") ||
+        lowerMessage.includes("build completed")) {
+        return "Build complete";
+    }
+    if (lowerMessage.includes("bundling")) {
+        return "Bundling functions...";
+    }
+    if (lowerMessage.includes("copying assets")) {
+        return "Copying assets...";
+    }
+    return currentPhase;
+}
+/**
+ * Build the StepContext build configuration from a buildConfig object.
+ * Extracts the database-related fields with defaults.
+ */
+export function buildStepContextBuildConfig(buildConfig) {
+    if (!buildConfig)
+        return undefined;
+    return {
+        requiresDatabase: buildConfig.requiresDatabase ?? false,
+        databaseEnvVar: buildConfig.databaseEnvVar ?? "DATABASE_URL"
+    };
+}
+/**
+ * Convert CloudFormation outputs array to a key-value record.
+ * Filters out outputs without keys and handles undefined values.
+ */
+export function convertCloudFormationOutputsToRecord(outputs) {
+    const result = {};
+    for (const output of outputs) {
+        if (output.OutputKey && output.OutputValue !== undefined) {
+            result[output.OutputKey] = output.OutputValue;
+        }
+    }
+    return result;
+}

package/dist/src/services/supporting/index.d.ts

@@ -0,0 +1,3 @@
+export { TemplateHashService, TemplateHashError, type TemplateComparisonResult } from "./TemplateHashService.js";
+export { CdkContextBuilder } from "./CdkContextBuilder.js";
+export { emitProgress, PROGRESS_MESSAGES, parseBuildPhase, buildStepContextBuildConfig, convertCloudFormationOutputsToRecord, type CloudFormationOutput } from "./helpers.js";

package/dist/src/services/supporting/index.js

@@ -0,0 +1,3 @@
+export { TemplateHashService, TemplateHashError } from "./TemplateHashService.js";
+export { CdkContextBuilder } from "./CdkContextBuilder.js";
+export { emitProgress, PROGRESS_MESSAGES, parseBuildPhase, buildStepContextBuildConfig, convertCloudFormationOutputsToRecord } from "./helpers.js";

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+declare const TemplateHashEntrySchema: z.ZodObject<{
+    hash: z.ZodString;
+    deployedAt: z.ZodString;
+    stackStatus: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * State file schema for hash-based change detection.
+ * Location: fjall/{appName}/.fjall-state.json
+ */
+export declare const FjallStateFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    lastDeployedAt: z.ZodOptional<z.ZodString>;
+    templateHashes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        hash: z.ZodString;
+        deployedAt: z.ZodString;
+        stackStatus: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type TemplateHashEntry = z.infer<typeof TemplateHashEntrySchema>;
+export type FjallStateFile = z.infer<typeof FjallStateFileSchema>;
+/**
+ * Get the state file path for an application
+ */
+export declare function getStateFilePath(appPath: string): string;
+/**
+ * Read state file from application directory.
+ * Returns null if file doesn't exist or is corrupt (graceful degradation).
+ */
+export declare function readStateFile(appPath: string): Promise<FjallStateFile | null>;
+/**
+ * Write state file atomically using temp file + rename pattern.
+ * Prevents partial writes from corrupting the state file.
+ */
+export declare function writeStateFile(appPath: string, state: FjallStateFile): Promise<void>;
+/**
+ * Create an empty state file structure
+ */
+export declare function createEmptyState(): FjallStateFile;
+/**
+ * Delete state file for an application directory.
+ * No-op if the file does not exist.
+ */
+export declare function deleteStateFile(appPath: string): Promise<void>;
+/**
+ * Update a single template hash in the state
+ */
+export declare function updateTemplateHash(state: FjallStateFile, stackName: string, hash: string, stackStatus?: string): FjallStateFile;
+export {};

package/dist/src/types/FjallState.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { readFile, writeFile, unlink, rename, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { fileExists } from "../util/fsHelpers.js";
+import { logger, getErrorMessage } from "@fjall/util";
+const TemplateHashEntrySchema = z
+    .object({
+    hash: z.string(),
+    deployedAt: z.string(),
+    stackStatus: z.string().optional()
+})
+    .strict();
+/**
+ * State file schema for hash-based change detection.
+ * Location: fjall/{appName}/.fjall-state.json
+ */
+export const FjallStateFileSchema = z
+    .object({
+    version: z.literal(1),
+    lastDeployedAt: z.string().optional(),
+    templateHashes: z.record(z.string(), TemplateHashEntrySchema),
+    metadata: z.record(z.string(), z.unknown()).optional()
+})
+    .strict();
+const STATE_FILE_NAME = ".fjall-state.json";
+/**
+ * Get the state file path for an application
+ */
+export function getStateFilePath(appPath) {
+    return join(appPath, STATE_FILE_NAME);
+}
+/**
+ * Read state file from application directory.
+ * Returns null if file doesn't exist or is corrupt (graceful degradation).
+ */
+export async function readStateFile(appPath) {
+    const statePath = getStateFilePath(appPath);
+    if (!(await fileExists(statePath))) {
+        return null;
+    }
+    try {
+        const content = await readFile(statePath, "utf-8");
+        const parsed = JSON.parse(content);
+        const result = FjallStateFileSchema.safeParse(parsed);
+        if (!result.success) {
+            return null;
+        }
+        return result.data;
+    }
+    catch (err) {
+        logger.debug("FjallState", "Failed to read state file", {
+            path: statePath,
+            error: getErrorMessage(err)
+        });
+        return null;
+    }
+}
+/**
+ * Write state file atomically using temp file + rename pattern.
+ * Prevents partial writes from corrupting the state file.
+ */
+export async function writeStateFile(appPath, state) {
+    const statePath = getStateFilePath(appPath);
+    const tempPath = `${statePath}.${Date.now()}.tmp`;
+    await mkdir(dirname(statePath), { recursive: true });
+    try {
+        await writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+        await rename(tempPath, statePath);
+    }
+    catch (error) {
+        try {
+            await unlink(tempPath);
+        }
+        catch {
+            // Temp file cleanup is non-fatal
+        }
+        throw error;
+    }
+}
+/**
+ * Create an empty state file structure
+ */
+export function createEmptyState() {
+    return {
+        version: 1,
+        templateHashes: {}
+    };
+}
+/**
+ * Delete state file for an application directory.
+ * No-op if the file does not exist.
+ */
+export async function deleteStateFile(appPath) {
+    const statePath = getStateFilePath(appPath);
+    try {
+        await unlink(statePath);
+    }
+    catch {
+        /* file may not exist */
+    }
+}
+/**
+ * Update a single template hash in the state
+ */
+export function updateTemplateHash(state, stackName, hash, stackStatus) {
+    return {
+        ...state,
+        lastDeployedAt: new Date().toISOString(),
+        templateHashes: {
+            ...state.templateHashes,
+            [stackName]: {
+                hash,
+                deployedAt: new Date().toISOString(),
+                ...(stackStatus !== undefined && { stackStatus })
+            }
+        }
+    };
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Progress callbacks used by infrastructure services.
+ *
+ * This is the simpler callback interface used by inner services
+ * (CdkService, CloudFormationService). The orchestration layer
+ * bridges between DeployCallbacks and ProgressCallbacks.
+ */
+import type { ProgressEvent } from "./events.js";
+export type { ProgressEvent, ProgressEventType } from "./events.js";
+export interface ProgressCallbacks {
+    onProgress?: (event: ProgressEvent) => void;
+    onWarning?: (message: string, callback: (proceed: boolean) => void) => void;
+    onError?: (error: Error) => void;
+    directConsole?: boolean;
+}
+/**
+ * Helper to create progress events with optional typing
+ */
+export declare class ProgressReporter {
+    private callbacks?;
+    private stepIndex;
+    private totalSteps?;
+    constructor(callbacks?: ProgressCallbacks | undefined);
+    setTotalSteps(total: number): void;
+    step(message: string, options?: {
+        stepIndex?: number;
+        totalSteps?: number;
+        metadata?: ProgressEvent["metadata"];
+    }): void;
+    info(message: string, metadata?: ProgressEvent["metadata"]): void;
+    spinner(message: string, metadata?: ProgressEvent["metadata"]): void;
+    warning(message: string, metadata?: ProgressEvent["metadata"]): void;
+    debug(message: string, metadata?: ProgressEvent["metadata"]): void;
+    error(message: string, metadata?: ProgressEvent["metadata"]): void;
+}

package/dist/src/types/ProgressEvent.js

@@ -0,0 +1,48 @@
+/**
+ * Progress callbacks used by infrastructure services.
+ *
+ * This is the simpler callback interface used by inner services
+ * (CdkService, CloudFormationService). The orchestration layer
+ * bridges between DeployCallbacks and ProgressCallbacks.
+ */
+/**
+ * Helper to create progress events with optional typing
+ */
+export class ProgressReporter {
+    callbacks;
+    stepIndex = 0;
+    totalSteps;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    setTotalSteps(total) {
+        this.totalSteps = total;
+    }
+    step(message, options) {
+        const { metadata, stepIndex, totalSteps } = options ?? {};
+        this.callbacks?.onProgress?.({
+            type: "step",
+            message,
+            metadata: {
+                ...metadata,
+                stepIndex: stepIndex ?? this.stepIndex++,
+                totalSteps: totalSteps ?? this.totalSteps
+            }
+        });
+    }
+    info(message, metadata) {
+        this.callbacks?.onProgress?.({ type: "info", message, metadata });
+    }
+    spinner(message, metadata) {
+        this.callbacks?.onProgress?.({ type: "spinner", message, metadata });
+    }
+    warning(message, metadata) {
+        this.callbacks?.onProgress?.({ type: "warning", message, metadata });
+    }
+    debug(message, metadata) {
+        this.callbacks?.onProgress?.({ type: "debug", message, metadata });
+    }
+    error(message, metadata) {
+        this.callbacks?.onProgress?.({ type: "error", message, metadata });
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Result } from "@fjall/generator";
+/**
+ * Interface for non-critical API operations.
+ *
+ * CLI provides a real implementation (FjallApiClient).
+ * Worker omits this — non-critical operations are handled
+ * by the webapp directly (it has DB access).
+ */
+export interface ApiClientInterface {
+    getIdentity(): Promise<Result<{
+        organisationId: string;
+        organisationName: string;
+    }>>;
+    getEntitlements(): Promise<Result<EntitlementsData>>;
+    verifyAwsAccount(data: {
+        awsAccountId: string;
+        accountName: string;
+    }): Promise<Result<unknown>>;
+    putOrganisationConfig(data: Record<string, unknown>): Promise<Result<unknown>>;
+    createApplication(data: Record<string, unknown>): Promise<Result<unknown>>;
+    createActivity(data: Record<string, unknown>): Promise<Result<unknown>>;
+}
+export interface EntitlementsData {
+    plan: string;
+    limits: {
+        awsAccounts: number;
+        applications: number;
+    };
+    usage: {
+        awsAccounts: number;
+        applications: number;
+    };
+    features: Record<string, boolean>;
+}

package/dist/src/types/apiClient.js

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

package/dist/src/types/application/ApplicationServiceTypes.d.ts

@@ -0,0 +1,56 @@
+import type { ApplicationStack } from "../operations.js";
+import type { ResourceEvent } from "../events.js";
+import { BaseServiceError } from "../errors/ServiceError.js";
+/**
+ * Wraps an error into an ApplicationError with consistent formatting.
+ */
+export declare function wrapApplicationError(message: string, errorType: ApplicationErrorType, appName: string | undefined, operation: string, error: unknown): ApplicationError;
+export interface StackDeploymentOptions {
+    verbose?: boolean;
+    onProgress?: (message: string) => void;
+    onResourceProgress?: (event: ResourceEvent) => void;
+}
+export interface StackDeploymentData {
+    stackName: string;
+    stackType: ApplicationStack;
+    skipped?: boolean;
+    outputs?: Record<string, string | number | boolean>;
+}
+/**
+ * Application deployment result data
+ */
+export interface ApplicationDeploymentData {
+    stacks: StackDeploymentData[];
+    dockerDeployed?: boolean;
+    ecrInitialised?: boolean;
+    message?: string;
+    websiteUrl?: string;
+}
+/**
+ * Application destruction result data
+ */
+export interface ApplicationDestructionData {
+    stacksDestroyed: string[];
+    skippedStacks: string[];
+}
+/**
+ * Application error types for categorised error handling
+ */
+export type ApplicationErrorType = "auth_failed" | "detection_failed" | "validation_failed" | "synth_failed" | "deployment_failed" | "destroy_failed" | "docker_failed" | "ecr_failed" | "stack_error" | "config_error" | "unknown";
+/**
+ * Application-specific error with typed error categories
+ */
+export declare class ApplicationError extends BaseServiceError {
+    readonly errorType: ApplicationErrorType;
+    readonly appName?: string;
+    readonly operation?: string;
+    readonly stackType?: ApplicationStack;
+    constructor(message: string, options: {
+        errorType: ApplicationErrorType;
+        appName?: string;
+        operation?: string;
+        stackType?: ApplicationStack;
+        details?: unknown;
+        recoverable?: boolean;
+    });
+}

package/dist/src/types/application/ApplicationServiceTypes.js

@@ -0,0 +1,30 @@
+import { BaseServiceError } from "../errors/ServiceError.js";
+import { getErrorMessage } from "@fjall/util";
+/**
+ * Wraps an error into an ApplicationError with consistent formatting.
+ */
+export function wrapApplicationError(message, errorType, appName, operation, error) {
+    const errorMsg = getErrorMessage(error);
+    return new ApplicationError(`${message}: ${errorMsg}`, {
+        errorType,
+        appName,
+        operation,
+        details: error
+    });
+}
+/**
+ * Application-specific error with typed error categories
+ */
+export class ApplicationError extends BaseServiceError {
+    errorType;
+    appName;
+    operation;
+    stackType;
+    constructor(message, options) {
+        super(`APPLICATION_${options.errorType.toUpperCase()}`, message, options.details, options.recoverable ?? false);
+        this.errorType = options.errorType;
+        this.appName = options.appName;
+        this.operation = options.operation;
+        this.stackType = options.stackType;
+    }
+}

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

@@ -0,0 +1 @@
+export { ApplicationError, wrapApplicationError, type ApplicationErrorType, type StackDeploymentData, type StackDeploymentOptions, type ApplicationDeploymentData, type ApplicationDestructionData } from "./ApplicationServiceTypes.js";

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

@@ -0,0 +1 @@
+export { ApplicationError, wrapApplicationError } from "./ApplicationServiceTypes.js";

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

@@ -0,0 +1,36 @@
+import type { ProgressEvent, ResourceEvent, AwsAuthResult, CascadeDeploymentResult, CascadePhase } from "./events.js";
+export type StepCompleteStatus = "completed" | "skipped" | "error";
+/**
+ * Unified callback interface for deployment progress.
+ *
+ * CLI adapter: formats for terminal output via OutputWriter.
+ * Worker adapter: writes events to DB and streams via SSE.
+ *
+ * All callbacks are optional. Omitting a callback means that
+ * event type is silently ignored.
+ */
+export interface DeployCallbacks {
+    onStepStart?: (stepId: string, stepName: string, stepIndex?: number, stepTotal?: number) => void;
+    onStepComplete?: (stepId: string, stepName: string, status: StepCompleteStatus, stepIndex?: number, stepTotal?: number) => void;
+    onProgress?: (event: ProgressEvent) => void;
+    onLog?: (message: string, level?: "info" | "debug" | "warn") => void;
+    onOutput?: (chunk: string) => void;
+    onResourceProgress?: (event: ResourceEvent) => void;
+    onDockerProgress?: (message: string, percentage?: number, layerId?: string, status?: string) => void;
+    onECSUpdate?: (status: string, service?: string) => void;
+    onECSProgress?: (message: string, percentage?: number) => void;
+    onCDKBootstrap?: (status: string) => void;
+    onCDKDiff?: (hasDifferences: boolean) => void;
+    onCdkOutput?: (output: string, type: "synth" | "diff") => void;
+    onCascadeStart?: () => void;
+    onCascadePhaseStart?: (phase: CascadePhase) => void;
+    onCascadeAccountStart?: (operationKey: string, accountId: string, region: string) => void;
+    onCascadeAccountPhaseChange?: (operationKey: string, phase: "synth" | "deploy" | "destroy", region?: string) => void;
+    onCascadeAccountResourceProgress?: (operationKey: string, event: ResourceEvent, region?: string) => void;
+    onCascadeAccountComplete?: (operationKey: string, success: boolean, error?: string, region?: string) => void;
+    onCascadeComplete?: (result: CascadeDeploymentResult) => void;
+    onSSOUrl?: (url: string | null) => void;
+    onAuthComplete?: (result: AwsAuthResult | null) => void;
+    onError?: (error: Error) => void;
+    verbose?: boolean;
+}

package/dist/src/types/callbacks.js

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

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

@@ -0,0 +1,6 @@
+/** CloudFormation error pattern indicating a stack doesn't exist */
+export declare const STACK_NOT_FOUND_PATTERN = "does not exist";
+/** CDK error pattern indicating no stacks matched the provided name */
+export declare const CDK_NO_STACKS_MATCH = "No stacks match the name(s)";
+/** The canonical name for generated infrastructure files */
+export declare const INFRASTRUCTURE_FILENAME = "infrastructure.ts";

package/dist/src/types/constants.js

@@ -0,0 +1,6 @@
+/** CloudFormation error pattern indicating a stack doesn't exist */
+export const STACK_NOT_FOUND_PATTERN = "does not exist";
+/** CDK error pattern indicating no stacks matched the provided name */
+export const CDK_NO_STACKS_MATCH = "No stacks match the name(s)";
+/** The canonical name for generated infrastructure files */
+export const INFRASTRUCTURE_FILENAME = "infrastructure.ts";

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

@@ -0,0 +1,30 @@
+/**
+ * AWS credentials for deployment. deploy-core never resolves these itself —
+ * the caller (CLI or worker) obtains credentials and injects them.
+ *
+ * CLI: resolves via SSO/OIDC profile authentication.
+ * Worker: resolves via OIDC JWT → STS AssumeRoleWithWebIdentity.
+ */
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    region: string;
+    accountId?: string;
+}
+/**
+ * Pre-fetched organisation identity for org deployments.
+ *
+ * CLI: omits this, provides apiClient instead (fetches from API).
+ * Worker: provides this from DB, omits apiClient.
+ */
+export interface DeployIdentity {
+    /** Fjall organisation ID (maps to what getIdentity() returns) */
+    fjallOrgId: string;
+    /** Plan tier — used for entitlement checks */
+    plan?: string;
+    /** Account limit from plan */
+    accountLimits?: number;
+    /** Current account count */
+    accountUsage?: number;
+}

package/dist/src/types/credentials.js

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

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

@@ -0,0 +1,23 @@
+import type { DeploymentContext } from "./DeploymentTypes.js";
+import type { StackOutputsRecord } from "./cloudformation.js";
+export type { StackOutput, StackOutputsRecord } from "./cloudformation.js";
+/**
+ * Extended deployment context for application deployments
+ */
+export interface ApplicationDeploymentContext extends Omit<DeploymentContext, "deployType"> {
+    deployType: "application" | "app";
+    appName: string;
+    path: string;
+    isManagedAccount?: boolean;
+    callerIdentity?: CallerIdentity;
+    stackOutputs?: StackOutputsRecord;
+}
+/**
+ * AWS Caller Identity structure
+ */
+export interface CallerIdentity {
+    Account: string;
+    UserId: string;
+    Arn: string;
+}
+export type { ValidationResult } from "../validation.js";

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

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

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

@@ -0,0 +1,29 @@
+import type { StackOutputsRecord } from "./cloudformation.js";
+import type { CallerIdentity } from "./DeploymentServiceTypes.js";
+export interface DeploymentContext {
+    deployType: "application" | "organisation" | "platform" | "account";
+    target: string;
+    accountName?: string;
+    region?: string;
+    callerIdentity?: CallerIdentity;
+    stackOutputs?: StackOutputsRecord;
+    isManagedAccount?: boolean;
+    imageVersion?: string;
+    orgId?: string;
+    rootId?: string;
+    managementAccountId?: string;
+    ipamPoolId?: string;
+    fjallOrgId?: string;
+    orgConfig?: string;
+    options: {
+        verbose?: boolean;
+        infraOnly?: boolean;
+    };
+    path: string;
+    logPath?: string;
+}
+export interface StepOutput {
+    message: string;
+    status?: "NO_CHANGES" | "SKIPPED";
+    details?: Record<string, unknown>;
+}