@spinnaker/ecs 2026.2.4 → 2026.3.1

package/dist/instance/details/EcsInstanceDetails.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import type { IAmazonHealth } from '@spinnaker/amazon';
+import type { Application, IInstanceDetailsProps, IMoniker, IRouterInjectedProps } from '@spinnaker/core';
+interface IEcsInstanceParams {
+    account?: string;
+    accountId?: string;
+    instanceId: string;
+    provider?: string;
+    region?: string;
+    [key: string]: any;
+}
+export interface IEcsInstanceDetailsProps extends Partial<IInstanceDetailsProps> {
+    accountId?: string;
+    app: Application;
+    environment?: string;
+    instance?: IEcsInstanceParams;
+    moniker?: IMoniker;
+    $stateParams?: IInstanceDetailsProps['$stateParams'] & Partial<IEcsInstanceParams>;
+}
+interface IEcsLoadedInstance {
+    [key: string]: any;
+    account?: string;
+    baseIpAddress?: string;
+    healthMetrics?: IAmazonHealth[];
+    instanceId?: string;
+    region?: string;
+}
+interface IEcsInstanceDetailsState {
+    instance?: IEcsLoadedInstance;
+    instanceIdNotFound?: string;
+    loading: boolean;
+}
+export declare class EcsInstanceDetailsComponent extends React.Component<IEcsInstanceDetailsProps & IRouterInjectedProps, IEcsInstanceDetailsState> {
+    state: IEcsInstanceDetailsState;
+    private activeRequestId;
+    private dataReady;
+    private isUnmounted;
+    private unsubscribeFromRefresh?;
+    componentDidMount(): void;
+    componentDidUpdate(previousProps: IEcsInstanceDetailsProps): void;
+    componentWillUnmount(): void;
+    private getInstanceParams;
+    private closeDetails;
+    private retrieveInstance;
+    render(): JSX.Element;
+}
+export declare const EcsInstanceDetails: React.ForwardRefExoticComponent<Omit<IEcsInstanceDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export {};

package/dist/loadBalancer/loadBalancer.transformer.d.ts

@@ -1,8 +1,4 @@
-import type { IQService } from 'angular';
 import type { IEcsLoadBalancer, IEcsLoadBalancerSourceData } from '../domain/IEcsLoadBalancer';
 export declare class EcsLoadBalancerTransformer {
-    private $q;
-    static $inject: string[];
-    constructor($q: IQService);
-    normalizeLoadBalancer(loadBalancer: IEcsLoadBalancerSourceData): PromiseLike<IEcsLoadBalancer>;
+    normalizeLoadBalancer(loadBalancer: IEcsLoadBalancerSourceData): Promise<IEcsLoadBalancer>;
 }

package/dist/loadBalancer/targetGroup.states.d.ts

@@ -1 +1,2 @@
-export declare const ECS_TARGET_GROUP_STATES = "spinnaker.ecs.loadBalancer.targetGroup.states";
+import type { INestedState } from '@spinnaker/core';
+export declare const ECS_TARGET_GROUP_DETAILS_STATE: INestedState;

package/dist/metricAlarm/metricAlarm.read.service.d.ts

@@ -1,5 +1,4 @@
 import type { IMetricAlarmDescriptor } from './MetricAlarm';
 export declare class MetricAlarmReader {
-    listMetricAlarms(): PromiseLike<IMetricAlarmDescriptor[]>;
+    listMetricAlarms(): Promise<IMetricAlarmDescriptor[]>;
 }
-export declare const METRIC_ALARM_READ_SERVICE = "spinnaker.ecs.metricAlarm.read.service";

package/dist/pipeline/stages/cloneServerGroup/ecsCloneServerGroupStage.d.ts

@@ -0,0 +1 @@
+export function registerEcsCloneServerGroupStage(): void;

package/dist/pipeline/stages/common/EcsServerGroupStepLabel.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface IEcsServerGroupStepLabelProps {
+    action: string;
+    step: any;
+    useSource?: boolean;
+}
+export declare function EcsServerGroupStepLabel({ action, step, useSource }: IEcsServerGroupStepLabelProps): JSX.Element;

