@glicogh/healthcare-cdk 0.1.89 → 0.1.90

package/.env.example

@@ -5,6 +5,8 @@ COMPANY_NAME=glico
 AWS_REGION=eu-west-2
 AWS_ACCOUNT_ID=825765383017
 
+# Optional local overrides go in .env.local (gitignored), e.g. MIGRATION_REPO_PATH=/path/to/migration
+
 EC2_REDIS_INSTANCE_TYPE=t4g.nano
 EC2_REDIS_INSTANCE_STORAGE_SIZE=
 EC2_REDIS_INSTANCE_STORAGE_TYPE=gp3

package/README.md

@@ -116,7 +116,13 @@ Only the selected stack is synthesized, so unrelated stacks (and their code asse
 
 `MicroserviceMigration` bundles the migration producer/consumer Lambdas (from the sibling `migration/lambdas` directory), the `migration-queue.fifo` queue, a `migration-verifier` Lambda, an S3 artifacts bucket, a one-shot ECS Fargate scripts runner, and the `migration-orchestrator` Step Function (`cdk/constructs/migration-state-machine.ts`). Invoking the state machine runs the migration runbook end-to-end:
 
-- **Scripts (runbook Steps 1–4)** run as one-shot ECS Fargate tasks from the migration repo's `Dockerfile` (entrypoint dispatches `restore` / `migrations` / `diseases` / `claim-batches` / `reset`). The restore task syncs the legacy dump from S3 first; no 15-minute Lambda cap.
+The stack also provisions the `legacy-s3-backups` EventBridge bus (`cdk/constructs/legacy-s3-backups-bus.ts`) for legacy S3 backup events forwarded from the main account (`169555392631`, see `legacyS3BackupsMainAccountId`). The bus allows `events:PutEvents` from that account, has CloudWatch logging enabled at TRACE/FULL detail delivered through vended logs to `/aws/vendedlogs/events/event-bus/legacy-s3-backups`, and a rule that logs every event payload to the `legacy-s3-backups` log group. The bus ARN is exported as the `legacy-s3-backups-arn` output.
+
+The bus also auto-starts the migration orchestrator from source archives landing in `s3://glicogh-pether-backup` (`legacyBackupBucketName`, read cross-account by the ECS scripts task role). Triggers are declared once in CDK as `MIGRATION_TRIGGERS` (`{ name, prefix, options, once }`) and passed to the `migration-runner` Lambda; the `legacy-s3-backups-migration-runner` rule forwards every event on the bus to it, and the runner applies the trigger policy itself. Today: `daily_backups/*.tar.gz` starts a delta run (`restoreMode: 'delta', affected: true, precomputeMode: 'incremental'`), and the first `weekly_backups/*.tar.gz` ever starts a fresh full run (`resetTracking: true, precomputeMode: 'full'`, `once: true`) — later weekly events are skipped until the SSM marker `/<env>/microservices/migration/triggers/weekly` is deleted. Every trigger also skips while an orchestrator execution is already RUNNING, and derives the execution name from the object key for dedupe.
+
+Daily runs are **deltas**: the payload adds `restoreMode: 'delta', affected: true`, so `s1-restore-delta` inserts the changed rows into the persistent legacy tables (no DROP/CREATE, duplicate key updates the row) and skips `s2-migrations`; `s4b-resolve-affected` then maps the changed rows (`migration_affected_source`) to resource ids (`migration_affected`, including claim `batch_key`s via `claim_batches.sibling_claim_ids`), and each resource step runs a targeted pass with `skipMigrated: false` so the target APIs receive updates, followed by `migration-clear-affected` for that resource. Weekly runs keep the full restore → schema → `skipMigrated` top-up path. Daily precompute is incremental (`precomputeMode: 'incremental'`): `s3-disease-lookups` and `s4-claim-batches` update only the batches/disease mappings touched by `migration_affected_source`, instead of truncating and rescanning; weekly/full runs use `precomputeMode: 'full'`. The restore ECS task downloads the archive, extracts it (top-level CSV folder or flat), and runs `restore-legacy-backup`.
+
+- **Scripts (runbook Steps 1–4)** run as one-shot ECS Fargate tasks from the migration repo's `Dockerfile` (entrypoint dispatches `restore` / `migrations` / `diseases` / `claim-batches` / `reset`). The restore task syncs the legacy dump from S3 first; no 15-minute Lambda cap. The precompute steps (`diseases`, `claim-batches`) always run when a restore runs; without one they only run when selected via `runPrecompute`. Their mode comes from `precomputeMode` (`incremental` updates only the delta's changed rows; `full` truncates and rebuilds).
 - **Migratables (Steps 5–16)** loop the producer Lambda until the response reports `endReached: true`, then wait for the SQS queue to drain (`ApproximateNumberOfMessages` + `NotVisible` = 0) before the next dependency step. Tier 0 (users, providers, insured, tpa, plans) runs as a `Parallel`.
 - **Every resource gets a retry pass** (`fromStart: true, skipMigrated: true`) after the first pass + drain, recovering records dropped by transient service failures.
 - **Verification** invokes the verifier Lambda, which writes `runs/<execution-name>/summary.json` (migrated counts, source counts, API totals) to the artifacts bucket.
