@spinnaker/amazon 2026.2.2 → 2026.3.0

package/src/serverGroup/details/securityGroups/EditSecurityGroupsModal.tsx

@@ -0,0 +1,177 @@
+import React from 'react';
+import { Modal } from 'react-bootstrap';
+import Select from 'react-select';
+
+import type { Application, DeckRuntimeServices, IModalComponentProps, ISecurityGroup } from '@spinnaker/core';
+import {
+  confirmNotManaged,
+  DeckRuntimeContext,
+  FirewallLabels,
+  ModalClose,
+  ReactModal,
+  TaskMonitor,
+  TaskMonitorWrapper,
+} from '@spinnaker/core';
+
+import { AwsModalFooter } from '../../../common/AwsModalFooter';
+import type { IAmazonServerGroup } from '../../../domain';
+
+export interface IEditSecurityGroupsModalProps extends IModalComponentProps {
+  application: Application;
+  securityGroups?: ISecurityGroup[];
+  serverGroup: IAmazonServerGroup;
+}
+
+interface IEditSecurityGroupsModalState {
+  availableSecurityGroups: ISecurityGroup[];
+  securityGroups: ISecurityGroup[];
+  securityGroupsLoadError?: string;
+  securityGroupsLoaded: boolean;
+  taskMonitor: TaskMonitor;
+}
+
+export function isLaunchTemplateBacked(serverGroup: IAmazonServerGroup): boolean {
+  return Boolean(serverGroup.launchTemplate || serverGroup.mixedInstancesPolicy);
+}
+
+export function filterSecurityGroupsForServerGroup(
+  allGroups: any,
+  serverGroup: IAmazonServerGroup,
+  attached: ISecurityGroup[],
+): ISecurityGroup[] {
+  const regionalGroups: ISecurityGroup[] = allGroups?.[serverGroup.account]?.aws?.[serverGroup.region] || [];
+  const matchingGroups = regionalGroups.filter((group) => group.vpcId === serverGroup.vpcId);
+  const matchingById = new Map(matchingGroups.map((group) => [group.id, group]));
+  const selectedIds = new Set<string>();
+  const selected = (attached || []).map((group) => {
+    selectedIds.add(group.id);
+    return matchingById.get(group.id) || group;
+  });
+  const available = matchingGroups
+    .filter((group) => !selectedIds.has(group.id))
+    .sort((left, right) => left.name.localeCompare(right.name));
+  return [...selected, ...available];
+}
+
+export class EditSecurityGroupsModal extends React.Component<
+  IEditSecurityGroupsModalProps,
+  IEditSecurityGroupsModalState
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  public static show(props: IEditSecurityGroupsModalProps, runtimeServices: DeckRuntimeServices) {
+    return confirmNotManaged(props.serverGroup, props.application).then(
+      (notManaged) => notManaged && ReactModal.show(EditSecurityGroupsModal, props, undefined, runtimeServices),
+    );
+  }
+
+  private initialSecurityGroups =
+    this.props.securityGroups ||
+    (this.props.serverGroup.securityGroups || []).map((id: string) => ({ id, name: id } as ISecurityGroup));
+
+  public state: IEditSecurityGroupsModalState = {
+    availableSecurityGroups: this.initialSecurityGroups,
+    securityGroups: this.initialSecurityGroups,
+    securityGroupsLoaded: false,
+    taskMonitor: new TaskMonitor({
+      application: this.props.application,
+      title: `Update ${FirewallLabels.get('Firewalls')} for ${this.props.serverGroup.name}`,
+      onDismiss: this.props.dismissModal,
+      onTaskComplete: () => this.props.application.serverGroups.refresh(),
+    }),
+  };
+
+  private isUnmounted = false;
+
+  public componentDidMount() {
+    this.loadSecurityGroups();
+  }
+
+  public componentWillUnmount() {
+    this.isUnmounted = true;
+  }
+
+  private loadSecurityGroups = () => {
+    this.setState({ securityGroupsLoaded: false, securityGroupsLoadError: undefined });
+    return this.context.services.securityGroupReader
+      .getAllSecurityGroups()
+      .then((allGroups) => {
+        if (!this.isUnmounted) {
+          this.setState({
+            availableSecurityGroups: filterSecurityGroupsForServerGroup(
+              allGroups,
+              this.props.serverGroup,
+              this.state.securityGroups,
+            ),
+            securityGroupsLoaded: true,
+          });
+        }
+      })
+      .catch(() => {
+        if (!this.isUnmounted) {
+          this.setState({
+            securityGroupsLoaded: true,
+            securityGroupsLoadError: 'Unable to load security groups. Check your connection and try again.',
+          });
+        }
+      });
+  };
+
+  private submit = () => {
+    const { application, serverGroup } = this.props;
+    this.state.taskMonitor.submit(() =>
+      this.context.services.serverGroupWriter.updateSecurityGroups(
+        serverGroup,
+        this.state.securityGroups,
+        application,
+        isLaunchTemplateBacked(serverGroup),
+      ),
+    );
+  };
+
+  public render() {
+    const { dismissModal, serverGroup } = this.props;
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={dismissModal} />
+        <Modal.Header>
+          <Modal.Title>
+            Edit {FirewallLabels.get('Firewalls')} for {serverGroup.name}
+          </Modal.Title>
+        </Modal.Header>
+        <Modal.Body className="container-fluid form-horizontal">
+          <div className="form-group">
+            <div className="col-md-10 col-md-offset-1">
+              <Select
+                labelKey="name"
+                isLoading={!this.state.securityGroupsLoaded}
+                multi={true}
+                onChange={(securityGroups: ISecurityGroup[]) => this.setState({ securityGroups: securityGroups || [] })}
+                optionRenderer={(group: ISecurityGroup) => <span>{`${group.name} (${group.id})`}</span>}
+                options={this.state.availableSecurityGroups}
+                value={this.state.securityGroups}
+                valueKey="id"
+              />
+              {this.state.securityGroupsLoadError && (
+                <div className="alert alert-danger security-groups-load-error" role="alert">
+                  {this.state.securityGroupsLoadError}{' '}
+                  <button className="btn btn-default btn-xs" onClick={this.loadSecurityGroups} type="button">
+                    Retry
+                  </button>
+                </div>
+              )}
+            </div>
+          </div>
+        </Modal.Body>
+        <AwsModalFooter
+          account={serverGroup.account}
+          isValid={this.state.securityGroupsLoaded && !this.state.securityGroupsLoadError}
+          onCancel={dismissModal}
+          onSubmit={this.submit}
+        />
+      </>
+    );
+  }
+}