package/dist/pipeline/stages/common/EcsStageConfigs.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { IStageConfigProps } from '@spinnaker/core';
+export declare function EcsDestroyAsgStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsDisableAsgStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsEnableAsgStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsDisableClusterStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsFindImageFromTagsStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsScaleDownClusterStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsShrinkClusterStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsCloneServerGroupStageConfig(props: IStageConfigProps): JSX.Element;
+export declare function EcsResizeAsgStageConfig(props: IStageConfigProps): JSX.Element;

package/dist/pipeline/stages/destroyAsg/ecsDestroyAsgStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_DESTROYASG_ECSDESTROYASGSTAGE: "spinnaker.ecs.pipeline.stage.ecs.destroyAsgStage";
-export const name: "spinnaker.ecs.pipeline.stage.ecs.destroyAsgStage";
+export function registerEcsDestroyServerGroupStage(): void;

package/dist/pipeline/stages/disableAsg/ecsDisableAsgStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_DISABLEASG_ECSDISABLEASGSTAGE: "spinnaker.ecs.pipeline.stage.disableAsgStage";
-export const name: "spinnaker.ecs.pipeline.stage.disableAsgStage";
+export function registerEcsDisableServerGroupStage(): void;

package/dist/pipeline/stages/disableCluster/ecsDisableClusterStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_DISABLECLUSTER_ECSDISABLECLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.disableClusterStage";
-export const name: "spinnaker.ecs.pipeline.stage.disableClusterStage";
+export function registerEcsDisableClusterStage(): void;

package/dist/pipeline/stages/enableAsg/ecsEnableAsgStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_ENABLEASG_ECSENABLEASGSTAGE: "spinnaker.ecs.pipeline.stage.enableAsgStage";
-export const name: "spinnaker.ecs.pipeline.stage.enableAsgStage";
+export function registerEcsEnableServerGroupStage(): void;

package/dist/pipeline/stages/findImageFromTags/EcsFindImageFromTagsExecutionDetails.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare function EcsFindImageFromTagsExecutionDetails(props: any): JSX.Element;
+export declare namespace EcsFindImageFromTagsExecutionDetails {
+    var title: string;
+}

package/dist/pipeline/stages/findImageFromTags/ecsFindImageFromTagStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_FINDIMAGEFROMTAGS_ECSFINDIMAGEFROMTAGSTAGE: "spinnaker.ecs.pipeline.stage.findImageFromTagsStage";
-export const name: "spinnaker.ecs.pipeline.stage.findImageFromTagsStage";
+export function registerEcsFindImageFromTagsStage(): void;

package/dist/pipeline/stages/resizeAsg/ecsResizeAsgStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_RESIZEASG_ECSRESIZEASGSTAGE: "spinnaker.ecs.pipeline.stage.ecs.resizeAsgStage";
-export const name: "spinnaker.ecs.pipeline.stage.ecs.resizeAsgStage";
+export function registerEcsResizeServerGroupStage(): void;

package/dist/pipeline/stages/scaleDownCluster/ecsScaleDownClusterStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_SCALEDOWNCLUSTER_ECSSCALEDOWNCLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.scaleDownClusterStage";
-export const name: "spinnaker.ecs.pipeline.stage.scaleDownClusterStage";
+export function registerEcsScaleDownClusterStage(): void;

package/dist/pipeline/stages/shrinkCluster/ecsShrinkClusterStage.d.ts

@@ -1,2 +1 @@
-export const ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.ecs.shrinkClusterStage";
-export const name: "spinnaker.ecs.pipeline.stage.ecs.shrinkClusterStage";
+export function registerEcsShrinkClusterStage(): void;

package/dist/placementStrategy/placementStrategy.service.d.ts