@@ -127,17 +133,30 @@ Only the selected stack is synthesized, so unrelated stacks (and their code asse
 aws s3 sync data/legacy-backup s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/
 ```
 
-**Start an execution** (all input fields are required; `fromStep` uses the step ids below, `""` = full run):
+**Start an execution** (all input fields are optional; defaults shown):
 
 ```json
 {
   "backupS3Uri": "s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/",
-  "fresh": false,
-  "skipPhotos": false,
+  "resetTracking": false,
+  "restore": true,
+  "runPrecompute": [],
+  "skipMigrated": true,
+  "refresh": false,
+  "ignoreProgress": false,
   "fromStep": ""
 }
 ```
 
+- `backupS3Uri` is required only when the restore step runs (omit it with `restore: false` or a `fromStep` past restore).
+- `resetTracking: true` truncates `migrated`/`disease_lookup`/`claim_batches` and clears the Redis cursors before restoring; it cannot be combined with `restore: false`.
+- `restore: false` runs against the existing legacy DB (skips the reset/restore steps).
+- `runPrecompute` selects which precompute steps (`"diseases"`, `"claim-batches"`) run when `restore` is false; `true` means all, `[]`/`false` means none (default `[]`). A restore always runs both precomputes. `precomputeMode` (`"full"` default, or `"incremental"`) selects their mode independently of `restoreMode`.
+- `skipMigrated: true` (default) publishes only records without a `migrated` row — a completed step ends immediately and advances its cursor; `skipMigrated: false` publishes from the cursor onward (existing records are PUT-updated).
+- `refresh: true` (requires `skipMigrated: false`) republishes every record from the start, so migrated records are PUT-updated; combine with `fromStep` to scope it to one step.
+- `ignoreProgress: true` clears the recorded progress marker and re-evaluates the start point (`resetTracking`/`restore`).
+- `fromStep` jumps to a step and records the step before it as the progress baseline.
+
 ```
 aws stepfunctions start-execution \
   --state-machine-arn <state-machine-arn> \
@@ -147,11 +166,11 @@ aws stepfunctions start-execution \
 
 Step ids for `fromStep`: `fresh-reset`, `restore`, `migrations`, `diseases`, `claim-batches`, `product-sources`, `product-categories`, `products`, `categories`, `coverage-groups`, `tier0`, `product-pricing`, `policies`, `benefits`, `plans-rewire`, `beneficiaries-principals`, `beneficiaries-dependants`, `beneficiary-photos`, `claims`.
 
-**Pause/resume**: every step is idempotent and cursor-backed — stop the execution and re-invoke later (optionally with `fromStep`). Completed resources no-op on the first producer invocation (`endReached` immediately). Guards fail the execution instead of looping forever: 2,000 producer invocations per pass, 600 drain checks (5-minute interval). Execution timeout 7 days.
+**Pause/resume**: the state machine records the last completed step in the SSM parameter `/<env>/microservices/migration/orchestrator/progress` (imported by name, not managed by CloudFormation; holds the last completed step id, or `none` when cleared). Stop the execution and re-invoke with the same input — it resumes at the step after the recorded one (skipped precompute steps are recorded too, so a resume continues past them). `ignoreProgress: true` clears the marker and re-evaluates the start point; `fromStep` jumps explicitly and writes the preceding step as the baseline. Every step is idempotent and cursor-backed; with the default `skipMigrated: true` a fully-migrated step returns immediately (`endReached`, cursor advanced). Guards fail the execution instead of looping forever: 2,000 producer invocations per pass, 4,000 drain checks (30-second interval). Execution timeout 7 days.
 
 **Monitoring**: Step Functions execution history; state-machine logs at `/aws/vendedlogs/states/migration-orchestrator`; ECS task logs under `/aws/ecs/migration-scripts`; the verifier summary in S3.
 
-**Notes**: the consumer's reserved concurrency is set to `max(50, MIGRATION_QUEUE_SHARDS)` so claims FIFO shards run in parallel. `fresh: true` truncates `migrated`/`disease_lookup`/`claim_batches` and clears the `glico_healthcare_migration:*` Redis cursors before restoring; the restore task re-imports all tables per run (container-local tracking). Secure envs (`DB_PASSWORD`, `MIGRATION_API_KEY`) are injected into the ECS task from SSM.
+**Notes**: the consumer's reserved concurrency is set to `max(50, MIGRATION_QUEUE_SHARDS)` so claims FIFO shards run in parallel. `resetTracking: true` truncates `migrated`/`disease_lookup`/`claim_batches` and clears the `glico_healthcare_migration:*` Redis cursors before restoring; the restore task re-imports all tables per run (container-local tracking). Secure envs (`DB_PASSWORD`, `MIGRATION_API_KEY`) are injected into the ECS task from SSM.
 
 ### Pipeline-based stack
 

package/dist/constructs/legacy-s3-backups-bus.d.ts

@@ -0,0 +1,23 @@
+import * as events from 'aws-cdk-lib/aws-events';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+export interface LegacyS3BackupsBusProps {
+    readonly busName: string;
+    readonly allowedAccountIds: string[];
+}
+export interface MigrationTrigger {
+    readonly name: string;
+    readonly prefix: string;
+    readonly options: Record<string, unknown>;
+    readonly once?: boolean;
+}
+export declare class LegacyS3BackupsBus extends Construct {
+    readonly bus: events.EventBus;
+    readonly ruleLogGroup: logs.LogGroup;
+    readonly vendedLogGroup: logs.LogGroup;
+    private readonly busName;
+    constructor(scope: Construct, id: string, props: LegacyS3BackupsBusProps);
+    addMigrationRunner(target: lambda.IFunction): void;
+    private configureVendedLogDelivery;
+}

package/dist/constructs/legacy-s3-backups-bus.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyS3BackupsBus = void 0;
+const cdk = require("aws-cdk-lib");
+const events = require("aws-cdk-lib/aws-events");
+const eventsTargets = require("aws-cdk-lib/aws-events-targets");
+const iam = require("aws-cdk-lib/aws-iam");
+const logs = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+class LegacyS3BackupsBus extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.busName = props.busName;
+        this.ruleLogGroup = new logs.LogGroup(this, 'RuleLogGroup', {
+            logGroupName: props.busName,
+            retention: logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.vendedLogGroup = new logs.LogGroup(this, 'VendedLogGroup', {
+            logGroupName: `/aws/vendedlogs/events/event-bus/${props.busName}`,
+            retention: logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.bus = new events.EventBus(this, 'EventBus', {
+            eventBusName: props.busName,
+            logConfig: {
+                level: events.Level.TRACE,
+                includeDetail: events.IncludeDetail.FULL,
+            },
+        });
+        this.bus.addToResourcePolicy(new iam.PolicyStatement({
+            sid: 'AllowMainAccountPutEvents',
+            effect: iam.Effect.ALLOW,
+            principals: props.allowedAccountIds.map((accountId) => new iam.AccountPrincipal(accountId)),
+            actions: ['events:PutEvents'],
+            resources: [this.bus.eventBusArn],
+        }));
+        new events.Rule(this, 'LogAllEventsRule', {
+            ruleName: `${props.busName}-log-all-events`,
+            description: `Logs every event published to the ${props.busName} event bus to the ${props.busName} CloudWatch log group`,
+            eventBus: this.bus,
+            eventPattern: { source: events.Match.exists() },
+            targets: [new eventsTargets.CloudWatchLogGroup(this.ruleLogGroup)],
+        });
+        this.configureVendedLogDelivery(props.busName);
+    }
+    // Catch-all: the bus policy already restricts senders to the allowed
+    // accounts, and the migration runner applies the MIGRATION_TRIGGERS policy
+    // (bucket, archive suffix, size, prefix, once) to every forwarded event.
+    addMigrationRunner(target) {
+        new events.Rule(this, 'MigrationRunnerRule', {
+            ruleName: `${this.busName}-migration-runner`,
+            description: 'Starts the migration orchestrator from source-archive events forwarded to the bus',
+            eventBus: this.bus,
+            eventPattern: { source: events.Match.exists() },
+            targets: [new eventsTargets.LambdaFunction(target)],
+        });
+    }
+    configureVendedLogDelivery(busName) {
+        const stack = cdk.Stack.of(this);
+        const { account, region, partition } = stack;
+        const deliveryPolicy = new logs.CfnResourcePolicy(this, 'LogDeliveryResourcePolicy', {
+            policyName: `${busName}-log-delivery`,
+            policyDocument: stack.toJsonString({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'AWSLogDeliveryWrite',
+                        Effect: 'Allow',
+                        Principal: { Service: 'delivery.logs.amazonaws.com' },
+                        Action: ['logs:CreateLogStream', 'logs:PutLogEvents'],
+                        Resource: `${this.vendedLogGroup.logGroupArn}:log-stream:*`,
+                        Condition: {
+                            StringEquals: { 'aws:SourceAccount': account },
+                            ArnLike: { 'aws:SourceArn': `arn:${partition}:logs:${region}:${account}:delivery-source:*` },
+                        },
+                    },
+                ],
+            }),
+        });
+        const destination = new logs.CfnDeliveryDestination(this, 'LogDeliveryDestination', {
+            name: `${busName}-logs`,
+            destinationResourceArn: this.vendedLogGroup.logGroupArn,
+        });
+        const logTypes = [
+            { logType: 'INFO_LOGS', id: 'Info', suffix: 'info' },
+            { logType: 'ERROR_LOGS', id: 'Error', suffix: 'error' },
+            { logType: 'TRACE_LOGS', id: 'Trace', suffix: 'trace' },
+        ];
+        let previousDelivery;
+        for (const { logType, id, suffix } of logTypes) {
+            const source = new logs.CfnDeliverySource(this, `DeliverySource${id}`, {
+                name: `${busName}-${suffix}`,
+                logType,
+                resourceArn: this.bus.eventBusArn,
+            });
+            const delivery = new logs.CfnDelivery(this, `Delivery${id}`, {
+                deliverySourceName: source.name,
+                deliveryDestinationArn: destination.attrArn,
+            });
+            delivery.addDependency(deliveryPolicy);
+            delivery.addDependency(source);
+            if (previousDelivery) {
+                delivery.addDependency(previousDelivery);
+            }
+            previousDelivery = delivery;
+        }
+    }
+}
+exports.LegacyS3BackupsBus = LegacyS3BackupsBus;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"legacy-s3-backups-bus.js","sourceRoot":"","sources":["../../constructs/legacy-s3-backups-bus.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as eventsTargets from 'aws-cdk-lib/aws-events-targets';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\n\nexport interface LegacyS3BackupsBusProps {\n  readonly busName: string;\n  readonly allowedAccountIds: string[];\n}\n\n// One migration trigger: a source-archive prefix plus the orchestrator input\n// options it maps to. The migration runner applies this list to every event\n// the bus forwards.\nexport interface MigrationTrigger {\n  readonly name: string;\n  readonly prefix: string;\n  readonly options: Record<string, unknown>;\n  readonly once?: boolean;\n}\n\nexport class LegacyS3BackupsBus extends Construct {\n  public readonly bus: events.EventBus;\n  public readonly ruleLogGroup: logs.LogGroup;\n  public readonly vendedLogGroup: logs.LogGroup;\n\n  private readonly busName: string;\n\n  constructor(scope: Construct, id: string, props: LegacyS3BackupsBusProps) {\n    super(scope, id);\n\n    this.busName = props.busName;\n\n    this.ruleLogGroup = new logs.LogGroup(this, 'RuleLogGroup', {\n      logGroupName: props.busName,\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    this.vendedLogGroup = new logs.LogGroup(this, 'VendedLogGroup', {\n      logGroupName: `/aws/vendedlogs/events/event-bus/${props.busName}`,\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    this.bus = new events.EventBus(this, 'EventBus', {\n      eventBusName: props.busName,\n      logConfig: {\n        level: events.Level.TRACE,\n        includeDetail: events.IncludeDetail.FULL,\n      },\n    });\n\n    this.bus.addToResourcePolicy(\n      new iam.PolicyStatement({\n        sid: 'AllowMainAccountPutEvents',\n        effect: iam.Effect.ALLOW,\n        principals: props.allowedAccountIds.map((accountId) => new iam.AccountPrincipal(accountId)),\n        actions: ['events:PutEvents'],\n        resources: [this.bus.eventBusArn],\n      })\n    );\n\n    new events.Rule(this, 'LogAllEventsRule', {\n      ruleName: `${props.busName}-log-all-events`,\n      description: `Logs every event published to the ${props.busName} event bus to the ${props.busName} CloudWatch log group`,\n      eventBus: this.bus,\n      eventPattern: { source: events.Match.exists() },\n      targets: [new eventsTargets.CloudWatchLogGroup(this.ruleLogGroup)],\n    });\n\n    this.configureVendedLogDelivery(props.busName);\n  }\n\n  // Catch-all: the bus policy already restricts senders to the allowed\n  // accounts, and the migration runner applies the MIGRATION_TRIGGERS policy\n  // (bucket, archive suffix, size, prefix, once) to every forwarded event.\n  public addMigrationRunner(target: lambda.IFunction): void {\n    new events.Rule(this, 'MigrationRunnerRule', {\n      ruleName: `${this.busName}-migration-runner`,\n      description: 'Starts the migration orchestrator from source-archive events forwarded to the bus',\n      eventBus: this.bus,\n      eventPattern: { source: events.Match.exists() },\n      targets: [new eventsTargets.LambdaFunction(target)],\n    });\n  }\n\n  private configureVendedLogDelivery(busName: string): void {\n    const stack = cdk.Stack.of(this);\n    const { account, region, partition } = stack;\n\n    const deliveryPolicy = new logs.CfnResourcePolicy(this, 'LogDeliveryResourcePolicy', {\n      policyName: `${busName}-log-delivery`,\n      policyDocument: stack.toJsonString({\n        Version: '2012-10-17',\n        Statement: [\n          {\n            Sid: 'AWSLogDeliveryWrite',\n            Effect: 'Allow',\n            Principal: { Service: 'delivery.logs.amazonaws.com' },\n            Action: ['logs:CreateLogStream', 'logs:PutLogEvents'],\n            Resource: `${this.vendedLogGroup.logGroupArn}:log-stream:*`,\n            Condition: {\n              StringEquals: { 'aws:SourceAccount': account },\n              ArnLike: { 'aws:SourceArn': `arn:${partition}:logs:${region}:${account}:delivery-source:*` },\n            },\n          },\n        ],\n      }),\n    });\n\n    const destination = new logs.CfnDeliveryDestination(this, 'LogDeliveryDestination', {\n      name: `${busName}-logs`,\n      destinationResourceArn: this.vendedLogGroup.logGroupArn,\n    });\n\n    const logTypes = [\n      { logType: 'INFO_LOGS', id: 'Info', suffix: 'info' },\n      { logType: 'ERROR_LOGS', id: 'Error', suffix: 'error' },\n      { logType: 'TRACE_LOGS', id: 'Trace', suffix: 'trace' },\n    ];\n\n    let previousDelivery: logs.CfnDelivery | undefined;\n\n    for (const { logType, id, suffix } of logTypes) {\n      const source = new logs.CfnDeliverySource(this, `DeliverySource${id}`, {\n        name: `${busName}-${suffix}`,\n        logType,\n        resourceArn: this.bus.eventBusArn,\n      });\n\n      const delivery = new logs.CfnDelivery(this, `Delivery${id}`, {\n        deliverySourceName: source.name,\n        deliveryDestinationArn: destination.attrArn,\n      });\n\n      delivery.addDependency(deliveryPolicy);\n      delivery.addDependency(source);\n      if (previousDelivery) {\n        delivery.addDependency(previousDelivery);\n      }\n      previousDelivery = delivery;\n    }\n  }\n}\n"]}