package/src/serverGroup/details/securityGroups/index.ts

@@ -0,0 +1 @@
+export * from './EditSecurityGroupsModal';

package/src/serverGroup/details/warmPool/ModifyWarmPoolModal.spec.tsx

@@ -0,0 +1,69 @@
+import { TaskExecutor } from '@spinnaker/core';
+
+import { ModifyWarmPoolModal, buildWarmPoolJob } from './ModifyWarmPoolModal';
+
+describe('ModifyWarmPoolModal', () => {
+  const serverGroup = { name: 'deck-main-v001', account: 'test', region: 'us-east-1' } as any;
+
+  it('builds a delete job when disabled', () => {
+    const state = { enabled: false, minSize: 0, maxGroupPreparedCapacity: -1, poolState: 'Stopped' } as any;
+
+    expect(buildWarmPoolJob(state, serverGroup)).toEqual({
+      type: 'modifyWarmPool',
+      action: 'delete',
+      asgName: 'deck-main-v001',
+      regions: ['us-east-1'],
+      credentials: 'test',
+      cloudProvider: 'aws',
+      reason: undefined,
+    });
+  });
+
+  it('builds an upsert job with the configured fields when enabled', () => {
+    const state = {
+      enabled: true,
+      minSize: 2,
+      maxGroupPreparedCapacity: 10,
+      poolState: 'Running',
+      reuseOnScaleIn: true,
+      reason: 'maintenance',
+    } as any;
+
+    expect(buildWarmPoolJob(state, serverGroup)).toEqual({
+      type: 'modifyWarmPool',
+      action: 'upsert',
+      minSize: 2,
+      maxGroupPreparedCapacity: 10,
+      poolState: 'Running',
+      reuseOnScaleIn: true,
+      asgName: 'deck-main-v001',
+      regions: ['us-east-1'],
+      credentials: 'test',
+      cloudProvider: 'aws',
+      reason: 'maintenance',
+    });
+  });
+
+  it('submits the built job through the task monitor', () => {
+    const execute = spyOn(TaskExecutor, 'executeTask').and.returnValue(Promise.resolve({} as any));
+    const application = { name: 'deck', serverGroups: { refresh: jasmine.createSpy('refresh') } } as any;
+    const modal = new ModifyWarmPoolModal({
+      application,
+      serverGroup: { ...serverGroup, asg: {} },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+    } as any) as any;
+    modal.state.enabled = true;
+    modal.state.minSize = 3;
+    modal.state.poolState = 'Stopped';
+    modal.state.taskMonitor = { submit: (method: () => any) => method() };
+
+    modal.submit();
+
+    expect(execute).toHaveBeenCalledWith({
+      application,
+      description: 'Update Warm Pool for deck-main-v001',
+      job: [jasmine.objectContaining({ action: 'upsert', minSize: 3, poolState: 'Stopped' })],
+    });
+  });
+});