@@ -8,4 +8,3 @@ export declare class PlacementStrategyService {
     getBinPackCpuStrategy(): IPlacementStrategy[];
     getOneTaskPerHostStrategy(): IPlacementStrategy[];
 }
-export declare const PLACEMENT_STRATEGY_SERVICE = "spinnaker.ecs.placementStrategyService.service";

package/dist/secrets/secret.read.service.d.ts

@@ -1,5 +1,4 @@
 import type { ISecretDescriptor } from './ISecret';
 export declare class SecretReader {
-    listSecrets(): PromiseLike<ISecretDescriptor[]>;
+    listSecrets(): Promise<ISecretDescriptor[]>;
 }
-export declare const ECS_SECRET_READ_SERVICE = "spinnaker.ecs.secret.read.service";

package/dist/securityGroup/details/EcsSecurityGroupDetails.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { VpcReader } from '@spinnaker/amazon';
+import type { Application, IRouterInjectedProps, ISecurityGroup, ISecurityGroupDetail, SecurityGroupReader } from '@spinnaker/core';
+import { DeckRuntimeContext } from '@spinnaker/core';
+interface IEcsResolvedSecurityGroup {
+    accountId: string;
+    name: string;
+    provider?: string;
+    region: string;
+    vpcId?: string;
+}
+interface IEcsSecurityGroupDetailsProps {
+    app: Application;
+    autoClose?: () => void;
+    resolvedSecurityGroup: IEcsResolvedSecurityGroup;
+    securityGroupReader?: SecurityGroupReader;
+    vpcReader?: Pick<typeof VpcReader, 'getVpcName'>;
+}
+interface IEcsSecurityGroupDetailsState {
+    loading: boolean;
+    notFound?: boolean;
+    securityGroup?: ISecurityGroupDetail & ISecurityGroup & Record<string, any>;
+}
+export declare class EcsSecurityGroupDetailsComponent extends React.Component<IEcsSecurityGroupDetailsProps & IRouterInjectedProps, IEcsSecurityGroupDetailsState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    state: IEcsSecurityGroupDetailsState;
+    private isUnmounted;
+    private loadRequestId;
+    private unsubscribeFromRefresh;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: IEcsSecurityGroupDetailsProps): void;
+    componentWillUnmount(): void;
+    private getCoordinatesKey;
+    private getSecurityGroupReader;
+    private getVpcReader;
+    private showNotFound;
+    private loadSecurityGroup;
+    private closeDetails;
+    render(): JSX.Element;
+}
+export declare const EcsSecurityGroupDetails: React.ForwardRefExoticComponent<Omit<IEcsSecurityGroupDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export {};

package/dist/securityGroup/securityGroup.reader.d.ts

@@ -2,4 +2,3 @@ import type { ISecurityGroup, ISecurityGroupsByAccount } from '@spinnaker/core';
 export declare class EcsSecurityGroupReader {
     resolveIndexedSecurityGroup(indexedSecurityGroups: ISecurityGroupsByAccount, container: ISecurityGroup, securityGroupId: string): ISecurityGroup;
 }
-export declare const ECS_SECURITY_GROUP_READER = "spinnaker.ecs.securityGroup.reader";

package/dist/securityGroup/securityGroup.transformer.d.ts

@@ -1,2 +1,3 @@
-export const ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER: "spinnaker.ecs.securityGroup.transformer";
-export const name: "spinnaker.ecs.securityGroup.transformer";
+export class EcsSecurityGroupTransformer {
+    normalizeSecurityGroup(securityGroup: any): Promise<any>;
+}

package/dist/serverGroup/configure/dockerImage.util.d.ts

@@ -0,0 +1,3 @@
+import type { IEcsDockerImage } from './serverGroupConfiguration.service';
+export declare function buildEcsImageId(image: any): string;
+export declare function normalizeEcsDockerImage(image: any): IEcsDockerImage;

package/dist/serverGroup/configure/serverGroupCommandBuilder.service.d.ts