package/dist/constructs/migration-scripts-runner.d.ts

@@ -5,6 +5,7 @@ import { Construct } from 'constructs';
 export interface MigrationScriptsRunnerProps {
     vpc: ec2.IVpc;
     artifactsBucket: s3.IBucket;
+    migrationRepoPath?: string;
     backupPrefix?: string;
     cpu?: number;
     memoryLimitMiB?: number;

package/dist/constructs/migration-scripts-runner.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MigrationScriptsRunner = void 0;
 const cdk = require("aws-cdk-lib");
 const ec2 = require("aws-cdk-lib/aws-ec2");
+const ecrAssets = require("aws-cdk-lib/aws-ecr-assets");
 const ecs = require("aws-cdk-lib/aws-ecs");
 const logs = require("aws-cdk-lib/aws-logs");
 const path = require("path");
@@ -37,7 +38,13 @@ class MigrationScriptsRunner extends constructs_1.Construct {
         const { environment, secrets } = (0, migration_1.getEcsEnvs)(cdk.Stack.of(this));
         this.container = this.taskDefinition.addContainer('scripts', {
             containerName: 'scripts',
-            image: ecs.ContainerImage.fromAsset(path.resolve('../../migration'), { file: 'Dockerfile' }),
+            // The task definition runs X86_64 Fargate; pin the image platform so a
+            // build from an arm64 host (e.g. a Mac) does not produce a mismatched
+            // image (exec format error on the entrypoint).
+            image: ecs.ContainerImage.fromAsset(props.migrationRepoPath ?? path.resolve('../../migration'), {
+                file: 'Dockerfile',
+                platform: ecrAssets.Platform.LINUX_AMD64,
+            }),
             environment,
             secrets,
             logging: ecs.LogDrivers.awsLogs({
@@ -49,4 +56,4 @@ class MigrationScriptsRunner extends constructs_1.Construct {
     }
 }
 exports.MigrationScriptsRunner = MigrationScriptsRunner;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/constructs/migration-state-machine.d.ts

@@ -8,12 +8,14 @@ import { Construct } from 'constructs';
 export interface MigrationStateMachineProps {
     producer: lambda.IFunction;
     verifier: lambda.IFunction;
+    clearAffected: lambda.IFunction;
     queue: sqs.IQueue;
     cluster: ecs.ICluster;
     taskDefinition: ecs.TaskDefinition;
     container: ecs.ContainerDefinition;
     securityGroup: ec2.ISecurityGroup;
     artifactsBucket: s3.IBucket;
+    progressParameterName: string;
     maxInvocations?: number;
     drainMaxChecks?: number;
     loopWaitSeconds?: number;
@@ -23,17 +25,23 @@ export declare class MigrationStateMachine extends Construct {
     readonly stateMachine: sfn.StateMachine;
     private readonly producer;
     private readonly verifier;
+    private readonly clearAffected;
     private readonly queue;
     private readonly cluster;
     private readonly taskDefinition;
     private readonly container;
     private readonly securityGroup;
     private readonly artifactsBucket;
+    private readonly progressParameterName;
+    private readonly progressParameterArn;
     private readonly maxInvocations;
     private readonly drainMaxChecks;
     private readonly loopWaitSeconds;
     private readonly drainWaitSeconds;
     constructor(scope: Construct, id: string, props: MigrationStateMachineProps);
+    private previousStep;
+    private precomputeEnabled;
+    private markStep;
     private producerPass;
     private resourceStep;
     private ecsStep;