package/src/serverGroup/details/warmPool/ModifyWarmPoolModal.tsx

@@ -0,0 +1,191 @@
+import React from 'react';
+import { Modal } from 'react-bootstrap';
+
+import type { Application, IJob, IModalComponentProps } from '@spinnaker/core';
+import {
+  confirmNotManaged,
+  HelpField,
+  ModalClose,
+  ReactModal,
+  TaskExecutor,
+  TaskMonitor,
+  TaskMonitorWrapper,
+  TaskReason,
+} from '@spinnaker/core';
+
+import { WarmPoolService } from './WarmPoolService';
+import { AwsModalFooter } from '../../../common/AwsModalFooter';
+import type { IAmazonServerGroup } from '../../../domain';
+
+export interface IModifyWarmPoolModalProps extends IModalComponentProps {
+  application: Application;
+  serverGroup: IAmazonServerGroup;
+}
+
+interface IModifyWarmPoolModalState {
+  enabled: boolean;
+  minSize: number;
+  maxGroupPreparedCapacity: number;
+  poolState: string;
+  reuseOnScaleIn: boolean;
+  reason?: string;
+  taskMonitor: TaskMonitor;
+}
+
+export function buildWarmPoolJob(state: IModifyWarmPoolModalState, serverGroup: IAmazonServerGroup): IJob {
+  const base = {
+    asgName: serverGroup.name,
+    regions: [serverGroup.region],
+    credentials: serverGroup.account,
+    cloudProvider: 'aws',
+    reason: state.reason,
+  };
+
+  if (!state.enabled) {
+    return { ...base, type: 'modifyWarmPool', action: 'delete' };
+  }
+
+  return {
+    ...base,
+    type: 'modifyWarmPool',
+    action: 'upsert',
+    minSize: state.minSize,
+    maxGroupPreparedCapacity: state.maxGroupPreparedCapacity,
+    poolState: state.poolState,
+    reuseOnScaleIn: state.reuseOnScaleIn,
+  };
+}
+
+export class ModifyWarmPoolModal extends React.Component<IModifyWarmPoolModalProps, IModifyWarmPoolModalState> {
+  public static show(props: IModifyWarmPoolModalProps) {
+    return confirmNotManaged(props.serverGroup, props.application).then(
+      (notManaged) => notManaged && ReactModal.show(ModifyWarmPoolModal, props),
+    );
+  }
+
+  private initialConfiguration = WarmPoolService.getWarmPoolConfiguration(this.props.serverGroup);
+
+  public state: IModifyWarmPoolModalState = {
+    enabled: !!this.initialConfiguration,
+    minSize: this.initialConfiguration?.minSize ?? 0,
+    maxGroupPreparedCapacity: this.initialConfiguration?.maxGroupPreparedCapacity ?? -1,
+    poolState: this.initialConfiguration?.poolState ?? 'Stopped',
+    reuseOnScaleIn: this.initialConfiguration?.instanceReusePolicy?.reuseOnScaleIn ?? false,
+    taskMonitor: new TaskMonitor({
+      application: this.props.application,
+      title: `Update Warm Pool for ${this.props.serverGroup.name}`,
+      onDismiss: this.props.dismissModal,
+      onTaskComplete: () => this.props.application.serverGroups.refresh(),
+    }),
+  };
+
+  private submit = () => {
+    const { application, serverGroup } = this.props;
+    const job = buildWarmPoolJob(this.state, serverGroup);
+    this.state.taskMonitor.submit(() =>
+      TaskExecutor.executeTask({
+        application,
+        description: `Update Warm Pool for ${serverGroup.name}`,
+        job: [job],
+      }),
+    );
+  };
+
+  public render() {
+    const { dismissModal, serverGroup } = this.props;
+    const { enabled, minSize, maxGroupPreparedCapacity, poolState, reuseOnScaleIn } = this.state;
+    return (
+      <>
+        <TaskMonitorWrapper monitor={this.state.taskMonitor} />
+        <ModalClose dismiss={dismissModal} />
+        <Modal.Header>
+          <Modal.Title>Modify Warm Pool for {serverGroup.name}</Modal.Title>
+        </Modal.Header>
+        <Modal.Body className="container-fluid form-horizontal">
+          <div className="form-group">
+            <div className="col-sm-offset-2 col-sm-10">
+              <div className="checkbox">
+                <label>
+                  <input
+                    checked={enabled}
+                    onChange={(event) => this.setState({ enabled: event.target.checked })}
+                    type="checkbox"
+                  />{' '}
+                  Enable Warm Pool
+                  <HelpField
+                    content="Keeps a pool of pre-initialized instances alongside this Auto Scaling Group to speed up scale-out."
+                    placement="right"
+                  />
+                </label>
+              </div>
+            </div>
+          </div>
+          {enabled && (
+            <>
+              <div className="form-group">
+                <label className="col-sm-4 control-label">Min Size</label>
+                <div className="col-sm-6">
+                  <input
+                    className="form-control"
+                    type="number"
+                    min={0}
+                    value={minSize}
+                    onChange={(event) => this.setState({ minSize: Number(event.target.value) })}
+                  />
+                </div>
+              </div>
+              <div className="form-group">
+                <label className="col-sm-4 control-label">
+                  Max Group Prepared Capacity
+                  <HelpField content="The maximum capacity of the Auto Scaling Group, including the warm pool. -1 means no limit beyond the group's own max size." />
+                </label>
+                <div className="col-sm-6">
+                  <input
+                    className="form-control"
+                    type="number"
+                    min={-1}
+                    value={maxGroupPreparedCapacity}
+                    onChange={(event) => this.setState({ maxGroupPreparedCapacity: Number(event.target.value) })}
+                  />
+                </div>
+              </div>
+              <div className="form-group">
+                <label className="col-sm-4 control-label">Instance State</label>
+                <div className="col-sm-6">
+                  <select
+                    className="form-control"
+                    value={poolState}
+                    onChange={(event) => this.setState({ poolState: event.target.value })}
+                  >
+                    {WarmPoolService.poolStates().map((state) => (
+                      <option key={state} value={state}>
+                        {state}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+              </div>
+              <div className="form-group">
+                <div className="col-sm-offset-2 col-sm-10">
+                  <div className="checkbox">
+                    <label>
+                      <input
+                        checked={reuseOnScaleIn}
+                        onChange={(event) => this.setState({ reuseOnScaleIn: event.target.checked })}
+                        type="checkbox"
+                      />{' '}
+                      Reuse instances on scale in
+                      <HelpField content="If enabled, instances terminated by scale-in are returned to the warm pool instead of being terminated." />
+                    </label>
+                  </div>
+                </div>
+              </div>
+            </>
+          )}
+          <TaskReason reason={this.state.reason} onChange={(reason) => this.setState({ reason })} />
+        </Modal.Body>
+        <AwsModalFooter account={serverGroup.account} isValid={true} onCancel={dismissModal} onSubmit={this.submit} />
+      </>
+    );
+  }
+}

package/src/serverGroup/details/warmPool/WarmPoolService.spec.ts

@@ -0,0 +1,30 @@
+import { WarmPoolService } from './WarmPoolService';
+import type { IAmazonServerGroup } from '../../../domain';
+
+describe('WarmPoolService', () => {
+  describe('getWarmPoolConfiguration', () => {
+    it('returns undefined if no asg or warmPoolConfiguration present on server group', () => {
+      expect(WarmPoolService.getWarmPoolConfiguration({} as IAmazonServerGroup)).toBeUndefined();
+      expect(WarmPoolService.getWarmPoolConfiguration({ asg: {} } as IAmazonServerGroup)).toBeUndefined();
+    });
+
+    it('returns the warm pool configuration when present', () => {
+      const asg = { warmPoolConfiguration: { minSize: 2, poolState: 'Stopped' } } as any;
+      expect(WarmPoolService.getWarmPoolConfiguration({ asg } as IAmazonServerGroup)).toEqual({
+        minSize: 2,
+        poolState: 'Stopped',
+      });
+    });
+  });
+
+  describe('isEnabled', () => {
+    it('returns false when no warm pool is configured', () => {
+      expect(WarmPoolService.isEnabled({ asg: {} } as IAmazonServerGroup)).toBe(false);
+    });
+
+    it('returns true when a warm pool is configured', () => {
+      const asg = { warmPoolConfiguration: { minSize: 1 } } as any;
+      expect(WarmPoolService.isEnabled({ asg } as IAmazonServerGroup)).toBe(true);
+    });
+  });
+});

package/src/serverGroup/details/warmPool/WarmPoolService.ts

@@ -0,0 +1,15 @@
+import type { IAmazonServerGroup, IAmazonWarmPoolConfiguration } from '../../../domain';
+
+export class WarmPoolService {
+  public static getWarmPoolConfiguration(serverGroup: IAmazonServerGroup): IAmazonWarmPoolConfiguration | undefined {
+    return serverGroup.asg?.warmPoolConfiguration;
+  }
+
+  public static isEnabled(serverGroup: IAmazonServerGroup): boolean {
+    return !!WarmPoolService.getWarmPoolConfiguration(serverGroup);
+  }
+
+  public static poolStates(): Array<IAmazonWarmPoolConfiguration['poolState']> {
+    return ['Stopped', 'Running', 'Hibernated'];
+  }
+}

package/src/serverGroup/details/warmPool/index.ts

@@ -0,0 +1,2 @@
+export * from './WarmPoolService';
+export * from './ModifyWarmPoolModal';

package/src/serverGroup/serverGroup.transformer.ts

@@ -1,5 +1,3 @@
-import { module } from 'angular';
-
 import type { IVpc } from '@spinnaker/core';
 
 import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './configure';
@@ -70,7 +68,7 @@ export class AwsServerGroupTransformer {
     return view;
   }
 
-  public normalizeServerGroup(serverGroup: IAmazonServerGroup): PromiseLike<IAmazonServerGroup> {
+  public normalizeServerGroup(serverGroup: IAmazonServerGroup): Promise<IAmazonServerGroup> {
     serverGroup.instances.forEach((instance) => {
       instance.vpcId = serverGroup.vpcId;
     });
@@ -155,6 +153,3 @@ export class AwsServerGroupTransformer {
     };
   }
 }
-
-export const AWS_SERVER_GROUP_TRANSFORMER = 'spinnaker.amazon.serverGroup.transformer';
-module(AWS_SERVER_GROUP_TRANSFORMER, []).service('awsServerGroupTransformer', AwsServerGroupTransformer);

package/src/vpc/VpcReader.ts

@@ -2,9 +2,9 @@ import type { IVpc } from '@spinnaker/core';
 import { NetworkReader } from '@spinnaker/core';
 
 export class VpcReader {
-  private static cache: PromiseLike<IVpc[]>;
+  private static cache: Promise<IVpc[]>;
 
-  public static listVpcs(): PromiseLike<IVpc[]> {
+  public static listVpcs(): Promise<IVpc[]> {
     if (this.cache) {
       return this.cache;
     }

package/src/vpc/index.ts

@@ -1 +1,2 @@
 export * from './VpcReader';
+export * from './VpcTag';

package/dist/common/common.module.d.ts

@@ -1 +0,0 @@
-export declare const COMMON_MODULE = "spinnaker.amazon.common";

package/dist/common/footer.component.d.ts

@@ -1 +0,0 @@
-export declare const AWS_FOOTER_COMPONENT = "spinnaker.amazon.footer";

package/dist/function/function.module.d.ts

@@ -1 +0,0 @@
-export declare const AWS_FUNCTION_MODULE = "spinnaker.amazon.function";

package/dist/instance/details/amazonInstanceInformation.component.d.ts

@@ -1 +0,0 @@
-export declare const AMAZON_INSTANCE_INFORMATION_COMPONENT = "spinnaker.application.amazonInstanceInformation.component";

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

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

package/dist/instance/details/instanceDns.component.d.ts

@@ -1 +0,0 @@
-export declare const INSTANCE_DNS_COMPONENT = "spinnaker.application.instanceDns.component";

package/dist/instance/details/instanceSecurityGroups.component.d.ts

@@ -1 +0,0 @@
-export declare const INSTANCE_SECURITY_GROUPS_COMPONENT = "spinnaker.application.instanceSecurityGroups.component";

package/dist/instance/details/instanceStatus.component.d.ts

@@ -1 +0,0 @@
-export declare const INSTANCE_STATUS_COMPONENT = "spinnaker.application.instanceStatus.component";

package/dist/instance/details/instanceTags.component.d.ts

@@ -1 +0,0 @@
-export declare const INSTANCE_TAGS_COMPONENT = "spinnaker.application.instanceTags.component";

package/dist/loadBalancer/details/loadBalancerActions.component.d.ts

@@ -1 +0,0 @@
-export declare const LOAD_BALANCER_ACTIONS = "spinnaker.amazon.loadBalancer.details.loadBalancerActions.component";

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

@@ -1,41 +0,0 @@
-import type { StateService } from '@uirouter/angularjs';
-import type { IController, IQService, IScope } from 'angular';
-import type { Application, ISecurityGroup, ISubnet, LoadBalancerReader, SecurityGroupReader } from '@spinnaker/core';
-import type { IAmazonLoadBalancer, IListenerAction, ITargetGroup } from '../../domain';
-export interface ILoadBalancerFromStateParams {
-    accountId: string;
-    region: string;
-    name: string;
-}
-export interface IActionDetails extends IListenerAction {
-    targetGroup: ITargetGroup;
-}
-export declare class AwsLoadBalancerDetailsController implements IController {
-    private $scope;
-    private $state;
-    private $q;
-    private app;
-    private securityGroupReader;
-    private loadBalancerReader;
-    application: Application;
-    elbProtocol: string;
-    listeners: Array<{
-        in: string;
-        actions: IActionDetails[];
-    }>;
-    loadBalancerFromParams: ILoadBalancerFromStateParams;
-    loadBalancer: IAmazonLoadBalancer;
-    securityGroups: ISecurityGroup[];
-    ipAddressTypeDescription: string;
-    state: {
-        loading: boolean;
-    };
-    firewallsLabel: string;
-    oidcConfigPath: any;
-    static $inject: string[];
-    constructor($scope: IScope, $state: StateService, $q: IQService, loadBalancer: ILoadBalancerFromStateParams, app: Application, securityGroupReader: SecurityGroupReader, loadBalancerReader: LoadBalancerReader);
-    autoClose(): void;
-    extractLoadBalancer(): PromiseLike<void>;
-    getFirstSubnetPurpose(subnetDetailsList?: ISubnet[]): string;
-}
-export declare const AWS_LOAD_BALANCER_DETAILS_CTRL = "spinnaker.amazon.loadBalancer.details.controller";

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

@@ -1,30 +0,0 @@
-import type { StateService } from '@uirouter/angularjs';
-import type { IController, IQService, IScope } from 'angular';
-import type { Application } from '@spinnaker/core';
-import type { IAmazonApplicationLoadBalancer, ITargetGroup } from '../../domain/IAmazonLoadBalancer';
-export interface ITargetGroupFromStateParams {
-    accountId: string;
-    region: string;
-    name: string;
-    loadBalancerName: string;
-    vpcId: string;
-}
-export declare class AwsTargetGroupDetailsController implements IController {
-    private $scope;
-    private $q;
-    private $state;
-    private app;
-    private targetGroupFromParams;
-    application: Application;
-    state: {
-        loading: boolean;
-    };
-    elbProtocol: string;
-    targetGroup: ITargetGroup;
-    loadBalancer: IAmazonApplicationLoadBalancer;
-    static $inject: string[];
-    constructor($scope: IScope, $q: IQService, $state: StateService, targetGroup: ITargetGroupFromStateParams, app: Application);
-    autoClose(): void;
-    extractTargetGroup(): PromiseLike<void>;
-}
-export declare const AWS_TARGET_GROUP_DETAILS_CTRL = "spinnaker.amazon.loadBalancer.details.targetGroupDetails.controller";

package/dist/loadBalancer/loadBalancer.module.d.ts

@@ -1 +0,0 @@
-export declare const AWS_LOAD_BALANCER_MODULE = "spinnaker.amazon.loadBalancer";

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

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

package/dist/pipeline/stages/bake/awsBakeStage.d.ts

@@ -1,2 +0,0 @@
-export const AMAZON_PIPELINE_STAGES_BAKE_AWSBAKESTAGE: "spinnaker.amazon.pipeline.stage.bakeStage";
-export const name: "spinnaker.amazon.pipeline.stage.bakeStage";

package/dist/pipeline/stages/bake/bakeExecutionDetails.controller.d.ts

@@ -1,2 +0,0 @@
-export const AMAZON_PIPELINE_STAGES_BAKE_BAKEEXECUTIONDETAILS_CONTROLLER: "spinnaker.amazon.pipeline.stage.bake.executionDetails.controller";
-export const name: "spinnaker.amazon.pipeline.stage.bake.executionDetails.controller";

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

@@ -1,2 +0,0 @@
-export const AMAZON_PIPELINE_STAGES_CLONESERVERGROUP_AWSCLONESERVERGROUPSTAGE: "spinnaker.amazon.pipeline.stage.cloneServerGroupStage";
-export const name: "spinnaker.amazon.pipeline.stage.cloneServerGroupStage";

package/dist/pipeline/stages/deployCloudFormation/cloudFormationTemplateEntry.component.d.ts

@@ -1 +0,0 @@
-export declare const CLOUDFORMATION_TEMPLATE_ENTRY = "spinnaker.amazon.cloudformation.entry.component";