@@ -1,2 +1,111 @@
-export const ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE: "spinnaker.ecs.serverGroupCommandBuilder.service";
-export const name: "spinnaker.ecs.serverGroupCommandBuilder.service";
+export class EcsServerGroupCommandBuilder {
+    configurationService: EcsServerGroupConfigurationService;
+    buildNewServerGroupCommand(application: any, defaults: any): Promise<{
+        application: any;
+        credentials: any;
+        region: any;
+        strategy: string;
+        capacity: {
+            min: number;
+            max: number;
+            desired: number;
+        };
+        launchType: string;
+        healthCheckType: string;
+        selectedProvider: string;
+        iamRole: string;
+        dockerImageCredentialsSecret: string;
+        availabilityZones: string[];
+        subnetType: string;
+        securityGroupNames: any[];
+        healthCheckGracePeriodSeconds: string;
+        placementConstraints: any[];
+        placementStrategyName: string;
+        taskDefinitionArtifact: {};
+        useTaskDefinitionArtifact: boolean;
+        placementStrategySequence: any[];
+        serviceDiscoveryAssociations: any[];
+        ecsClusterName: string;
+        targetGroup: string;
+        copySourceScalingPoliciesAndActions: boolean;
+        preferSourceCapacity: boolean;
+        useSourceCapacity: boolean;
+        enableDeploymentCircuitBreaker: boolean;
+        viewState: {
+            useAllImageSelection: boolean;
+            useSimpleCapacity: boolean;
+            usePreferredZones: boolean;
+            mode: any;
+            disableStrategySelection: boolean;
+            dirty: {};
+        };
+    }>;
+    buildServerGroupCommandFromExisting(application: any, serverGroup: any, mode: any): Promise<{
+        application: any;
+        credentials: any;
+        region: any;
+        strategy: string;
+        capacity: {
+            min: number;
+            max: number;
+            desired: number;
+        };
+        launchType: string;
+        healthCheckType: string;
+        selectedProvider: string;
+        iamRole: string;
+        dockerImageCredentialsSecret: string;
+        availabilityZones: string[];
+        subnetType: string;
+        securityGroupNames: any[];
+        healthCheckGracePeriodSeconds: string;
+        placementConstraints: any[];
+        placementStrategyName: string;
+        taskDefinitionArtifact: {};
+        useTaskDefinitionArtifact: boolean;
+        placementStrategySequence: any[];
+        serviceDiscoveryAssociations: any[];
+        ecsClusterName: string;
+        targetGroup: string;
+        copySourceScalingPoliciesAndActions: boolean;
+        preferSourceCapacity: boolean;
+        useSourceCapacity: boolean;
+        enableDeploymentCircuitBreaker: boolean;
+        viewState: {
+            useAllImageSelection: boolean;
+            useSimpleCapacity: boolean;
+            usePreferredZones: boolean;
+            mode: any;
+            disableStrategySelection: boolean;
+            dirty: {};
+        };
+    }>;
+    buildNewServerGroupCommandForPipeline(current: any, pipeline: any): Promise<{
+        viewState: {
+            requiresTemplateSelection: boolean;
+            overrides: {
+                viewState: {
+                    mode: string;
+                    contextImages: {
+                        fromContext: boolean;
+                        imageLabelOrSha: any;
+                        stageId: any;
+                    }[];
+                    pipeline: any;
+                    currentStage: any;
+                };
+            };
+        };
+    }>;
+    buildServerGroupCommandFromPipeline(application: any, originalCluster: any, current: any, pipeline: any): Promise<any>;
+    buildUpdateServerGroupCommand(serverGroup: any): {
+        type: string;
+        asgs: {
+            asgName: any;
+            region: any;
+        }[];
+        healthCheckType: any;
+        credentials: any;
+    };
+}
+import { EcsServerGroupConfigurationService } from './serverGroupConfiguration.service';

package/dist/serverGroup/configure/serverGroupConfiguration.service.d.ts

