@spinnaker/amazon 2026.2.2 → 2026.3.0

package/dist/instance/amazon.instance.write.service.d.ts

@@ -1,4 +1,4 @@
-import type { Application, IMultiInstanceGroup, IMultiInstanceJob, ITask } from '@spinnaker/core';
+import type { Application, IMultiInstanceGroup, IMultiInstanceJob, ITask, ProviderServiceDelegate } from '@spinnaker/core';
 import { InstanceWriter } from '@spinnaker/core';
 import type { IAmazonInstance } from '../domain';
 export interface IAmazonMultiInstanceGroup extends IMultiInstanceGroup {
@@ -8,8 +8,8 @@ export interface IAmazonMultiInstanceJob extends IMultiInstanceJob {
     targetGroupNames?: string[];
 }
 export declare class AmazonInstanceWriter extends InstanceWriter {
-    static deregisterInstancesFromTargetGroup(instanceGroups: IMultiInstanceGroup[], application: Application, targetGroupNames: string[]): PromiseLike<ITask>;
-    static deregisterInstanceFromTargetGroup(instance: IAmazonInstance, application: Application, params?: any): PromiseLike<ITask>;
-    static registerInstancesWithTargetGroup(instanceGroups: IMultiInstanceGroup[], application: Application, targetGroupNames: string[]): PromiseLike<ITask>;
-    static registerInstanceWithTargetGroup(instance: IAmazonInstance, application: Application, params?: any): PromiseLike<ITask>;
+    static deregisterInstancesFromTargetGroup(instanceGroups: IMultiInstanceGroup[], application: Application, targetGroupNames: string[], providerServiceDelegate: ProviderServiceDelegate): Promise<ITask>;
+    static deregisterInstanceFromTargetGroup(instance: IAmazonInstance, application: Application, params?: any): Promise<ITask>;
+    static registerInstancesWithTargetGroup(instanceGroups: IMultiInstanceGroup[], application: Application, targetGroupNames: string[], providerServiceDelegate: ProviderServiceDelegate): Promise<ITask>;
+    static registerInstanceWithTargetGroup(instance: IAmazonInstance, application: Application, params?: any): Promise<ITask>;
 }

package/dist/instance/awsInstanceType.service.d.ts

@@ -46,5 +46,16 @@ export interface IAmazonInstanceGpuDeviceInfo {
 export interface IAmazonInstanceTypesByRegion extends IInstanceTypesByRegion {
     [region: string]: IAmazonInstanceType[];
 }
-export declare const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE = "spinnaker.amazon.instanceType.service";
-export declare const name = "spinnaker.amazon.instanceType.service";
+export declare class AwsInstanceTypeService {
+    private instanceClassOrder;
+    private families;
+    getCategories(): Promise<IAmazonInstanceTypeCategory[]>;
+    getAllTypesByRegion(): Promise<IAmazonInstanceTypesByRegion>;
+    private sortTypesByFamilyAndSize;
+    getAvailableTypesForRegions(availableInstanceTypes: IAmazonInstanceTypesByRegion, selectedRegions: string[]): IAmazonInstanceType[];
+    filterInstanceTypes(instanceTypes: IAmazonInstanceType[], virtualizationType: string, vpcConfigured: boolean, architecture: string): IAmazonInstanceType[];
+    isEbsOptimized(instanceType: string): boolean;
+    isBurstingSupportedForAllTypes(instanceTypes: string[]): boolean;
+    isBurstingSupported(instanceType: string): boolean;
+    getInstanceTypesInCategory(instanceTypesToFilter: string[], category: string): string[];
+}

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

@@ -0,0 +1,67 @@
+import React from 'react';
+import type { Application, IInstanceDetailsProps, IRouterInjectedProps } from '@spinnaker/core';
+import type { IAmazonHealth, IAmazonInstance } from '../../domain';
+interface IAmazonInstanceParams {
+    account?: string;
+    instanceId: string;
+    provider?: string;
+    region?: string;
+}
+interface IAmazonInstanceDetailsProps extends Partial<IInstanceDetailsProps> {
+    accountId?: string;
+    app: Application;
+    environment?: string;
+    initialInstance?: IAmazonLoadedInstance;
+    instance?: IAmazonInstanceParams;
+    $stateParams?: IInstanceDetailsProps['$stateParams'] & Partial<IAmazonInstanceParams>;
+}
+export interface IAmazonLoadedInstance extends IAmazonInstance {
+    [key: string]: any;
+    baseIpAddress?: string;
+    healthMetrics?: IAmazonHealth[];
+    instanceId?: string;
+    instanceIdNotFound?: string;
+    ipv6Addresses?: Array<{
+        ip: string;
+        url: string;
+    }>;
+    permanentIps?: string[];
+    serverGroupDisabled?: boolean;
+}
+export declare function loadAmazonInstanceDetails({ app, instance, }: {
+    app: Application;
+    instance: IAmazonInstanceParams;
+}): Promise<IAmazonLoadedInstance>;
+export declare function AmazonInstanceActionsComponent({ app, instance, stateService, }: {
+    app: Application;
+    instance: IAmazonLoadedInstance;
+} & IRouterInjectedProps): JSX.Element | null;
+export declare class AmazonInstanceDetailsComponent extends React.Component<IAmazonInstanceDetailsProps & IRouterInjectedProps, {
+    instance?: IAmazonLoadedInstance;
+    loading: boolean;
+}> {
+    state: {
+        instance: IAmazonLoadedInstance;
+        loading: boolean;
+    };
+    private activeRequestId;
+    private isUnmounted;
+    private unsubscribeFromRefresh;
+    componentDidMount(): void;
+    private closeDetails;
+    componentDidUpdate(prevProps: IAmazonInstanceDetailsProps): void;
+    componentWillUnmount(): void;
+    private getInstanceParams;
+    private retrieveInstance;
+    render(): JSX.Element;
+}
+export declare const AmazonInstanceActions: React.ForwardRefExoticComponent<Omit<{
+    app: Application;
+    instance: IAmazonLoadedInstance;
+} & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export declare const AmazonInstanceDetails: React.ForwardRefExoticComponent<Omit<IAmazonInstanceDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export {};

package/dist/instance/index.d.ts

@@ -1,4 +1,5 @@
 export * from './details/utils';
+export * from './details/AmazonInstanceDetails';
 export * from './details/InstanceDns';
 export * from './details/InstanceInformation';
 export * from './details/InstanceStatus';

package/dist/keyPairs/KeyPairsReader.d.ts

@@ -1,4 +1,4 @@
 import type { IKeyPair } from '../domain';
 export declare class KeyPairsReader {
-    static listKeyPairs(): PromiseLike<IKeyPair[]>;
+    static listKeyPairs(): Promise<IKeyPair[]>;
 }

package/dist/loadBalancer/AmazonLoadBalancersTag.d.ts

@@ -1,20 +1,23 @@
 import React from 'react';
-import type { ILoadBalancer, ILoadBalancersTagProps } from '@spinnaker/core';
+import type { ILoadBalancer, ILoadBalancersTagProps, IRouterInjectedProps } from '@spinnaker/core';
 import type { ITargetGroup } from '../domain';
 export interface IAmazonLoadBalancersTagState {
     loadBalancers: ILoadBalancer[];
     targetGroups: ITargetGroup[];
     isLoading: boolean;
 }
-export declare class AmazonLoadBalancersTag extends React.Component<ILoadBalancersTagProps, IAmazonLoadBalancersTagState> {
+export declare class AmazonLoadBalancersTagComponent extends React.Component<ILoadBalancersTagProps & IRouterInjectedProps, IAmazonLoadBalancersTagState> {
     private loadBalancersRefreshUnsubscribe;
     private mounted;
-    constructor(props: ILoadBalancersTagProps);
+    constructor(props: ILoadBalancersTagProps & IRouterInjectedProps);
     private showLoadBalancerDetails;
     private showTargetGroupDetails;
     private handleShowPopover;
     private handleClick;
     componentDidMount(): void;
     componentWillUnmount(): void;
-    render(): React.ReactElement<AmazonLoadBalancersTag>;
+    render(): React.ReactElement;
 }
+export declare const AmazonLoadBalancersTag: React.ForwardRefExoticComponent<Omit<ILoadBalancersTagProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;

package/dist/loadBalancer/OidcConfigReader.d.ts

@@ -12,5 +12,5 @@ export interface IAuthenticateOidcActionConfig {
     userInfoEndpoint: string;
 }
 export declare class OidcConfigReader {
-    static getOidcConfigsByApp(app: string): PromiseLike<IAuthenticateOidcActionConfig[]>;
+    static getOidcConfigsByApp(app: string): Promise<IAuthenticateOidcActionConfig[]>;
 }

package/dist/loadBalancer/TargetGroupDetails.d.ts

@@ -1,7 +1,41 @@
 import React from 'react';
-import type { IOverridableProps } from '@spinnaker/core';
-export interface ITargetGroupDetailsProps extends IOverridableProps {
+import type { Application, IRouterInjectedProps } from '@spinnaker/core';
+import type { IAmazonApplicationLoadBalancer, ITargetGroup } from '../domain';
+interface IAmazonTargetGroupDetailsState {
+    loadBalancer?: IAmazonApplicationLoadBalancer;
+    loading: boolean;
+    targetGroup?: ITargetGroup;
 }
-export declare class TargetGroupDetails extends React.Component<ITargetGroupDetailsProps> {
+interface ITargetGroupStateParams {
+    accountId: string;
+    loadBalancerName: string;
+    name: string;
+    provider: string;
+    region: string;
+    vpcId?: string;
+}
+interface ITargetGroupDetailsProps {
+    accountId: string;
+    app: Application;
+    name: string;
+    provider: string;
+    targetGroup: ITargetGroupStateParams;
+}
+export declare class TargetGroupDetailsComponent extends React.Component<ITargetGroupDetailsProps & IRouterInjectedProps, IAmazonTargetGroupDetailsState> {
+    state: IAmazonTargetGroupDetailsState;
+    private unsubscribeFromRefresh;
+    private isUnmounted;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private extractTargetGroup;
+    private autoClose;
+    private closeDetails;
+    private renderHeader;
+    private renderNotFound;
+    private renderDetails;
     render(): JSX.Element;
 }
+export declare const TargetGroupDetails: React.ForwardRefExoticComponent<Omit<ITargetGroupDetailsProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>>;
+export {};

package/dist/loadBalancer/amazonLoadBalancerDataUtils.d.ts

@@ -2,5 +2,5 @@ import type { Application } from '@spinnaker/core';
 import type { IAmazonServerGroup, ITargetGroup } from '../domain';
 export declare class AmazonLoadBalancerDataUtils {
     private static buildTargetGroup;
-    static populateTargetGroups(application: Application, serverGroup: IAmazonServerGroup): PromiseLike<ITargetGroup[]>;
+    static populateTargetGroups(application: Application, serverGroup: IAmazonServerGroup): Promise<ITargetGroup[]>;
 }

package/dist/loadBalancer/configure/AmazonLoadBalancerChoiceModal.d.ts

@@ -1,13 +1,17 @@
 import React from 'react';
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { DeckRuntimeServices, ILoadBalancerModalProps } from '@spinnaker/core';
+import { DeckRuntimeContext } from '@spinnaker/core';
 import type { IAmazonLoadBalancerConfig } from './LoadBalancerTypes';
 export interface IAmazonLoadBalancerChoiceModalState {
     choices: IAmazonLoadBalancerConfig[];
     selectedChoice: IAmazonLoadBalancerConfig;
 }
 export declare class AmazonLoadBalancerChoiceModal extends React.Component<ILoadBalancerModalProps, IAmazonLoadBalancerChoiceModalState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
+    static supportsPipelineConfig: boolean;
     static defaultProps: Partial<ILoadBalancerModalProps>;
-    static show(props: ILoadBalancerModalProps): Promise<void>;
+    static show(props: ILoadBalancerModalProps, runtimeServices: DeckRuntimeServices): Promise<any>;
     constructor(props: ILoadBalancerModalProps);
     choiceSelected(choice: IAmazonLoadBalancerConfig): void;
     private choose;

package/dist/loadBalancer/configure/LoadBalancerTypes.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { DeckRuntimeServices, ILoadBalancerModalProps } from '@spinnaker/core';
 import type { IAmazonLoadBalancerUpsertCommand } from '../../domain';
-export interface ICloseableLoadBalancerModal extends React.ComponentClass<ILoadBalancerModalProps> {
-    show: (props: ILoadBalancerModalProps) => Promise<IAmazonLoadBalancerUpsertCommand>;
-}
+export type ICloseableLoadBalancerModal = React.ComponentType<ILoadBalancerModalProps> & {
+    show: (props: ILoadBalancerModalProps, runtimeServices: DeckRuntimeServices) => Promise<IAmazonLoadBalancerUpsertCommand>;
+};
 export interface IAmazonLoadBalancerConfig {
     type: 'network' | 'application' | 'classic';
     label: string;

package/dist/loadBalancer/configure/application/CreateApplicationLoadBalancer.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { DeckRuntimeServices, ILoadBalancerModalProps, IRouterInjectedProps } from '@spinnaker/core';
 import { TaskMonitor } from '@spinnaker/core';
 import type { IAmazonApplicationLoadBalancer, IAmazonApplicationLoadBalancerUpsertCommand } from '../../../domain';
 import '../common/configure.less';
@@ -12,13 +12,13 @@ export interface ICreateApplicationLoadBalancerState {
     loadBalancerCommand: IAmazonApplicationLoadBalancerUpsertCommand;
     taskMonitor: TaskMonitor;
 }
-export declare class CreateApplicationLoadBalancer extends React.Component<ICreateApplicationLoadBalancerProps, ICreateApplicationLoadBalancerState> {
+export declare class CreateApplicationLoadBalancerComponent extends React.Component<ICreateApplicationLoadBalancerProps & IRouterInjectedProps, ICreateApplicationLoadBalancerState> {
     static defaultProps: Partial<ICreateApplicationLoadBalancerProps>;
     private _isUnmounted;
-    private refreshUnsubscribe;
+    private refreshUnsubscribe?;
     private certificateTypes;
-    static show(props: ICreateApplicationLoadBalancerProps): Promise<IAmazonApplicationLoadBalancerUpsertCommand>;
-    constructor(props: ICreateApplicationLoadBalancerProps);
+    static show(props: ICreateApplicationLoadBalancerProps, runtimeServices: DeckRuntimeServices): Promise<IAmazonApplicationLoadBalancerUpsertCommand>;
+    constructor(props: ICreateApplicationLoadBalancerProps & IRouterInjectedProps);
     protected certificateIdAsARN(accountId: string, certificateId: string, region: string, certificateType: string): string;
     private formatListeners;
     private setAvailabilityZones;
@@ -33,3 +33,8 @@ export declare class CreateApplicationLoadBalancer extends React.Component<ICrea
     private submit;
     render(): JSX.Element;
 }
+export declare const CreateApplicationLoadBalancer: React.ForwardRefExoticComponent<Omit<ICreateApplicationLoadBalancerProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof CreateApplicationLoadBalancerComponent.show;
+};

package/dist/loadBalancer/configure/classic/CreateClassicLoadBalancer.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { DeckRuntimeServices, ILoadBalancerModalProps, IRouterInjectedProps } from '@spinnaker/core';
 import { TaskMonitor } from '@spinnaker/core';
 import type { IAmazonClassicLoadBalancer, IAmazonClassicLoadBalancerUpsertCommand } from '../../../domain';
 import '../common/configure.less';
@@ -11,15 +11,15 @@ export interface ICreateClassicLoadBalancerState {
     loadBalancerCommand: IAmazonClassicLoadBalancerUpsertCommand;
     taskMonitor: TaskMonitor;
 }
-export declare class CreateClassicLoadBalancer extends React.Component<ICreateClassicLoadBalancerProps, ICreateClassicLoadBalancerState> {
+export declare class CreateClassicLoadBalancerComponent extends React.Component<ICreateClassicLoadBalancerProps & IRouterInjectedProps, ICreateClassicLoadBalancerState> {
     static defaultProps: Partial<ICreateClassicLoadBalancerProps>;
     private _isUnmounted;
-    private refreshUnsubscribe;
+    private refreshUnsubscribe?;
     private certificateTypes;
-    static show(props: ICreateClassicLoadBalancerProps): Promise<IAmazonClassicLoadBalancerUpsertCommand>;
-    constructor(props: ICreateClassicLoadBalancerProps);
+    static show(props: ICreateClassicLoadBalancerProps, runtimeServices: DeckRuntimeServices): Promise<IAmazonClassicLoadBalancerUpsertCommand>;
+    constructor(props: ICreateClassicLoadBalancerProps & IRouterInjectedProps);
     protected certificateIdAsARN(accountId: string, certificateId: string, region: string, certificateType: string): string;
-    protected formatListeners(command: IAmazonClassicLoadBalancerUpsertCommand): PromiseLike<void>;
+    protected formatListeners(command: IAmazonClassicLoadBalancerUpsertCommand): Promise<void>;
     private clearSecurityGroupsIfNotInVpc;
     private addHealthCheckToCommand;
     setAvailabilityZones(loadBalancerCommand: IAmazonClassicLoadBalancerUpsertCommand): void;
@@ -29,5 +29,10 @@ export declare class CreateClassicLoadBalancer extends React.Component<ICreateCl
     private onTaskComplete;
     private submit;
     private validate;
-    render(): React.ReactElement<CreateClassicLoadBalancer>;
+    render(): React.ReactElement<CreateClassicLoadBalancerComponent>;
 }
+export declare const CreateClassicLoadBalancer: React.ForwardRefExoticComponent<Omit<ICreateClassicLoadBalancerProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof CreateClassicLoadBalancerComponent.show;
+};

package/dist/loadBalancer/configure/common/SecurityGroups.d.ts

@@ -1,6 +1,7 @@
 import type { FormikErrors, FormikProps } from 'formik';
 import React from 'react';
 import type { IWizardPageComponent } from '@spinnaker/core';
+import { DeckRuntimeContext } from '@spinnaker/core';
 import type { IAmazonLoadBalancerUpsertCommand } from '../../../domain';
 export interface ISecurityGroupsProps {
     formik: FormikProps<IAmazonLoadBalancerUpsertCommand>;
@@ -19,10 +20,13 @@ export interface ISecurityGroupsState {
     refreshTime: number;
 }
 export declare class SecurityGroups extends React.Component<ISecurityGroupsProps, ISecurityGroupsState> implements IWizardPageComponent<IAmazonLoadBalancerUpsertCommand> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
     private destroy$;
     private props$;
     private refresh$;
     constructor(props: ISecurityGroupsProps);
+    private getRefreshTime;
     validate(): FormikErrors<IAmazonLoadBalancerUpsertCommand>;
     private clearRemoved;
     private updateRemovedSecurityGroups;

package/dist/loadBalancer/configure/network/CreateNetworkLoadBalancer.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { DeckRuntimeServices, ILoadBalancerModalProps, IRouterInjectedProps } from '@spinnaker/core';
 import { TaskMonitor } from '@spinnaker/core';
 import type { IAmazonNetworkLoadBalancer, IAmazonNetworkLoadBalancerUpsertCommand } from '../../../domain';
 import '../common/configure.less';
@@ -11,13 +11,13 @@ export interface ICreateApplicationLoadBalancerState {
     loadBalancerCommand: IAmazonNetworkLoadBalancerUpsertCommand;
     taskMonitor: TaskMonitor;
 }
-export declare class CreateNetworkLoadBalancer extends React.Component<ICreateNetworkLoadBalancerProps, ICreateApplicationLoadBalancerState> {
+export declare class CreateNetworkLoadBalancerComponent extends React.Component<ICreateNetworkLoadBalancerProps & IRouterInjectedProps, ICreateApplicationLoadBalancerState> {
     static defaultProps: Partial<ICreateNetworkLoadBalancerProps>;
     private _isUnmounted;
-    private refreshUnsubscribe;
+    private refreshUnsubscribe?;
     private certificateTypes;
-    static show(props: ICreateNetworkLoadBalancerProps): Promise<IAmazonNetworkLoadBalancerUpsertCommand>;
-    constructor(props: ICreateNetworkLoadBalancerProps);
+    static show(props: ICreateNetworkLoadBalancerProps, runtimeServices: DeckRuntimeServices): Promise<IAmazonNetworkLoadBalancerUpsertCommand>;
+    constructor(props: ICreateNetworkLoadBalancerProps & IRouterInjectedProps);
     protected certificateIdAsARN(accountId: string, certificateId: string, region: string, certificateType: string): string;
     private formatListeners;
     private setAvailabilityZones;
@@ -32,3 +32,8 @@ export declare class CreateNetworkLoadBalancer extends React.Component<ICreateNe
     private validate;
     render(): React.ReactElement<ICreateNetworkLoadBalancerProps>;
 }
+export declare const CreateNetworkLoadBalancer: React.ForwardRefExoticComponent<Omit<ICreateNetworkLoadBalancerProps & IRouterInjectedProps, keyof IRouterInjectedProps> & {
+    children?: React.ReactNode;
+} & React.RefAttributes<any>> & {
+    show: typeof CreateNetworkLoadBalancerComponent.show;
+};

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

@@ -1,16 +1,23 @@
 import React from 'react';
 import type { Application } from '@spinnaker/core';
+import { DeckRuntimeContext } from '@spinnaker/core';
 import type { IAmazonLoadBalancer } from '../../domain';
-import type { ILoadBalancerFromStateParams } from './loadBalancerDetails.controller';
+export interface ILoadBalancerFromStateParams {
+    accountId: string;
+    region: string;
+    name: string;
+}
 export interface ILoadBalancerActionsProps {
     app: Application;
     loadBalancer: IAmazonLoadBalancer;
-    loadBalancerFromParams: ILoadBalancerFromStateParams;
+    loadBalancerFromParams?: ILoadBalancerFromStateParams;
 }
 export interface ILoadBalancerActionsState {
     application: Application;
 }
 export declare class LoadBalancerActions extends React.Component<ILoadBalancerActionsProps, ILoadBalancerActionsState> {
+    static contextType: React.Context<import("@spinnaker/core").DeckRuntimeContextValue>;
+    context: React.ContextType<typeof DeckRuntimeContext>;
     constructor(props: ILoadBalancerActionsProps);
     editLoadBalancer: () => void;
     deleteLoadBalancer: () => void;

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

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import type { Application, ILoadBalancer, ILoadBalancerActionsProps, ILoadBalancerDetailsSectionProps, IUseDetailsHookProps, SecurityGroupReader, UseDetailsResult } from '@spinnaker/core';
+import type { IAmazonLoadBalancer } from '../../domain';
+type ILoadBalancerStateParams = IUseDetailsHookProps['loadBalancerParams'];
+interface ILoadAmazonLoadBalancerDetailsProps {
+    app: Application;
+    autoClose: () => void;
+    loadBalancerParams: ILoadBalancerStateParams;
+    loadBalancers?: ILoadBalancer[];
+    securityGroupReader?: SecurityGroupReader;
+}
+export declare function loadAmazonLoadBalancerDetails({ app, autoClose, loadBalancerParams, loadBalancers, securityGroupReader, }: ILoadAmazonLoadBalancerDetailsProps): Promise<IAmazonLoadBalancer | undefined>;
+export declare function useAmazonLoadBalancerDetails({ app, loadBalancerParams, autoClose, }: IUseDetailsHookProps): UseDetailsResult<ILoadBalancer>;
+export declare function AmazonLoadBalancerActions({ app, loadBalancer }: ILoadBalancerActionsProps): JSX.Element;
+export declare function AmazonLoadBalancerDetailsSection({ app, loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AmazonLoadBalancerStatusSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AmazonLoadBalancerListenersSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AmazonLoadBalancerFirewallsSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AmazonLoadBalancerSubnetsSection({ loadBalancer }: ILoadBalancerDetailsSectionProps): JSX.Element;
+export declare function AmazonLoadBalancerHealthChecksSection({ loadBalancer, }: ILoadBalancerDetailsSectionProps): JSX.Element | null;
+export declare const amazonLoadBalancerDetailsSections: (typeof AmazonLoadBalancerDetailsSection)[];
+export {};

package/dist/loadBalancer/index.d.ts

@@ -7,3 +7,4 @@ export * from './TargetGroupDetails';
 export * from './configure/common/AmazonCertificateSelectField';
 export * from './configure/AmazonLoadBalancerChoiceModal';
 export * from './configure/LoadBalancerTypes';
+export * from './details/amazonLoadBalancerDetails';

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

@@ -7,7 +7,7 @@ export declare class AwsLoadBalancerTransformer {
     private normalizeServerGroups;
     private normalizeTargetGroup;
     private normalizeActions;
-    normalizeLoadBalancer(loadBalancer: IAmazonLoadBalancer): PromiseLike<IAmazonLoadBalancer>;
+    normalizeLoadBalancer(loadBalancer: IAmazonLoadBalancer): Promise<IAmazonLoadBalancer>;
     static convertClassicLoadBalancerForEditing(loadBalancer: IAmazonClassicLoadBalancer): IAmazonClassicLoadBalancerUpsertCommand;
     static convertApplicationLoadBalancerForEditing(loadBalancer: IAmazonApplicationLoadBalancer): IAmazonApplicationLoadBalancerUpsertCommand;
     static convertNetworkLoadBalancerForEditing(loadBalancer: IAmazonApplicationLoadBalancer): IAmazonNetworkLoadBalancerUpsertCommand;

package/dist/pipeline/stages/AmazonStageConfig.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { IStage, IStageConfigProps } from '@spinnaker/core';
+type AmazonStageFieldType = 'account' | 'onlyEnabled' | 'regions' | 'selectionStrategy' | 'target' | 'text';
+export interface IAmazonStageField {
+    fieldName: string;
+    label: string;
+    type?: AmazonStageFieldType;
+}
+export declare function getAmazonStageFields(stage: Partial<IStage>): IAmazonStageField[];
+export declare function AmazonStageConfig({ application, stage, updateStageField }: IStageConfigProps): JSX.Element;
+export {};

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

@@ -0,0 +1,66 @@
+import React from 'react';
+import type { IExecutionDetailsSectionProps, IStageConfigProps } from '@spinnaker/core';
+import { BakeExecutionLabel } from '@spinnaker/core';
+interface IBaseOsOption {
+    id: string;
+    detailedDescription?: string;
+    shortDescription?: string;
+    displayName?: string;
+    vmTypes?: string[];
+}
+interface IAwsBakeStageState {
+    baseLabelOptions: string[];
+    baseOsOptions: IBaseOsOption[];
+    extendedAttributeKey: string;
+    extendedAttributeValue: string;
+    loading: boolean;
+    loadError: boolean;
+    regions: string[];
+    roscoMode: boolean;
+    showAdvancedOptions: boolean;
+    vmTypes: string[];
+}
+export declare class AwsBakeStageConfig extends React.Component<IStageConfigProps, IAwsBakeStageState> {
+    private mounted;
+    state: IAwsBakeStageState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private initialize;
+    private applyDefaults;
+    private computeVmTypes;
+    private showAdvanced;
+    private replaceStage;
+    private updateStage;
+    private updateExtendedAttribute;
+    private removeExtendedAttribute;
+    private addExtendedAttribute;
+    private renderDockerPreview;
+    render(): JSX.Element;
+}
+export declare function AwsBakeExecutionDetails({ current, execution, name, stage }: IExecutionDetailsSectionProps): JSX.Element;
+export declare const awsBakeStage: {
+    key: string;
+    provides: string;
+    cloudProvider: string;
+    label: string;
+    description: string;
+    component: typeof AwsBakeStageConfig;
+    executionDetailsSections: any[];
+    executionLabelComponent: typeof BakeExecutionLabel;
+    extraLabelLines: (stage: any) => 0 | 1;
+    supportsCustomTimeout: boolean;
+    validators: ({
+        type: string;
+        fieldName: string;
+        checkParentTriggers?: undefined;
+        getMessage?: undefined;
+    } | {
+        type: string;
+        checkParentTriggers: boolean;
+        getMessage: (labels: string[]) => string;
+        fieldName?: undefined;
+    })[];
+    restartable: boolean;
+};
+export declare function registerAwsBakeStage(): void;
+export {};

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

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import type { IStageConfigProps } from '@spinnaker/core';
+export declare function AwsCloneServerGroupStageConfig(props: IStageConfigProps): JSX.Element;
+export declare const awsCloneServerGroupStage: {
+    key: string;
+    provides: string;
+    cloudProvider: string;
+    component: typeof AwsCloneServerGroupStageConfig;
+    accountExtractor: (stage: any) => any[];
+    validators: ({
+        type: string;
+        fieldName: string;
+        fieldLabel: string;
+    } | {
+        type: string;
+        fieldName: string;
+        fieldLabel?: undefined;
+    })[];
+};
+export declare function registerAwsCloneServerGroupStage(): void;

package/dist/pipeline/stages/deleteLambda/index.d.ts

@@ -1,2 +1,2 @@
 export * from './LambdaDeleteStage';
-export declare const AMAZON_PIPELINE_STAGES_LAMBDA_DELETE = "spinnaker.amazon.pipeline.stage.Aws.LambdaDeleteStage";
+export declare function registerLambdaDeleteStage(): void;

package/dist/pipeline/stages/deployCloudFormation/CloudFormationChangeSetInfo.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="react" />
-import type { IStage, IStageConfigProps } from '@spinnaker/core';
+import type { IStage } from '@spinnaker/core';
 export interface ICloudFormationChangeSetInfoProps {
-    stage: IStage[];
-    stageconfig: IStageConfigProps;
+    stage: IStage;
+    updateStageField: (changes: {
+        [key: string]: any;
+    }) => void;
 }
 export declare const CloudFormationChangeSetInfo: (props: ICloudFormationChangeSetInfoProps) => JSX.Element;
-export declare const CLOUD_FORMATION_CHANGE_SET_INFO = "spinnaker.amazon.cloudformation.changetset.info.component";

package/dist/pipeline/stages/deployCloudFormation/DeployCloudFormationStackStageConfig.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { IStageConfigProps } from '@spinnaker/core';
+export declare function DeployCloudFormationStackStageConfig({ application, pipeline, stage, updateStageField, }: IStageConfigProps): JSX.Element;

package/dist/pipeline/stages/deployCloudFormation/deployCloudFormationStackStage.d.ts

@@ -1 +1 @@
-export declare const DEPLOY_CLOUDFORMATION_STACK_STAGE = "spinnaker.amazon.pipeline.stages.deployCloudFormationStage";
+export declare function registerDeployCloudFormationStackStage(): void;

package/dist/pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service.d.ts

@@ -3,8 +3,6 @@ import type { IExecution, IExecutionStage } from '@spinnaker/core';
 import type { Application } from '@spinnaker/core';
 export declare class EvaluateCloudFormationChangeSetExecutionService {
     private executionService;
-    static $inject: string[];
     constructor(executionService: ExecutionService);
-    evaluateExecution(application: Application, execution: IExecution, stage: IExecutionStage, changeSetExecutionChoice: string): PromiseLike<void>;
+    evaluateExecution(application: Application, execution: IExecution, stage: IExecutionStage, changeSetExecutionChoice: string): Promise<void>;
 }
-export declare const AWS_EVALUATE_CLOUD_FORMATION_CHANGE_SET_EXECUTION_SERVICE = "spinnaker.amazon.deployCloudFormation.service";

package/dist/pipeline/stages/deployLambda/index.d.ts

@@ -1,2 +1,2 @@
 export * from './config/LambdaDeploymentStage';
-export declare const AMAZON_PIPELINE_STAGES_LAMBDA_DEPLOY = "spinnaker.amazon.pipeline.stage.Aws.LambdaDeploymentStage";
+export declare function registerLambdaDeployStage(): void;

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

@@ -1,2 +1,26 @@
-export const AMAZON_PIPELINE_STAGES_DESTROYASG_AWSDESTROYASGSTAGE: "spinnaker.amazon.pipeline.stage.aws.destroyAsgStage";
-export const name: "spinnaker.amazon.pipeline.stage.aws.destroyAsgStage";
+export function registerAwsDestroyAsgStage(): void;
+export namespace awsDestroyAsgStage {
+    export const provides: string;
+    export const alias: string;
+    export const cloudProvider: string;
+    export { AmazonStageConfig as component };
+    export function accountExtractor(stage: any): any[];
+    export function configAccountExtractor(stage: any): any[];
+    export const validators: ({
+        type: string;
+        message: string;
+        fieldName?: undefined;
+        fieldLabel?: undefined;
+    } | {
+        type: string;
+        fieldName: string;
+        message?: undefined;
+        fieldLabel?: undefined;
+    } | {
+        type: string;
+        fieldName: string;
+        fieldLabel: string;
+        message?: undefined;
+    })[];
+}
+import { AmazonStageConfig } from '../AmazonStageConfig';