@go-to-k/cdkd 0.94.8 → 0.94.9

package/dist/index.d.ts

@@ -0,0 +1,703 @@
+import { S3Client } from "@aws-sdk/client-s3";
+import { CloudControlClient } from "@aws-sdk/client-cloudcontrol";
+import { IAMClient } from "@aws-sdk/client-iam";
+import { SQSClient } from "@aws-sdk/client-sqs";
+import { SNSClient } from "@aws-sdk/client-sns";
+import { LambdaClient } from "@aws-sdk/client-lambda";
+import { STSClient } from "@aws-sdk/client-sts";
+import { EC2Client } from "@aws-sdk/client-ec2";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { CloudFormationClient } from "@aws-sdk/client-cloudformation";
+import { APIGatewayClient } from "@aws-sdk/client-api-gateway";
+import { EventBridgeClient } from "@aws-sdk/client-eventbridge";
+import { SecretsManagerClient } from "@aws-sdk/client-secrets-manager";
+import { SSMClient } from "@aws-sdk/client-ssm";
+import { CloudFrontClient } from "@aws-sdk/client-cloudfront";
+import { CloudWatchClient } from "@aws-sdk/client-cloudwatch";
+import { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
+import { BedrockAgentCoreControlClient } from "@aws-sdk/client-bedrock-agentcore-control";
+import graphlib from "graphlib";
+
+//#region src/types/state.d.ts
+type StateSchemaVersion = 1 | 2 | 3;
+interface StackState {
+  version: StateSchemaVersion;
+  stackName: string;
+  region?: string;
+  resources: Record<string, ResourceState>;
+  outputs: Record<string, unknown>;
+  lastModified: number;
+}
+interface ResourceState {
+  physicalId: string;
+  resourceType: string;
+  properties: Record<string, unknown>;
+  observedProperties?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+  dependencies?: string[];
+  metadata?: Record<string, unknown>;
+}
+interface LockInfo {
+  owner: string;
+  timestamp: number;
+  expiresAt: number;
+  operation?: string;
+}
+type ChangeType = 'CREATE' | 'UPDATE' | 'DELETE' | 'NO_CHANGE';
+interface ResourceChange {
+  logicalId: string;
+  changeType: ChangeType;
+  resourceType: string;
+  currentProperties?: Record<string, unknown>;
+  desiredProperties?: Record<string, unknown>;
+  propertyChanges?: PropertyChange[];
+}
+interface PropertyChange {
+  path: string;
+  oldValue: unknown;
+  newValue: unknown;
+  requiresReplacement: boolean;
+}
+//#endregion
+//#region src/provisioning/region-check.d.ts
+interface DeleteContext {
+  expectedRegion?: string | undefined;
+  removeProtection?: boolean;
+}
+//#endregion
+//#region src/types/resource.d.ts
+interface CloudFormationTemplate {
+  AWSTemplateFormatVersion?: string;
+  Description?: string;
+  Parameters?: Record<string, TemplateParameter>;
+  Resources: Record<string, TemplateResource>;
+  Outputs?: Record<string, TemplateOutput>;
+  Conditions?: Record<string, unknown>;
+  Mappings?: Record<string, unknown>;
+}
+interface TemplateParameter {
+  Type: string;
+  Default?: unknown;
+  Description?: string;
+  AllowedValues?: unknown[];
+  AllowedPattern?: string;
+  ConstraintDescription?: string;
+}
+interface TemplateResource {
+  Type: string;
+  Properties?: Record<string, unknown>;
+  DependsOn?: string | readonly string[];
+  Condition?: string;
+  Metadata?: Record<string, unknown>;
+  CreationPolicy?: Record<string, unknown>;
+  UpdatePolicy?: Record<string, unknown>;
+  DeletionPolicy?: 'Delete' | 'Retain' | 'Snapshot';
+  UpdateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot';
+}
+interface TemplateOutput {
+  Value: unknown;
+  Description?: string;
+  Export?: {
+    Name: string;
+  };
+}
+interface ResourceCreateResult {
+  physicalId: string;
+  attributes?: Record<string, unknown>;
+}
+interface ResourceUpdateResult {
+  physicalId: string;
+  wasReplaced: boolean;
+  attributes?: Record<string, unknown>;
+}
+interface ResourceImportInput {
+  logicalId: string;
+  resourceType: string;
+  cdkPath: string;
+  stackName: string;
+  region: string;
+  properties: Record<string, unknown>;
+  knownPhysicalId?: string;
+}
+interface ResourceImportResult {
+  physicalId: string;
+  attributes?: Record<string, unknown>;
+}
+interface ResourceProvider {
+  handledProperties?: ReadonlyMap<string, ReadonlySet<string>>;
+  disableCcApiFallback?: boolean;
+  disableOuterRetry?: boolean;
+  getMinResourceTimeoutMs?(): number;
+  preparePropertiesForFallback?(logicalId: string, resourceType: string, properties: Record<string, unknown>): Record<string, unknown>;
+  create(logicalId: string, resourceType: string, properties: Record<string, unknown>): Promise<ResourceCreateResult>;
+  update(logicalId: string, physicalId: string, resourceType: string, properties: Record<string, unknown>, previousProperties: Record<string, unknown>): Promise<ResourceUpdateResult>;
+  delete(logicalId: string, physicalId: string, resourceType: string, properties?: Record<string, unknown>, context?: DeleteContext): Promise<void>;
+  getAttribute?(physicalId: string, resourceType: string, attributeName: string): Promise<unknown>;
+  readCurrentState?(physicalId: string, logicalId: string, resourceType: string, properties?: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+  getDriftUnknownPaths?(resourceType: string): string[];
+  import?(input: ResourceImportInput): Promise<ResourceImportResult | null>;
+}
+//#endregion
+//#region src/types/config.d.ts
+interface CdkdConfig {
+  app: string;
+  stateBucket: string;
+  statePrefix?: string;
+  stack?: string;
+  region?: string;
+  profile?: string;
+  concurrency?: number;
+  verbose?: boolean;
+  dryRun?: boolean;
+  output?: string;
+}
+interface DeployOptions {
+  stackName: string;
+  template: string;
+  stateBackend: StateBackendConfig;
+  concurrency: number;
+  dryRun: boolean;
+  skipAssets?: boolean;
+}
+interface StateBackendConfig {
+  bucket: string;
+  prefix: string;
+}
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface Logger {
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+//#endregion
+//#region src/utils/logger.d.ts
+declare class ConsoleLogger implements Logger {
+  private level;
+  private useColors;
+  constructor(level?: LogLevel, useColors?: boolean);
+  private shouldLog;
+  private formatMessage;
+  private emit;
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  setLevel(level: LogLevel): void;
+  getLevel(): LogLevel;
+  child(prefix: string): ChildLogger;
+}
+declare class ChildLogger extends ConsoleLogger {
+  private readonly prefix;
+  constructor(prefix: string, useColors: boolean);
+  private syncLevel;
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+declare function getLogger(): ConsoleLogger;
+declare function setLogger(logger: ConsoleLogger): void;
+//#endregion
+//#region src/utils/error-handler.d.ts
+declare class CdkdError extends Error {
+  readonly code: string;
+  readonly cause: Error | undefined;
+  constructor(message: string, code: string, cause?: Error);
+}
+declare class StateError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare class LockError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare class SynthesisError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare class AssetError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare class ProvisioningError extends CdkdError {
+  readonly resourceType: string;
+  readonly logicalId: string;
+  readonly physicalId: string | undefined;
+  constructor(message: string, resourceType: string, logicalId: string, physicalId?: string, cause?: Error);
+}
+declare class DependencyError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare class ConfigError extends CdkdError {
+  constructor(message: string, cause?: Error);
+}
+declare function isCdkdError(error: unknown): error is CdkdError;
+declare function formatError(error: unknown): string;
+interface NormalizeAwsErrorContext {
+  bucket?: string;
+  operation?: string;
+}
+declare function normalizeAwsError(err: unknown, context?: NormalizeAwsErrorContext): Error;
+//#endregion
+//#region src/utils/aws-clients.d.ts
+interface AwsClientConfig {
+  region?: string;
+  profile?: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+  };
+}
+declare class AwsClients {
+  private s3Client?;
+  private cloudControlClient?;
+  private iamClient?;
+  private sqsClient?;
+  private snsClient?;
+  private lambdaClient?;
+  private stsClient?;
+  private ec2Client?;
+  private dynamoDBClient?;
+  private cloudFormationClient?;
+  private apiGatewayClient?;
+  private eventBridgeClient?;
+  private secretsManagerClient?;
+  private ssmClient?;
+  private cloudFrontClient?;
+  private cloudWatchClient?;
+  private cloudWatchLogsClient?;
+  private bedrockAgentCoreControlClient?;
+  private config;
+  constructor(config?: AwsClientConfig);
+  getS3Client(): S3Client;
+  getCloudControlClient(): CloudControlClient;
+  getIAMClient(): IAMClient;
+  get s3(): S3Client;
+  get cloudControl(): CloudControlClient;
+  get iam(): IAMClient;
+  getSQSClient(): SQSClient;
+  get sqs(): SQSClient;
+  getSNSClient(): SNSClient;
+  get sns(): SNSClient;
+  getLambdaClient(): LambdaClient;
+  get lambda(): LambdaClient;
+  getEC2Client(): EC2Client;
+  get ec2(): EC2Client;
+  getSTSClient(): STSClient;
+  get sts(): STSClient;
+  getDynamoDBClient(): DynamoDBClient;
+  get dynamoDB(): DynamoDBClient;
+  getCloudFormationClient(): CloudFormationClient;
+  get cloudFormation(): CloudFormationClient;
+  getAPIGatewayClient(): APIGatewayClient;
+  get apiGateway(): APIGatewayClient;
+  getEventBridgeClient(): EventBridgeClient;
+  get eventBridge(): EventBridgeClient;
+  getSecretsManagerClient(): SecretsManagerClient;
+  get secretsManager(): SecretsManagerClient;
+  getSSMClient(): SSMClient;
+  get ssm(): SSMClient;
+  getCloudFrontClient(): CloudFrontClient;
+  get cloudFront(): CloudFrontClient;
+  getCloudWatchClient(): CloudWatchClient;
+  get cloudWatch(): CloudWatchClient;
+  getCloudWatchLogsClient(): CloudWatchLogsClient;
+  get cloudWatchLogs(): CloudWatchLogsClient;
+  getBedrockAgentCoreControlClient(): BedrockAgentCoreControlClient;
+  get bedrockAgentCoreControl(): BedrockAgentCoreControlClient;
+  destroy(): void;
+}
+declare function getAwsClients(config?: AwsClientConfig): AwsClients;
+declare function setAwsClients(clients: AwsClients): void;
+declare function resetAwsClients(): void;
+//#endregion
+//#region src/utils/aws-region-resolver.d.ts
+interface ResolveBucketRegionOptions {
+  profile?: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+  };
+  fallbackRegion?: string;
+}
+declare function resolveBucketRegion(bucketName: string, opts?: ResolveBucketRegionOptions): Promise<string>;
+declare function clearBucketRegionCache(): void;
+//#endregion
+//#region src/types/assembly.d.ts
+interface AssemblyManifest {
+  version: string;
+  artifacts?: Record<string, ArtifactManifest>;
+  missing?: MissingContext[];
+  runtime?: RuntimeInfo;
+}
+interface ArtifactManifest {
+  type: ArtifactType;
+  environment?: string;
+  displayName?: string;
+  properties?: Record<string, unknown>;
+  dependencies?: string[];
+  metadata?: Record<string, MetadataEntry[]>;
+}
+type ArtifactType = 'aws:cloudformation:stack' | 'cdk:asset-manifest' | 'cdk:tree' | 'cdk:cloud-assembly' | 'cdk:feature-flag-report';
+interface MissingContext {
+  key: string;
+  provider: string;
+  props: ContextQueryProperties;
+}
+interface ContextQueryProperties {
+  account: string;
+  region: string;
+  lookupRoleArn?: string;
+  [key: string]: unknown;
+}
+interface MetadataEntry {
+  type: string;
+  data?: unknown;
+  trace?: string[];
+}
+interface RuntimeInfo {
+  libraries?: Record<string, string>;
+}
+//#endregion
+//#region src/synthesis/assembly-reader.d.ts
+interface StackInfo {
+  stackName: string;
+  displayName: string;
+  artifactId: string;
+  template: CloudFormationTemplate;
+  assetManifestPath?: string | undefined;
+  dependencyNames: string[];
+  region?: string | undefined;
+  account?: string | undefined;
+  terminationProtection?: boolean | undefined;
+}
+declare class AssemblyReader {
+  private logger;
+  readManifest(assemblyDir: string): AssemblyManifest;
+  getAllStacks(assemblyDir: string, manifest: AssemblyManifest): StackInfo[];
+  getStack(assemblyDir: string, manifest: AssemblyManifest, stackName: string): StackInfo;
+  getTemplate(assemblyDir: string, manifest: AssemblyManifest, stackName: string): CloudFormationTemplate;
+  private buildAssetManifestMap;
+  private extractStackInfo;
+  hasAssets(stackInfo: StackInfo): boolean;
+}
+//#endregion
+//#region src/synthesis/synthesizer.d.ts
+interface SynthesisOptions {
+  app: string;
+  output?: string;
+  profile?: string;
+  region?: string;
+  context?: Record<string, string>;
+}
+interface SynthesisResult {
+  manifest: AssemblyManifest;
+  assemblyDir: string;
+  stacks: StackInfo[];
+}
+declare class Synthesizer {
+  private logger;
+  private appExecutor;
+  private assemblyReader;
+  private contextStore;
+  synthesize(options: SynthesisOptions): Promise<SynthesisResult>;
+  listStacks(options: SynthesisOptions): Promise<string[]>;
+}
+//#endregion
+//#region src/deployment/work-graph.d.ts
+type WorkNodeType = 'asset-build' | 'asset-publish' | 'stack';
+type NodeState = 'pending' | 'queued' | 'running' | 'completed' | 'failed' | 'skipped';
+interface WorkNode {
+  id: string;
+  type: WorkNodeType;
+  dependencies: Set<string>;
+  state: NodeState;
+  data: unknown;
+}
+interface WorkGraphConcurrency {
+  'asset-build': number;
+  'asset-publish': number;
+  stack: number;
+}
+declare class WorkGraph {
+  private nodes;
+  private logger;
+  addNode(node: WorkNode): void;
+  execute(concurrency: WorkGraphConcurrency, fn: (node: WorkNode) => Promise<void>): Promise<void>;
+  summary(): Record<WorkNodeType, number>;
+}
+//#endregion
+//#region src/assets/asset-publisher.d.ts
+interface AssetPublisherOptions {
+  profile?: string;
+  region?: string;
+  accountId?: string;
+  assetPublishConcurrency?: number;
+  imageBuildConcurrency?: number;
+}
+declare class AssetPublisher {
+  private logger;
+  private filePublisher;
+  private dockerPublisher;
+  addAssetsToGraph(graph: WorkGraph, manifestPath: string, options: {
+    accountId: string;
+    region: string;
+    profile?: string;
+    nodePrefix?: string;
+  }): string[];
+  executeNode(node: WorkNode): Promise<void>;
+  publishFromManifest(manifestPath: string, options?: AssetPublisherOptions): Promise<void>;
+  hasAssets(manifestPath: string): boolean;
+}
+//#endregion
+//#region src/state/s3-state-backend.d.ts
+interface StackStateRef {
+  stackName: string;
+  region?: string;
+}
+interface S3ClientOptions {
+  region?: string;
+  profile?: string;
+  credentials?: {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+  };
+}
+declare class S3StateBackend {
+  private logger;
+  private s3Client;
+  private config;
+  private clientOpts;
+  private clientResolved;
+  private resolveInFlight;
+  constructor(s3Client: S3Client, config: StateBackendConfig, clientOpts?: S3ClientOptions);
+  private getStateKey;
+  private getLegacyStateKey;
+  private ensureClientForBucket;
+  verifyBucketExists(): Promise<void>;
+  stateExists(stackName: string, region: string): Promise<boolean>;
+  getState(stackName: string, region: string): Promise<{
+    state: StackState;
+    etag: string;
+    migrationPending?: boolean;
+  } | null>;
+  saveState(stackName: string, region: string, state: StackState, options?: {
+    expectedEtag?: string;
+    migrateLegacy?: boolean;
+  }): Promise<string>;
+  deleteState(stackName: string, region: string): Promise<void>;
+  listStacks(): Promise<StackStateRef[]>;
+  private headObject;
+  private readLegacyRegion;
+  private legacyMatchesRegion;
+  private tryGetLegacy;
+  private parseStateBody;
+}
+//#endregion
+//#region src/state/lock-manager.d.ts
+interface LockManagerOptions {
+  ttlMinutes?: number;
+}
+declare class LockManager {
+  private logger;
+  private s3Client;
+  private config;
+  private readonly ttlMs;
+  constructor(s3Client: S3Client, config: StateBackendConfig, options?: LockManagerOptions);
+  private getLockKey;
+  private getDefaultOwner;
+  private isLockExpired;
+  private formatDuration;
+  acquireLock(stackName: string, region: string, owner?: string, operation?: string): Promise<boolean>;
+  getLockInfo(stackName: string, region: string | undefined): Promise<LockInfo | null>;
+  isLocked(stackName: string, region: string | undefined): Promise<boolean>;
+  releaseLock(stackName: string, region: string): Promise<void>;
+  forceReleaseLock(stackName: string, region: string | undefined): Promise<void>;
+  private deleteLock;
+  acquireLockWithRetry(stackName: string, region: string, owner?: string, operation?: string, maxRetries?: number, retryDelay?: number): Promise<void>;
+}
+//#endregion
+//#region src/analyzer/template-parser.d.ts
+declare class TemplateParser {
+  private logger;
+  getResourceIds(template: CloudFormationTemplate): string[];
+  getResource(template: CloudFormationTemplate, logicalId: string): TemplateResource | undefined;
+  extractDependencies(resource: TemplateResource): Set<string>;
+  private extractRefsFromValue;
+  hasProperty(resource: TemplateResource, propertyPath: string): boolean;
+  getProperty(resource: TemplateResource, propertyPath: string): unknown;
+  validateTemplate(template: unknown): template is CloudFormationTemplate;
+  getResourcesByType(template: CloudFormationTemplate, resourceType: string): Map<string, TemplateResource>;
+  countResources(template: CloudFormationTemplate): number;
+}
+//#endregion
+//#region src/analyzer/dag-builder.d.ts
+type GraphType = graphlib.Graph;
+interface DagBuilderOptions {
+  relaxCdkVpcDefensiveDeps?: boolean;
+}
+declare class DagBuilder {
+  private logger;
+  private parser;
+  private options;
+  constructor(options?: DagBuilderOptions);
+  buildGraph(template: CloudFormationTemplate): GraphType;
+  getExecutionLevels(graph: GraphType): string[][];
+  private findCycles;
+  getAllDependencies(graph: GraphType, logicalId: string): Set<string>;
+  getAllDependents(graph: GraphType, logicalId: string): Set<string>;
+  getDirectDependencies(graph: GraphType, logicalId: string): string[];
+  getDirectDependents(graph: GraphType, logicalId: string): string[];
+  dependsOn(graph: GraphType, resourceA: string, resourceB: string): boolean;
+  private addCustomResourcePolicyEdges;
+  private addLambdaVpcEdges;
+  private isCustomResourceType;
+  private buildRolePoliciesMap;
+  private extractAttachedRoleIds;
+  private extractLogicalIdFromReference;
+}
+//#endregion
+//#region src/analyzer/diff-calculator.d.ts
+type IntrinsicResolveFn = (value: unknown) => Promise<unknown>;
+declare class DiffCalculator {
+  private logger;
+  private replacementRules;
+  calculateDiff(currentState: StackState, desiredTemplate: CloudFormationTemplate, resolveFn?: IntrinsicResolveFn): Promise<Map<string, ResourceChange>>;
+  private resolveBestEffort;
+  private compareProperties;
+  private static readonly INTRINSIC_KEYS;
+  private static isIntrinsic;
+  private valuesEqual;
+  getSummary(changes: Map<string, ResourceChange>): {
+    create: number;
+    update: number;
+    delete: number;
+    noChange: number;
+    total: number;
+  };
+  filterByType(changes: Map<string, ResourceChange>, type: ChangeType): ResourceChange[];
+  hasChanges(changes: Map<string, ResourceChange>): boolean;
+  getReplacementChanges(changes: Map<string, ResourceChange>): ResourceChange[];
+}
+//#endregion
+//#region src/provisioning/cloud-control-provider.d.ts
+declare class CloudControlProvider implements ResourceProvider {
+  private cloudControlClient;
+  private logger;
+  private patchGenerator;
+  private readonly MAX_WAIT_TIME_MS;
+  private readonly INITIAL_POLL_INTERVAL_MS;
+  private readonly MAX_POLL_INTERVAL_MS;
+  constructor();
+  create(logicalId: string, resourceType: string, properties: Record<string, unknown>): Promise<ResourceCreateResult>;
+  update(logicalId: string, physicalId: string, resourceType: string, properties: Record<string, unknown>, previousProperties: Record<string, unknown>): Promise<ResourceUpdateResult>;
+  delete(logicalId: string, physicalId: string, resourceType: string, _properties?: Record<string, unknown>, context?: DeleteContext): Promise<void>;
+  getResourceState(resourceType: string, physicalId: string): Promise<Record<string, unknown> | null>;
+  private waitForOperation;
+  private parseResourceModel;
+  private enrichResourceAttributes;
+  private handleError;
+  private sleep;
+  static isSupportedResourceType(resourceType: string): boolean;
+  readCurrentState(physicalId: string, _logicalId: string, resourceType: string, _properties?: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+  import(input: ResourceImportInput): Promise<ResourceImportResult | null>;
+}
+//#endregion
+//#region src/provisioning/provider-registry.d.ts
+declare class ProviderRegistry {
+  private logger;
+  private providers;
+  private cloudControlProvider;
+  private customResourceProvider;
+  private skipResourceTypes;
+  constructor();
+  setCustomResourceResponseBucket(bucket: string, bucketRegion?: string): void;
+  skipResourceType(resourceType: string): void;
+  register(resourceType: string, provider: ResourceProvider): void;
+  unregister(resourceType: string): void;
+  getProvider(resourceType: string): ResourceProvider;
+  shouldSkipResource(resourceType: string): boolean;
+  hasProvider(resourceType: string): boolean;
+  getCloudControlProvider(): CloudControlProvider;
+  getRegisteredTypes(): string[];
+  getProviderType(resourceType: string): 'sdk' | 'cloud-control' | null;
+  validateResourceTypes(resourceTypes: Set<string>): void;
+}
+//#endregion
+//#region src/provisioning/providers/iam-role-provider.d.ts
+declare class IAMRoleProvider implements ResourceProvider {
+  private iamClient;
+  private logger;
+  handledProperties: Map<string, ReadonlySet<string>>;
+  constructor();
+  create(logicalId: string, resourceType: string, properties: Record<string, unknown>): Promise<ResourceCreateResult>;
+  update(logicalId: string, physicalId: string, resourceType: string, properties: Record<string, unknown>, previousProperties: Record<string, unknown>): Promise<ResourceUpdateResult>;
+  delete(logicalId: string, physicalId: string, resourceType: string, _properties?: Record<string, unknown>, context?: DeleteContext): Promise<void>;
+  private detachAllManagedPolicies;
+  private deleteAllInlinePolicies;
+  private removeFromAllInstanceProfiles;
+  private updateManagedPolicies;
+  private updateInlinePolicies;
+  private updateTags;
+  getAttribute(physicalId: string, _resourceType: string, attributeName: string): Promise<unknown>;
+  readCurrentState(physicalId: string, _logicalId: string, _resourceType: string, properties?: Record<string, unknown>): Promise<Record<string, unknown> | undefined>;
+  import(input: ResourceImportInput): Promise<ResourceImportResult | null>;
+}
+//#endregion
+//#region src/deployment/deploy-engine.d.ts
+interface DeployEngineOptions {
+  concurrency?: number;
+  dryRun?: boolean;
+  lockTimeout?: number;
+  parameters?: Record<string, string>;
+  noRollback?: boolean;
+  resourceWarnAfterMs?: number;
+  resourceTimeoutMs?: number;
+  resourceWarnAfterByType?: Record<string, number>;
+  resourceTimeoutByType?: Record<string, number>;
+  captureObservedState?: boolean;
+}
+interface DeployResult {
+  stackName: string;
+  created: number;
+  updated: number;
+  deleted: number;
+  unchanged: number;
+  durationMs: number;
+}
+declare class DeployEngine {
+  private logger;
+  private resolver;
+  private interrupted;
+  private observedCaptureTasks;
+  private stateBackend;
+  private lockManager;
+  private dagBuilder;
+  private diffCalculator;
+  private providerRegistry;
+  private options;
+  private stackRegion;
+  constructor(stateBackend: S3StateBackend, lockManager: LockManager, dagBuilder: DagBuilder, diffCalculator: DiffCalculator, providerRegistry: ProviderRegistry, options: DeployEngineOptions | undefined, stackRegion: string);
+  deploy(stackName: string, template: CloudFormationTemplate): Promise<DeployResult>;
+  private kickOffObservedCapture;
+  private drainObservedCaptures;
+  private kickOffAutoRefreshObservedProperties;
+  private doDeploy;
+  private executeDeployment;
+  private performRollback;
+  private sortRollbackCreates;
+  private performSingleRollback;
+  private provisionResource;
+  private provisionResourceBody;
+  private extractAllDependencies;
+  private hasPending;
+  private buildDeletionDependencies;
+  private addImplicitDeleteDependencies;
+  private selectProviderWithSafetyNet;
+  private withRetry;
+  private resolveOutputs;
+}
+//#endregion
+export { AssemblyReader, AssetError, AssetPublisher, type AssetPublisherOptions, AwsClients, type CdkdConfig, CdkdError, type ChangeType, CloudControlProvider, type CloudFormationTemplate, ConfigError, ConsoleLogger, DagBuilder, DependencyError, DeployEngine, type DeployEngineOptions, type DeployOptions, type DeployResult, DiffCalculator, IAMRoleProvider, LockError, type LockInfo, LockManager, type LogLevel, type Logger, type NormalizeAwsErrorContext, type PropertyChange, ProviderRegistry, ProvisioningError, type ResolveBucketRegionOptions, type ResourceChange, type ResourceCreateResult, type ResourceProvider, type ResourceState, type ResourceUpdateResult, S3StateBackend, type StackInfo, type StackState, type StateBackendConfig, StateError, SynthesisError, type SynthesisOptions, type SynthesisResult, Synthesizer, type TemplateOutput, type TemplateParameter, TemplateParser, type TemplateResource, clearBucketRegionCache, formatError, getAwsClients, getLogger, isCdkdError, normalizeAwsError, resetAwsClients, resolveBucketRegion, setAwsClients, setLogger };
+//# sourceMappingURL=index.d.ts.map