@@ -1,27 +1,20 @@
-import type { IQService } from 'angular';
-import type { IArtifact, IPipeline, IServerGroupCommand, IServerGroupCommandBackingData, IServerGroupCommandBackingDataFiltered, IServerGroupCommandDirty, IServerGroupCommandResult, IServerGroupCommandViewState, IStage, ISubnet, LoadBalancerReader, SecurityGroupReader, ServerGroupCommandRegistry } from '@spinnaker/core';
+import type { IArtifact, IPipeline, IServerGroupCommandResult, IStage } from '@spinnaker/core';
 import type { IDockerImage } from '@spinnaker/docker';
 import type { IEcsCapacityProviderDetails } from '../../ecsCluster/IEcsCapacityProviderDetails';
 import type { IEcsClusterDescriptor } from '../../ecsCluster/IEcsCluster';
-import type { EcsClusterReader } from '../../ecsCluster/ecsCluster.read.service';
 import type { IRoleDescriptor } from '../../iamRoles/IRole';
-import type { IamRoleReader } from '../../iamRoles/iamRole.read.service';
 import type { IMetricAlarmDescriptor } from '../../metricAlarm/MetricAlarm';
-import type { MetricAlarmReader } from '../../metricAlarm/metricAlarm.read.service';
 import type { IPlacementStrategy } from '../../placementStrategy/IPlacementStrategy';
-import type { PlacementStrategyService } from '../../placementStrategy/placementStrategy.service';
 import type { ISecretDescriptor } from '../../secrets/ISecret';
-import type { SecretReader } from '../../secrets/secret.read.service';
 import type { IServiceDiscoveryRegistryDescriptor } from '../../serviceDiscovery/IServiceDiscovery';
