@spinnaker/ecs 0.0.0-main-2

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

@@ -0,0 +1,2 @@
+export const ECS_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER: "spinnaker.ecs.instance.details.controller";
+export const name: "spinnaker.ecs.instance.details.controller";

package/dist/loadBalancer/EcsLoadBalancerClusterContainer.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { ILoadBalancerClusterContainerProps } from '@spinnaker/core';
+export declare class EcsLoadBalancerClusterContainer extends React.Component<ILoadBalancerClusterContainerProps> {
+    shouldComponentUpdate(nextProps: ILoadBalancerClusterContainerProps): boolean;
+    render(): React.ReactElement<EcsLoadBalancerClusterContainer>;
+}

package/dist/loadBalancer/TargetGroup.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { IEcsLoadBalancer, IEcsTargetGroup } from '../domain/IEcsLoadBalancer';
+export interface IEcsTargetGroupProps {
+    loadBalancer: IEcsLoadBalancer;
+    targetGroup: IEcsTargetGroup;
+    showServerGroups: boolean;
+    showInstances: boolean;
+}
+export declare class EcsTargetGroup extends React.Component<IEcsTargetGroupProps> {
+    render(): React.ReactElement<EcsTargetGroup>;
+}

package/dist/loadBalancer/details/loadBalancerDetails.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { Application } from '@spinnaker/core';
+import type { IEcsLoadBalancer } from '../../domain/IEcsLoadBalancer';
+interface IEcsLoadBalancerFromStateParams {
+    accountId: string;
+    region: string;
+    name: string;
+    vpcId: string;
+}
+interface IEcsLoadBalancerDetailsState {
+    loadBalancer: IEcsLoadBalancer;
+    loadBalancerNotFound?: string;
+    loading: boolean;
+    refreshListenerUnsubscribe: () => void;
+}
+export interface IEcsLoadBalancerDetailsProps {
+    app: Application;
+    accountId: string;
+    loadBalancer: IEcsLoadBalancerFromStateParams;
+}
+export declare class EcsLoadBalancerDetails extends React.Component<IEcsLoadBalancerDetailsProps, IEcsLoadBalancerDetailsState> {
+    constructor(props: IEcsLoadBalancerDetailsProps);
+    componentWillUnmount(): void;
+    private extractLoadBalancer;
+    render(): React.ReactElement<EcsLoadBalancerDetails>;
+}
+export {};

package/dist/loadBalancer/details/targetGroupDetails.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { Application } from '@spinnaker/core';
+import type { IEcsLoadBalancer, IEcsTargetGroup } from '../../domain/IEcsLoadBalancer';
+interface IEcsTargetGroupFromStateParams {
+    loadBalancerName: string;
+    targetGroupName: string;
+    region: string;
+    vpcId: string;
+}
+interface IEcsTargetGroupDetailsState {
+    loadBalancer: IEcsLoadBalancer;
+    targetGroup: IEcsTargetGroup;
+    targetGroupNotFound?: string;
+    loading: boolean;
+    refreshListenerUnsubscribe: () => void;
+}
+export interface IEcsTargetGroupProps {
+    app: Application;
+    accountId: string;
+    name: string;
+    targetGroup: IEcsTargetGroupFromStateParams;
+    provider: string;
+}
+export declare class EcsTargetGroupDetails extends React.Component<IEcsTargetGroupProps, IEcsTargetGroupDetailsState> {
+    constructor(props: IEcsTargetGroupProps);
+    componentWillUnmount(): void;
+    private extractTargetGroup;
+    render(): React.ReactElement<EcsTargetGroupDetails>;
+}
+export {};

package/dist/loadBalancer/listener.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IEcsListener } from '../domain/IEcsLoadBalancer';
+export interface IEcsListenerProps {
+    listener: IEcsListener;
+}
+export declare class EcsListener extends React.Component<IEcsListenerProps> {
+    constructor(props: IEcsListenerProps);
+    private getTargetGroupNameFromArn;
+    render(): React.ReactElement<EcsListener>;
+}

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

@@ -0,0 +1,8 @@
+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>;
+}

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

@@ -0,0 +1 @@
+export declare const ECS_TARGET_GROUP_STATES = "spinnaker.ecs.loadBalancer.targetGroup.states";

package/dist/metricAlarm/MetricAlarm.d.ts

@@ -0,0 +1,6 @@
+export interface IMetricAlarmDescriptor {
+    accountName: string;
+    region: string;
+    alarmName: string;
+    alarmArn: string;
+}

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

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

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_DESTROYASG_ECSDESTROYASGSTAGE: "spinnaker.ecs.pipeline.stage.ecs.destroyAsgStage";
+export const name: "spinnaker.ecs.pipeline.stage.ecs.destroyAsgStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_DISABLEASG_ECSDISABLEASGSTAGE: "spinnaker.ecs.pipeline.stage.disableAsgStage";
+export const name: "spinnaker.ecs.pipeline.stage.disableAsgStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_DISABLECLUSTER_ECSDISABLECLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.disableClusterStage";
+export const name: "spinnaker.ecs.pipeline.stage.disableClusterStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_ENABLEASG_ECSENABLEASGSTAGE: "spinnaker.ecs.pipeline.stage.enableAsgStage";
+export const name: "spinnaker.ecs.pipeline.stage.enableAsgStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_FINDIMAGEFROMTAGS_ECSFINDIMAGEFROMTAGSTAGE: "spinnaker.ecs.pipeline.stage.findImageFromTagsStage";
+export const name: "spinnaker.ecs.pipeline.stage.findImageFromTagsStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_RESIZEASG_ECSRESIZEASGSTAGE: "spinnaker.ecs.pipeline.stage.ecs.resizeAsgStage";
+export const name: "spinnaker.ecs.pipeline.stage.ecs.resizeAsgStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_SCALEDOWNCLUSTER_ECSSCALEDOWNCLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.scaleDownClusterStage";
+export const name: "spinnaker.ecs.pipeline.stage.scaleDownClusterStage";

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

@@ -0,0 +1,2 @@
+export const ECS_PIPELINE_STAGES_SHRINKCLUSTER_ECSSHRINKCLUSTERSTAGE: "spinnaker.ecs.pipeline.stage.ecs.shrinkClusterStage";
+export const name: "spinnaker.ecs.pipeline.stage.ecs.shrinkClusterStage";

package/dist/placementStrategy/IPlacementStrategy.d.ts

@@ -0,0 +1,4 @@
+export interface IPlacementStrategy {
+    field: string;
+    type: string;
+}

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

@@ -0,0 +1,11 @@
+import type { IPlacementStrategy } from './IPlacementStrategy';
+export declare class PlacementStrategyService {
+    getPredefinedStrategy(strategyName: string): IPlacementStrategy[];
+    getAzBalancedSpreadStrategy(): IPlacementStrategy[];
+    getAzBalancedMemoryBinPackStrategy(): IPlacementStrategy[];
+    getBinPackMemoryStrategy(): IPlacementStrategy[];
+    getAzBalancedCpuBinPackStrategy(): IPlacementStrategy[];
+    getBinPackCpuStrategy(): IPlacementStrategy[];
+    getOneTaskPerHostStrategy(): IPlacementStrategy[];
+}
+export declare const PLACEMENT_STRATEGY_SERVICE = "spinnaker.ecs.placementStrategyService.service";

package/dist/secrets/ISecret.d.ts

@@ -0,0 +1,5 @@
+export interface ISecretDescriptor {
+    account: string;
+    region: string;
+    name: string;
+}

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

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

package/dist/securityGroup/details/securityGroupDetail.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER: "spinnaker.ecs.securityGroup.details.controller";
+export const name: "spinnaker.ecs.securityGroup.details.controller";

package/dist/securityGroup/securityGroup.module.d.ts

@@ -0,0 +1 @@
+export declare const ECS_SECURITY_GROUP_MODULE = "spinnaker.ecs.securityGroup";

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,2 @@
+export const ECS_SECURITYGROUP_SECURITYGROUP_TRANSFORMER: "spinnaker.ecs.securityGroup.transformer";
+export const name: "spinnaker.ecs.securityGroup.transformer";

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

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE: "spinnaker.ecs.serverGroupCommandBuilder.service";
+export const name: "spinnaker.ecs.serverGroupCommandBuilder.service";

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