-export interface IEcsServerGroupCommandDirty extends IServerGroupCommandDirty {
-    targetGroups?: string[];
-    defaulCapacityProviders?: string[];
-    customCapacityProviders?: string[];
+export interface IEcsServerGroupCommandDirty {
+    [key: string]: any;
 }
 export interface IEcsServerGroupCommandResult extends IServerGroupCommandResult {
     dirty: IEcsServerGroupCommandDirty;
 }
 export interface IEcsDockerImage extends IDockerImage {
+    [key: string]: any;
     imageId: string;
     message: string;
     fromTrigger: boolean;
@@ -29,26 +22,29 @@ export interface IEcsDockerImage extends IDockerImage {
     stageId: string;
     imageLabelOrSha: string;
 }
-export interface IEcsServerGroupCommandViewState extends IServerGroupCommandViewState {
+export interface IEcsServerGroupCommandViewState {
+    [key: string]: any;
     contextImages: IEcsDockerImage[];
     pipeline: IPipeline;
     currentStage: IStage;
     dirty: IEcsServerGroupCommandDirty;
 }
-export interface IEcsServerGroupCommandBackingDataFiltered extends IServerGroupCommandBackingDataFiltered {
+export interface IEcsServerGroupCommandBackingDataFiltered {
+    [key: string]: any;
     targetGroups: string[];
     iamRoles: string[];
     ecsClusters: string[];
     availableCapacityProviders: string[];
     defaultCapacityProviderStrategy: IEcsCapacityProviderStrategyItem[];
     metricAlarms: IMetricAlarmDescriptor[];
-    subnetTypes: ISubnet[];
+    subnetTypes: any[];
     securityGroupNames: string[];
     secrets: string[];
     serviceDiscoveryRegistries: IServiceDiscoveryRegistryDescriptor[];
     images: IEcsDockerImage[];
 }
-export interface IEcsServerGroupCommandBackingData extends IServerGroupCommandBackingData {
+export interface IEcsServerGroupCommandBackingData {
+    [key: string]: any;
     filtered: IEcsServerGroupCommandBackingDataFiltered;
     targetGroups: string[];
     ecsClusters: IEcsClusterDescriptor[];
@@ -84,7 +80,8 @@ export interface IEcsCapacityProviderStrategyItem {
     base: number;
     weight: number;
 }
-export interface IEcsServerGroupCommand extends IServerGroupCommand {
+export interface IEcsServerGroupCommand {
+    [key: string]: any;
     associatePublicIpAddress: boolean;
     backingData: IEcsServerGroupCommandBackingData;
     computeUnits: number;
@@ -112,54 +109,7 @@ export interface IEcsServerGroupCommand extends IServerGroupCommand {
     capacityProviderStrategy: IEcsCapacityProviderStrategyItem[];
     useDefaultCapacityProviders: boolean;
     ecsClusterName: string;
-    subnetTypeChanged: (command: IEcsServerGroupCommand) => IServerGroupCommandResult;
-    placementStrategyNameChanged: (command: IEcsServerGroupCommand) => IServerGroupCommandResult;
-    regionIsDeprecated: (command: IEcsServerGroupCommand) => boolean;
-    clusterChanged: (command: IServerGroupCommand) => void;
 }
 export declare class EcsServerGroupConfigurationService {
-    private $q;
-    private loadBalancerReader;
-    private serverGroupCommandRegistry;
-    private iamRoleReader;
-    private ecsClusterReader;
-    private metricAlarmReader;
-    private placementStrategyService;
-    private securityGroupReader;
-    private secretReader;
-    private launchTypes;
-    private networkModes;
-    static $inject: string[];
-    constructor($q: IQService, loadBalancerReader: LoadBalancerReader, serverGroupCommandRegistry: ServerGroupCommandRegistry, iamRoleReader: IamRoleReader, ecsClusterReader: EcsClusterReader, metricAlarmReader: MetricAlarmReader, placementStrategyService: PlacementStrategyService, securityGroupReader: SecurityGroupReader, secretReader: SecretReader);
     configureUpdateCommand(command: IEcsServerGroupCommand): void;
-    configureCommand(cmd: IEcsServerGroupCommand, imageQuery?: string): PromiseLike<void>;
-    setCapacityProviderDetails(command: IEcsServerGroupCommand): void;
-    configureAvailableCapacityProviders(command: IEcsServerGroupCommand): void;
-    mapCapacityProviderDetails(describeClusters: IEcsCapacityProviderDetails): IEcsCapacityProviderDetails;
-    applyOverrides(phase: string, command: IEcsServerGroupCommand): void;
-    grabImageAndTag(imageId: string): string;
-    buildImageId(image: IEcsDockerImage): string;
-    mapImage(image: IEcsDockerImage): IEcsDockerImage;
-    configureAvailableImages(command: IEcsServerGroupCommand): void;
-    configureAvailabilityZones(command: IEcsServerGroupCommand): void;
-    configureAvailableSecurityGroups(command: IEcsServerGroupCommand): void;
-    configureAvailableSubnetTypes(command: IEcsServerGroupCommand): void;
-    configureAvailableEcsClusters(command: IEcsServerGroupCommand): void;
-    configureAvailableSecrets(command: IEcsServerGroupCommand): void;
-    buildServiceRegistryDisplayName(registry: IServiceDiscoveryRegistryDescriptor): string;
-    mapServiceRegistry(registry: IServiceDiscoveryRegistryDescriptor): IServiceDiscoveryRegistryDescriptor;
-    configureAvailableServiceDiscoveryRegistries(command: IEcsServerGroupCommand): void;
-    configureAvailableRegions(command: IEcsServerGroupCommand): void;
-    configureAvailableIamRoles(command: IEcsServerGroupCommand): void;
-    configureSubnetPurposes(command: IEcsServerGroupCommand): IServerGroupCommandResult;
-    private getLoadBalancerMap;
-    getLoadBalancerNames(command: IEcsServerGroupCommand): string[];
-    getVpcLoadBalancerNames(command: IEcsServerGroupCommand): string[];
-    getTargetGroupNames(command: IEcsServerGroupCommand): string[];
-    configureLoadBalancerOptions(command: IEcsServerGroupCommand): IServerGroupCommandResult;
-    refreshLoadBalancers(command: IEcsServerGroupCommand, skipCommandReconfiguration?: boolean): PromiseLike<void>;
-    configureVpcId(command: IEcsServerGroupCommand): IEcsServerGroupCommandResult;
-    checkDirtyCapacityProviders(command: IEcsServerGroupCommand): void;
-    attachEventHandlers(cmd: IEcsServerGroupCommand): void;
 }
-export declare const ECS_SERVER_GROUP_CONFIGURATION_SERVICE = "spinnaker.ecs.serverGroup.configure.service";

package/dist/serverGroup/configure/wizard/EcsCloneServerGroupModal.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import type { Application, DeckRuntimeServices, IModalComponentProps, IRouterInjectedProps } from '@spinnaker/core';
+import { DeckRuntimeContext, TaskMonitor } from '@spinnaker/core';
+import type { IEcsServerGroupCommand } from '../serverGroupConfiguration.service';
+export interface IEcsCloneServerGroupModalProps extends IModalComponentProps {
+    title: string;
+    application: Application;
+    command: IEcsServerGroupCommand;
+}
+interface IEcsCloneServerGroupModalState {
+    command: IEcsServerGroupCommand;
+    loaded: boolean;
+    requiresTemplateSelection: boolean;
+    taskMonitor: TaskMonitor;
+}
+export declare class EcsCloneServerGroupModalComponent extends React.Component<IEcsCloneServerGroupModalProps & IRouterInjectedProps, IEcsCloneServerGroupModalState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    private command;
+    private configureRequest;
+    private formik;
+    private unmounted;
+    private applicationRefreshUnsubscribe?;
+    static defaultProps: Partial<IEcsCloneServerGroupModalProps>;
+    private ecsClusterReader;
+    private iamRoleReader;
+    private metricAlarmReader;
+    private placementStrategyService;
+    private secretReader;
+    static show(props: IEcsCloneServerGroupModalProps, runtimeServices: DeckRuntimeServices): Promise<IEcsServerGroupCommand>;
+    constructor(props: IEcsCloneServerGroupModalProps & IRouterInjectedProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private onTaskComplete;
+    private onApplicationRefresh;
+    private clearApplicationRefreshSubscription;
+    private templateSelected;
+    private configureCommand;
+    private safe;
+    private loadBackingData;
+    private ensureCommandShape;
+    private attachEventHandlers;
+    private reconcileLocation;
+    private normalizeImages;
+    private getSubnetTypes;
+    private getClusterNames;
+    private getIamRoles;
+    private getSecrets;
+    private getServiceDiscoveryRegistries;
+    private getSecurityGroupNames;
+    private getTargetGroups;
+    private getAvailableCapacityProviders;
+    private getDefaultCapacityProviderStrategy;
+    private syncCommand;
+    private updateCommand;
+    private submit;
+    render(): JSX.Element;
+}
+export declare const EcsCloneServerGroupModal: React.ForwardRefExoticComponent<Omit<IEcsCloneServerGroupModalProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof EcsCloneServerGroupModalComponent.show;
+};
+export {};

package/dist/serverGroup/configure/wizard/capacityProvider/CapacityProvider.d.ts

@@ -1,7 +1,32 @@
-import type { IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
+import React from 'react';
+import type { IEcsCapacityProviderStrategyItem, IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
 export interface IEcsCapacityProviderProps {
     command: IEcsServerGroupCommand;
-    notifyAngular: (key: string, value: any) => void;
-    configureCommand: (query: string) => PromiseLike<void>;
+    onFieldChange: (key: string, value: any) => void;
+    configureCommand: (query: string) => Promise<void>;
 }
-export declare const ECS_CAPACITY_PROVIDER_REACT = "spinnaker.ecs.serverGroup.configure.wizard.capacityProvider.react";
+interface IEcsCapacityProviderState {
+    capacityProviderStrategy: IEcsCapacityProviderStrategyItem[];
+    defaultCapacityProviderStrategy: IEcsCapacityProviderStrategyItem[];
+    availableCapacityProviders: string[];
+    ecsClusterName: string;
+    useDefaultCapacityProviders: boolean;
+    capacityProviderLoadedFlag: boolean;
+    activeCapacityProviderIndex: number | null;
+}
+export declare class EcsCapacityProvider extends React.Component<IEcsCapacityProviderProps, IEcsCapacityProviderState> {
+    constructor(props: IEcsCapacityProviderProps);
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    private getAvailableCapacityProviders;
+    private getDefaultCapacityProviderStrategy;
+    private getCapacityProviderStrategy;
+    private addCapacityProviderStrategy;
+    private removeCapacityProviderStrategy;
+    private updateCapacityProviderName;
+    private updateCapacityProviderBase;
+    private updateCapacityProviderWeight;
+    private updateCapacityProviderType;
+    render(): React.ReactElement<EcsCapacityProvider>;
+}
+export {};

package/dist/serverGroup/configure/wizard/container/Container.d.ts

@@ -3,8 +3,8 @@ import type { IAccountDetails } from '@spinnaker/core';
 import type { IEcsDockerImage, IEcsServerGroupCommand, IEcsTargetGroupMapping } from '../../serverGroupConfiguration.service';
 export interface IContainerProps {
     command: IEcsServerGroupCommand;
-    notifyAngular: (key: string, value: any) => void;
-    configureCommand: (query: string) => PromiseLike<void>;
+    onFieldChange: (key: string, value: any) => void;
+    configureCommand: (query: string) => Promise<void>;
 }
 interface IContainerState {
     imageDescription: IEcsDockerImage;
@@ -19,6 +19,7 @@ interface IContainerState {
 export declare class Container extends React.Component<IContainerProps, IContainerState> {
     constructor(props: IContainerProps);
     componentDidMount(): void;
+    componentDidUpdate(): void;
     private getIdToImageMap;
     private getEmptyImageDescription;
     private updateDockerRegistryAccount;
@@ -32,5 +33,4 @@ export declare class Container extends React.Component<IContainerProps, IContain
     private updateDirtyTargetGroups;
     render(): React.ReactElement<Container>;
 }
-export declare const CONTAINER_REACT = "spinnaker.ecs.serverGroup.configure.wizard.container.react";
 export {};

package/dist/serverGroup/configure/wizard/networking/Networking.d.ts

@@ -3,8 +3,8 @@ import type { ISubnet } from '@spinnaker/core';
 import type { IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
 export interface IEcsNetworkingProps {
     command: IEcsServerGroupCommand;
-    notifyAngular: (key: string, value: any) => void;
-    configureCommand: (query: string) => PromiseLike<void>;
+    onFieldChange: (key: string, value: any) => void;
+    configureCommand: (query: string) => Promise<void>;
 }
 interface IEcsNetworkingState {
     associatePublicIpAddress: boolean;
@@ -18,11 +18,11 @@ interface IEcsNetworkingState {
 export declare class EcsNetworking extends React.Component<IEcsNetworkingProps, IEcsNetworkingState> {
     constructor(props: IEcsNetworkingProps);
     componentDidMount(): void;
+    componentDidUpdate(): void;
     private updateNetworkMode;
     private updateSecurityGroups;
     private updateSubnetTypes;
     private updateAssociatePublicIpAddress;
     render(): React.ReactElement<EcsNetworking>;
 }
-export declare const ECS_NETWORKING_REACT = "spinnaker.ecs.serverGroup.configure.wizard.networking.react";
 export {};

package/dist/serverGroup/configure/wizard/pages/AdvancedSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const AdvancedSettings: ({ command, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/BasicSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const BasicSettings: ({ application, command, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/ContainerSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const ContainerSettings: ({ command, configureCommand, onFieldChange }: IEcsWizardPageProps) => JSX.Element;

package/dist/serverGroup/configure/wizard/pages/HorizontalScalingSettings.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IEcsWizardPageProps } from './common';
+export declare const HorizontalScalingSettings: ({ command, configureCommand, onFieldChange }: IEcsWizardPageProps) => JSX.Element;