@@ -0,0 +1,165 @@
+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 { 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 IEcsServerGroupCommandResult extends IServerGroupCommandResult {
+    dirty: IEcsServerGroupCommandDirty;
+}
+export interface IEcsDockerImage extends IDockerImage {
+    imageId: string;
+    message: string;
+    fromTrigger: boolean;
+    fromContext: boolean;
+    stageId: string;
+    imageLabelOrSha: string;
+}
+export interface IEcsServerGroupCommandViewState extends IServerGroupCommandViewState {
+    contextImages: IEcsDockerImage[];
+    pipeline: IPipeline;
+    currentStage: IStage;
+    dirty: IEcsServerGroupCommandDirty;
+}
+export interface IEcsServerGroupCommandBackingDataFiltered extends IServerGroupCommandBackingDataFiltered {
+    targetGroups: string[];
+    iamRoles: string[];
+    ecsClusters: string[];
+    availableCapacityProviders: string[];
+    defaultCapacityProviderStrategy: IEcsCapacityProviderStrategyItem[];
+    metricAlarms: IMetricAlarmDescriptor[];
+    subnetTypes: ISubnet[];
+    securityGroupNames: string[];
+    secrets: string[];
+    serviceDiscoveryRegistries: IServiceDiscoveryRegistryDescriptor[];
+    images: IEcsDockerImage[];
+}
+export interface IEcsServerGroupCommandBackingData extends IServerGroupCommandBackingData {
+    filtered: IEcsServerGroupCommandBackingDataFiltered;
+    targetGroups: string[];
+    ecsClusters: IEcsClusterDescriptor[];
+    capacityProviderDetails: IEcsCapacityProviderDetails[];
+    iamRoles: IRoleDescriptor[];
+    metricAlarms: IMetricAlarmDescriptor[];
+    launchTypes: string[];
+    networkModes: string[];
+    secrets: ISecretDescriptor[];
+    serviceDiscoveryRegistries: IServiceDiscoveryRegistryDescriptor[];
+    images: IEcsDockerImage[];
+}
+export interface IEcsTaskDefinitionArtifact {
+    artifact?: IArtifact;
+    artifactId?: string;
+}
+export interface IEcsContainerMapping {
+    containerName: string;
+    imageDescription: IEcsDockerImage;
+}
+export interface IEcsTargetGroupMapping {
+    containerName: string;
+    containerPort: number;
+    targetGroup: string;
+}
+export interface IEcsServiceDiscoveryRegistryAssociation {
+    registry: IServiceDiscoveryRegistryDescriptor;
+    containerPort: number;
+    containerName: string;
+}
+export interface IEcsCapacityProviderStrategyItem {
+    capacityProvider: string;
+    base: number;
+    weight: number;
+}
+export interface IEcsServerGroupCommand extends IServerGroupCommand {
+    associatePublicIpAddress: boolean;
+    backingData: IEcsServerGroupCommandBackingData;
+    computeUnits: number;
+    reservedMemory: number;
+    targetHealthyDeployPercentage: number;
+    targetGroup: string;
+    containerPort: number;
+    placementStrategyName: string;
+    placementStrategySequence: IPlacementStrategy[];
+    imageDescription: IEcsDockerImage;
+    networkMode: string;
+    subnetType: string;
+    subnetTypes: string[];
+    securityGroups: string[];
+    securityGroupNames: string[];
+    viewState: IEcsServerGroupCommandViewState;
+    taskDefinitionArtifact: IEcsTaskDefinitionArtifact;
+    taskDefinitionArtifactAccount: string;
+    containerMappings: IEcsContainerMapping[];
+    loadBalancedContainer: string;
+    targetGroupMappings: IEcsTargetGroupMapping[];
+    serviceDiscoveryAssociations: IEcsServiceDiscoveryRegistryAssociation[];
+    useTaskDefinitionArtifact: boolean;
+    evaluateTaskDefinitionArtifactExpressions: boolean;
+    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/CloneServerGroup.ecs.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_ECS_CONTROLLER: "spinnaker.ecs.cloneServerGroup.controller";
+export const name: "spinnaker.ecs.cloneServerGroup.controller";

package/dist/serverGroup/configure/wizard/advancedSettings/advancedSettings.component.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_CONFIGURE_WIZARD_ADVANCEDSETTINGS_ADVANCEDSETTINGS_COMPONENT: "spinnaker.ecs.serverGroup.configure.wizard.advancedSettings.component";
+export const name: "spinnaker.ecs.serverGroup.configure.wizard.advancedSettings.component";

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

@@ -0,0 +1,7 @@
+import type { IEcsServerGroupCommand } from '../../serverGroupConfiguration.service';
+export interface IEcsCapacityProviderProps {
+    command: IEcsServerGroupCommand;
+    notifyAngular: (key: string, value: any) => void;
+    configureCommand: (query: string) => PromiseLike<void>;
+}
+export declare const ECS_CAPACITY_PROVIDER_REACT = "spinnaker.ecs.serverGroup.configure.wizard.capacityProvider.react";

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

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import type { IEcsDockerImage, IEcsServerGroupCommand, IEcsTargetGroupMapping } from '../../serverGroupConfiguration.service';
+export interface IContainerProps {
+    command: IEcsServerGroupCommand;
+    notifyAngular: (key: string, value: any) => void;
+    configureCommand: (query: string) => PromiseLike<void>;
+}
+interface IContainerState {
+    imageDescription: IEcsDockerImage;
+    computeUnits: number;
+    reservedMemory: number;
+    dockerImages: IEcsDockerImage[];
+    targetGroupsAvailable: string[];
+    targetGroupMappings: IEcsTargetGroupMapping[];
+}
+export declare class Container extends React.Component<IContainerProps, IContainerState> {
+    constructor(props: IContainerProps);
+    componentDidMount(): void;
+    private getIdToImageMap;
+    private getEmptyImageDescription;
+    private pushTargetGroupMapping;
+    private updateContainerMappingImage;
+    private updateComputeUnits;
+    private updateReservedMemory;
+    private updateTargetGroupMappingTargetGroup;
+    private updateTargetGroupMappingPort;
+    private removeTargetGroupMapping;
+    private updateDirtyTargetGroups;
+    render(): React.ReactElement<Container>;
+}
+export declare const CONTAINER_REACT = "spinnaker.ecs.serverGroup.configure.wizard.container.react";
+export {};

package/dist/serverGroup/configure/wizard/horizontalScaling/horizontalScaling.component.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_CONFIGURE_WIZARD_HORIZONTALSCALING_HORIZONTALSCALING_COMPONENT: "spinnaker.ecs.serverGroup.configure.wizard.horizontalScaling.component";
+export const name: "spinnaker.ecs.serverGroup.configure.wizard.horizontalScaling.component";

package/dist/serverGroup/configure/wizard/location/ServerGroupBasicSettings.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_CONFIGURE_WIZARD_LOCATION_SERVERGROUPBASICSETTINGS_CONTROLLER: "spinnaker.ecs.serverGroup.configure.basicSettings";
+export const name: "spinnaker.ecs.serverGroup.configure.basicSettings";

package/dist/serverGroup/configure/wizard/logging/logging.component.d.ts

@@ -0,0 +1 @@
+export declare const ECS_SERVER_GROUP_LOGGING = "spinnaker.ecs.serverGroup.configure.wizard.logging.component";

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

@@ -0,0 +1,28 @@
+import * as React from 'react';
+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>;
+}
+interface IEcsNetworkingState {
+    associatePublicIpAddress: boolean;
+    networkMode: string;
+    networkModesAvailable: string[];
+    securityGroupNames: string[];
+    securityGroupsAvailable: string[];
+    subnetTypes: string[];
+    subnetTypesAvailable: ISubnet[];
+}
+export declare class EcsNetworking extends React.Component<IEcsNetworkingProps, IEcsNetworkingState> {
+    constructor(props: IEcsNetworkingProps);
+    componentDidMount(): 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/serviceDiscovery/ServiceDiscovery.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import type { IEcsServerGroupCommand, IEcsServiceDiscoveryRegistryAssociation } from '../../serverGroupConfiguration.service';
+export interface IServiceDiscoveryProps {
+    command: IEcsServerGroupCommand;
+    notifyAngular: (key: string, value: any) => void;
+    configureCommand: (query: string) => PromiseLike<void>;
+}
+export interface IEcsServiceDiscoveryRegistry {
+    account: string;
+    region: string;
+    name: string;
+    id: string;
+    arn: string;
+    displayName: string;
+}
+interface IServiceDiscoveryState {
+    serviceDiscoveryAssociations: IEcsServiceDiscoveryRegistryAssociation[];
+    serviceDiscoveryRegistriesAvailable: IEcsServiceDiscoveryRegistry[];
+    useTaskDefinitionArtifact: boolean;
+}
+export declare class ServiceDiscovery extends React.Component<IServiceDiscoveryProps, IServiceDiscoveryState> {
+    constructor(props: IServiceDiscoveryProps);
+    componentDidMount(): void;
+    private getNameToRegistryMap;
+    private getEmptyRegistry;
+    private updateServiceDiscoveryRegistry;
+    private updateServiceDiscoveryPort;
+    private updateServiceDiscoveryContainerName;
+    private pushServiceDiscoveryAssociation;
+    private removeServiceDiscoveryAssociations;
+    render(): React.ReactElement<ServiceDiscovery>;
+}
+export declare const SERVICE_DISCOVERY_REACT = "spinnaker.ecs.serverGroup.configure.wizard.serviceDiscovery.react";
+export {};

package/dist/serverGroup/configure/wizard/taskDefinition/TaskDefinition.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import type { IEcsContainerMapping, IEcsDockerImage, IEcsServerGroupCommand, IEcsTargetGroupMapping, IEcsTaskDefinitionArtifact } from '../../serverGroupConfiguration.service';
+export interface ITaskDefinitionProps {
+    command: IEcsServerGroupCommand;
+    notifyAngular: (key: string, value: any) => void;
+    configureCommand: (query: string) => PromiseLike<void>;
+}
+interface ITaskDefinitionState {
+    taskDefArtifact: IEcsTaskDefinitionArtifact;
+    taskDefArtifactAccount: string;
+    containerMappings: IEcsContainerMapping[];
+    targetGroupMappings: IEcsTargetGroupMapping[];
+    dockerImages: IEcsDockerImage[];
+    targetGroupsAvailable: string[];
+    loadBalancedContainer: string;
+    evaluateTaskDefinitionArtifactExpressions: boolean;
+}
+export declare class TaskDefinition extends React.Component<ITaskDefinitionProps, ITaskDefinitionState> {
+    constructor(props: ITaskDefinitionProps);
+    componentDidMount(): void;
+    private getIdToImageMap;
+    private getEmptyImageDescription;
+    private excludedArtifactTypePatterns;
+    private onExpectedArtifactSelected;
+    private onArtifactEdited;
+    private pushMapping;
+    private pushTargetGroupMapping;
+    private updateContainerMappingName;
+    private updateContainerMappingImage;
+    private updateTargetGroupMappingTargetGroup;
+    private updateTargetGroupMappingContainer;
+    private updateTargetGroupMappingPort;
+    private removeMapping;
+    private removeTargetGroupMapping;
+    private updateEvaluateTaskDefArtifactFlag;
+    render(): React.ReactElement<TaskDefinition>;
+}
+export declare const TASK_DEFINITION_REACT = "spinnaker.ecs.serverGroup.configure.wizard.taskDefinition.react";
+export {};

package/dist/serverGroup/details/resize/resizeCapacity.component.d.ts

@@ -0,0 +1 @@
+export declare const ECS_RESIZE_CAPACITY_COMPONENT = "spinnaker.ecs.serverGroup.resize";

package/dist/serverGroup/details/resize/resizeServerGroup.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_DETAILS_RESIZE_RESIZESERVERGROUP_CONTROLLER: "spinnaker.ecs.serverGroup.details.resize.controller";
+export const name: "spinnaker.ecs.serverGroup.details.resize.controller";

package/dist/serverGroup/details/rollback/rollbackServerGroup.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_DETAILS_ROLLBACK_ROLLBACKSERVERGROUP_CONTROLLER: "spinnaker.ecs.serverGroup.details.rollback.controller";
+export const name: "spinnaker.ecs.serverGroup.details.rollback.controller";

package/dist/serverGroup/details/serverGroupDetails.ecs.controller.d.ts

@@ -0,0 +1,2 @@
+export const ECS_SERVERGROUP_DETAILS_SERVERGROUPDETAILS_ECS_CONTROLLER: "spinnaker.ecs.serverGroup.details.controller";
+export const name: "spinnaker.ecs.serverGroup.details.controller";

package/dist/serverGroup/details/serverGroupDetails.module.d.ts

@@ -0,0 +1 @@
+export declare const SERVER_GROUP_DETAILS_MODULE = "spinnaker.ecs.serverGroup.details";

package/dist/serverGroup/events/EventsLink.d.ts

@@ -0,0 +1,4 @@
+import type { IServerGroup } from '@spinnaker/core';
+export interface IViewScalingActivitiesLinkProps {
+    serverGroup: IServerGroup;
+}

package/dist/serverGroup/events/events.component.d.ts

@@ -0,0 +1,3 @@
+import type { IComponentOptions } from 'angular';
+export declare const viewEventsLink: IComponentOptions;
+export declare const VIEW_EVENTS_LINK_COMPONENT = "spinnaker.ecs.serverGroup.details.viewEvents.link";

package/dist/serverGroup/events/events.controller.d.ts

@@ -0,0 +1,19 @@
+import type { IController } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+import type { IServerGroup } from '@spinnaker/core';
+import type { IEventDescription } from './serverGroupEventsReader.service';
+export interface IScalingActivitiesViewState {
+    loading: boolean;
+    error: boolean;
+}
+export declare class EventsController implements IController {
+    private $uibModalInstance;
+    serverGroup: IServerGroup;
+    viewState: IScalingActivitiesViewState;
+    events: IEventDescription[];
+    static $inject: string[];
+    constructor($uibModalInstance: IModalServiceInstance, serverGroup: IServerGroup);
+    $onInit(): void;
+    close(): void;
+}
+export declare const EVENTS_CTRL = "spinnaker.ecs.serverGroup.events.controller";

package/dist/serverGroup/events/serverGroupEventsReader.service.d.ts

@@ -0,0 +1,10 @@
+import type { IServerGroup } from '@spinnaker/core';
+export interface IEventDescription {
+    createdAt: number;
+    message: string;
+    id: string;
+    status: string;
+}
+export declare class ServerGroupEventsReader {
+    static getEvents(serverGroup: IServerGroup): PromiseLike<IEventDescription[]>;
+}

package/dist/serverGroup/serverGroup.module.d.ts

@@ -0,0 +1 @@
+export declare const ECS_SERVERGROUP_MODULE = "spinnaker.ecs.serverGroup";

package/dist/serverGroup/serverGroup.transformer.d.ts

@@ -0,0 +1,11 @@
+import type { IAmazonServerGroup, IAmazonServerGroupView } from '@spinnaker/amazon';
+export declare class EcsServerGroupTransformer {
+    private addComparator;
+    private addAdjustmentAttributes;
+    private transformScalingPolicy;
+    normalizeServerGroupDetails(serverGroup: IAmazonServerGroup): IAmazonServerGroupView;
+    normalizeServerGroup(serverGroup: IAmazonServerGroup): PromiseLike<IAmazonServerGroup>;
+    private addVpcNameToServerGroup;
+    convertServerGroupCommandToDeployConfiguration(base: any): any;
+}
+export declare const ECS_SERVER_GROUP_TRANSFORMER = "spinnaker.ecs.serverGroup.transformer";