@spinnaker/amazon 0.0.0-2025.1-0

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

@@ -0,0 +1,15 @@
+import type { Application, IMultiInstanceGroup, IMultiInstanceJob, ITask } from '@spinnaker/core';
+import { InstanceWriter } from '@spinnaker/core';
+import type { IAmazonInstance } from '../domain';
+export interface IAmazonMultiInstanceGroup extends IMultiInstanceGroup {
+    targetGroups: string[];
+}
+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>;
+}

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

@@ -0,0 +1,50 @@
+import type { IInstanceType, IInstanceTypeCategory, IInstanceTypesByRegion, IPreferredInstanceType } from '@spinnaker/core';
+export interface IAmazonPreferredInstanceType extends IPreferredInstanceType {
+    cpuCreditsPerHour?: number;
+}
+export interface IAmazonInstanceTypeCategory extends IInstanceTypeCategory {
+    showCpuCredits?: boolean;
+    descriptionListOverride?: string[];
+}
+export interface IAmazonInstanceType extends IInstanceType {
+    defaultVCpus: number;
+    memoryInGiB: number;
+    hypervisor: string;
+    instanceStorageInfo?: IAmazonInstanceTypeStorageInfo;
+    ebsInfo?: IAmazonInstanceTypeEbsInfo;
+    gpuInfo?: IAmazonInstanceGpuInfo;
+    instanceStorageSupported: boolean;
+    currentGeneration: boolean;
+    bareMetal: boolean;
+    ipv6Supported?: boolean;
+    burstablePerformanceSupported: boolean;
+    supportedArchitectures: string[];
+    supportedUsageClasses: string[];
+    supportedRootDeviceTypes: string[];
+    supportedVirtualizationTypes: string[];
+}
+export interface IAmazonInstanceTypeStorageInfo {
+    storageTypes: string;
+    totalSizeInGB?: number;
+    nvmeSupport?: string;
+}
+export interface IAmazonInstanceTypeEbsInfo {
+    ebsOptimizedSupport: string;
+    nvmeSupport?: string;
+    encryptionSupport: string;
+}
+export interface IAmazonInstanceGpuInfo {
+    totalGpuMemoryInMiB: number;
+    gpus: IAmazonInstanceGpuDeviceInfo[];
+}
+export interface IAmazonInstanceGpuDeviceInfo {
+    name: string;
+    manufacturer: string;
+    count: number;
+    gpuSizeInMiB: number;
+}
+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";

package/dist/instance/awsInstanceTypes.d.ts

@@ -0,0 +1,10 @@
+import type { IInstanceTypeCategory, IInstanceTypeFamily } from '@spinnaker/core';
+interface IAwsInstanceTypeCategory extends IInstanceTypeCategory {
+    showCpuCredits?: boolean;
+    descriptionListOverride?: string[];
+}
+export declare const defaultCategories: IAwsInstanceTypeCategory[];
+export declare const categories: (IAwsInstanceTypeCategory & {
+    families: IInstanceTypeFamily[];
+})[];
+export {};

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { IAmazonInstance } from '../../domain';
+export interface IAmazonInstanceInformationProps {
+    instance: IAmazonInstance;
+}
+export declare const AmazonInstanceInformation: ({ instance }: IAmazonInstanceInformationProps) => JSX.Element;

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export interface ICostFactorProps {
+    min: number;
+    max?: number;
+}
+export declare const CostFactor: ({ min, max }: ICostFactorProps) => JSX.Element;

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+interface IIpv6Address {
+    ip: string;
+    url: string;
+}
+export interface IInstanceDnsProps {
+    instancePort: string;
+    ipv6Addresses: IIpv6Address[];
+    permanentIps: string[];
+    privateDnsName: string;
+    privateIpAddress: string;
+    publicDnsName: string;
+    publicIpAddress: string;
+}
+export declare const InstanceDns: ({ instancePort, ipv6Addresses, permanentIps, privateDnsName, privateIpAddress, publicDnsName, publicIpAddress, }: IInstanceDnsProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+export interface IInstanceInformationProps {
+    account: string;
+    availabilityZone: string;
+    instanceType: string;
+    capacityType?: string;
+    launchTime: number;
+    provider: string;
+    region: string;
+    serverGroup: string;
+    showInstanceType?: boolean;
+}
+export declare const InstanceInformation: ({ account, availabilityZone, instanceType, capacityType, launchTime, provider, region, serverGroup, showInstanceType, }: IInstanceInformationProps) => JSX.Element;

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

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import type { IAmazonInstance } from '../../domain';
+export interface IInstanceSecurityGroupsProps {
+    instance: IAmazonInstance;
+}
+export declare const InstanceSecurityGroups: ({ instance }: IInstanceSecurityGroupsProps) => JSX.Element;

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

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import type { IAmazonHealth } from '../../domain';
+export type MetricTypes = 'LoadBalancer' | 'TargetGroup';
+export interface CustomHealthLink {
+    type: string;
+    href: string;
+    text: string;
+}
+export interface IInstanceStatusProps {
+    healthMetrics: IAmazonHealth[];
+    healthState: string;
+    metricTypes: MetricTypes[];
+    customHealthUrl?: CustomHealthLink;
+    privateIpAddress?: string;
+}
+export declare const InstanceStatus: ({ healthMetrics, healthState, metricTypes, customHealthUrl, privateIpAddress, }: IInstanceStatusProps) => JSX.Element;

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export interface IInstanceTagsProps {
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export declare const InstanceTags: ({ tags }: IInstanceTagsProps) => JSX.Element;

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { IAmazonApplicationLoadBalancer, IAmazonHealth, IAmazonNetworkLoadBalancer, ITargetGroup } from '../../domain';
+export declare const getAllTargetGroups: (loadBalancers: IAmazonApplicationLoadBalancer[] | IAmazonNetworkLoadBalancer[]) => ITargetGroup[];
+export declare const applyHealthCheckInfoToTargetGroups: (healthMetrics: IAmazonHealth[], targetGroups: ITargetGroup[], account: string) => void;

package/dist/instance/index.d.ts

@@ -0,0 +1,5 @@
+export * from './details/utils';
+export * from './details/InstanceDns';
+export * from './details/InstanceInformation';
+export * from './details/InstanceStatus';
+export * from './amazon.instance.write.service';

package/dist/keyPairs/KeyPairsReader.d.ts

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

package/dist/keyPairs/index.d.ts

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

package/dist/loadBalancer/AmazonLoadBalancerClusterContainer.d.ts

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

package/dist/loadBalancer/AmazonLoadBalancersTag.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { ILoadBalancer, ILoadBalancersTagProps } 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> {
+    private loadBalancersRefreshUnsubscribe;
+    private mounted;
+    constructor(props: ILoadBalancersTagProps);
+    private showLoadBalancerDetails;
+    private showTargetGroupDetails;
+    private handleShowPopover;
+    private handleClick;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): React.ReactElement<AmazonLoadBalancersTag>;
+}

package/dist/loadBalancer/OidcConfigReader.d.ts

@@ -0,0 +1,16 @@
+export interface IAuthenticateOidcActionConfig {
+    authorizationEndpoint: string;
+    authenticationRequestExtraParams?: any;
+    clientId: string;
+    clientSecret?: string;
+    idpLogoutUrl?: string;
+    issuer: string;
+    scope: string;
+    sessionCookieName: string;
+    sessionTimeout?: number;
+    tokenEndpoint: string;
+    userInfoEndpoint: string;
+}
+export declare class OidcConfigReader {
+    static getOidcConfigsByApp(app: string): PromiseLike<IAuthenticateOidcActionConfig[]>;
+}

package/dist/loadBalancer/TargetGroup.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { IAmazonApplicationLoadBalancer, ITargetGroup } from '../domain/IAmazonLoadBalancer';
+import './targetGroup.less';
+export interface ITargetGroupProps {
+    loadBalancer: IAmazonApplicationLoadBalancer;
+    targetGroup: ITargetGroup;
+    showServerGroups: boolean;
+    showInstances: boolean;
+}
+export declare class TargetGroup extends React.Component<ITargetGroupProps> {
+    render(): React.ReactElement<TargetGroup>;
+}

package/dist/loadBalancer/TargetGroupDetails.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { IOverridableProps } from '@spinnaker/core';
+export interface ITargetGroupDetailsProps extends IOverridableProps {
+}
+export declare class TargetGroupDetails extends React.Component<ITargetGroupDetailsProps> {
+    render(): JSX.Element;
+}

package/dist/loadBalancer/amazonLoadBalancerDataUtils.d.ts

@@ -0,0 +1,6 @@
+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[]>;
+}

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ILoadBalancerModalProps } 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 defaultProps: Partial<ILoadBalancerModalProps>;
+    static show(props: ILoadBalancerModalProps): Promise<void>;
+    constructor(props: ILoadBalancerModalProps);
+    choiceSelected(choice: IAmazonLoadBalancerConfig): void;
+    private choose;
+    close: (reason?: any) => void;
+    private getIncompatibility;
+    private isIncompatibleWithAllProviders;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,14 @@
+/// <reference types="react" />
+import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import type { IAmazonLoadBalancerUpsertCommand } from '../../domain';
+export interface ICloseableLoadBalancerModal extends React.ComponentClass<ILoadBalancerModalProps> {
+    show: (props: ILoadBalancerModalProps) => Promise<IAmazonLoadBalancerUpsertCommand>;
+}
+export interface IAmazonLoadBalancerConfig {
+    type: 'network' | 'application' | 'classic';
+    label: string;
+    sublabel: string;
+    description: string;
+    component: ICloseableLoadBalancerModal;
+}
+export declare const LoadBalancerTypes: IAmazonLoadBalancerConfig[];

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ALBAdvancedSettings: React.ForwardRefExoticComponent<React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,59 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { Application, IWizardPageComponent } from '@spinnaker/core';
+import type { IAuthenticateOidcActionConfig } from '../../OidcConfigReader';
+import type { IAmazonApplicationLoadBalancerUpsertCommand, IAmazonCertificate, IListenerDescription } from '../../../domain';
+export interface IALBListenersState {
+    certificates: {
+        [accountId: number]: IAmazonCertificate[];
+    };
+    certificateTypes: string[];
+    oidcConfigs: IAuthenticateOidcActionConfig[];
+}
+export interface IALBListenersProps {
+    app: Application;
+    formik: FormikProps<IAmazonApplicationLoadBalancerUpsertCommand>;
+}
+export declare class ALBListeners extends React.Component<IALBListenersProps, IALBListenersState> implements IWizardPageComponent<IAmazonApplicationLoadBalancerUpsertCommand> {
+    protocols: string[];
+    private initialActionsWithAuth;
+    private initialListenersWithDefaultAuth;
+    private removedAuthActions;
+    constructor(props: IALBListenersProps);
+    private getAllTargetGroupsFromListeners;
+    validate(values: IAmazonApplicationLoadBalancerUpsertCommand): FormikErrors<IAmazonApplicationLoadBalancerUpsertCommand>;
+    componentDidMount(): void;
+    private loadCertificates;
+    private attachClientSecret;
+    private loadOidcClients;
+    private updateListeners;
+    private needsCert;
+    private showCertificateSelect;
+    private addListenerCertificate;
+    private removeAuthActions;
+    private reenableAuthActions;
+    private listenerProtocolChanged;
+    private listenerPortChanged;
+    private certificateTypeChanged;
+    private handleCertificateChanged;
+    private removeListener;
+    private addListener;
+    private addRule;
+    removeRule: (listener: IListenerDescription, index: number) => void;
+    private handleConditionFieldChanged;
+    private handleConditionValueChanged;
+    private handleHttpRequestMethodChanged;
+    private addCondition;
+    private removeCondition;
+    private handleRuleActionTargetChanged;
+    private handleRuleActionTypeChanged;
+    private handleSortEnd;
+    private configureOidcClient;
+    private configureRedirect;
+    private removeAuthActionInternal;
+    private removeAuthAction;
+    private authenticateRuleToggle;
+    private oidcConfigChanged;
+    private redirectConfigChanged;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { IAuthenticateOidcActionConfig } from '../../OidcConfigReader';
+import './ConfigureConfigModal.css';
+export interface IConfigureOidcConfigModalProps {
+    config: IAuthenticateOidcActionConfig;
+    closeModal?(result?: any): void;
+    dismissModal?(rejection?: any): void;
+}
+export interface IConfigureOidcConfigModalState {
+    initialValues: IAuthenticateOidcActionConfig;
+}
+export declare class ConfigureOidcConfigModal extends React.Component<IConfigureOidcConfigModalProps, IConfigureOidcConfigModalState> {
+    static defaultProps: Partial<IConfigureOidcConfigModalProps>;
+    static show(props: IConfigureOidcConfigModalProps): Promise<void>;
+    constructor(props: IConfigureOidcConfigModalProps);
+    private close;
+    private submit;
+    private validate;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { IRedirectActionConfig } from '../../../domain';
+import './ConfigureConfigModal.css';
+export interface IConfigureRedirectConfigModalProps {
+    config: IRedirectActionConfig;
+    closeModal?(result?: any): void;
+    dismissModal?(rejection?: any): void;
+}
+export declare class ConfigureRedirectConfigModal extends React.Component<IConfigureRedirectConfigModalProps> {
+    private initialValues;
+    static defaultProps: Partial<IConfigureRedirectConfigModalProps>;
+    static show(props: IConfigureRedirectConfigModalProps): Promise<void>;
+    constructor(props: IConfigureRedirectConfigModalProps);
+    private close;
+    private submit;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAmazonApplicationLoadBalancer, IAmazonApplicationLoadBalancerUpsertCommand } from '../../../domain';
+import '../common/configure.less';
+export interface ICreateApplicationLoadBalancerProps extends ILoadBalancerModalProps {
+    loadBalancer: IAmazonApplicationLoadBalancer;
+}
+export interface ICreateApplicationLoadBalancerState {
+    includeSecurityGroups: boolean;
+    isNew: boolean;
+    loadBalancerCommand: IAmazonApplicationLoadBalancerUpsertCommand;
+    taskMonitor: TaskMonitor;
+}
+export declare class CreateApplicationLoadBalancer extends React.Component<ICreateApplicationLoadBalancerProps, ICreateApplicationLoadBalancerState> {
+    static defaultProps: Partial<ICreateApplicationLoadBalancerProps>;
+    private _isUnmounted;
+    private refreshUnsubscribe;
+    private certificateTypes;
+    static show(props: ICreateApplicationLoadBalancerProps): Promise<IAmazonApplicationLoadBalancerUpsertCommand>;
+    constructor(props: ICreateApplicationLoadBalancerProps);
+    protected certificateIdAsARN(accountId: string, certificateId: string, region: string, certificateType: string): string;
+    private formatListeners;
+    private setAvailabilityZones;
+    private addAppName;
+    private manageTargetGroupNames;
+    private manageRules;
+    private setIpAddressType;
+    private formatCommand;
+    protected onApplicationRefresh(values: IAmazonApplicationLoadBalancerUpsertCommand): void;
+    componentWillUnmount(): void;
+    private onTaskComplete;
+    private submit;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,33 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { Application, IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonApplicationLoadBalancer, IAmazonApplicationLoadBalancerUpsertCommand } from '../../../domain';
+export interface ITargetGroupsProps {
+    app: Application;
+    formik: FormikProps<IAmazonApplicationLoadBalancerUpsertCommand>;
+    isNew: boolean;
+    loadBalancer: IAmazonApplicationLoadBalancer;
+}
+export interface ITargetGroupsState {
+    existingTargetGroupNames: {
+        [account: string]: {
+            [region: string]: string[];
+        };
+    };
+    oldTargetGroupCount: number;
+}
+export declare class TargetGroups extends React.Component<ITargetGroupsProps, ITargetGroupsState> implements IWizardPageComponent<IAmazonApplicationLoadBalancerUpsertCommand> {
+    protocols: string[];
+    targetTypes: string[];
+    private destroy$;
+    constructor(props: ITargetGroupsProps);
+    validate(values: IAmazonApplicationLoadBalancerUpsertCommand): FormikErrors<IAmazonApplicationLoadBalancerUpsertCommand>;
+    private removeAppName;
+    protected updateLoadBalancerNames(props: ITargetGroupsProps): void;
+    private targetGroupFieldChanged;
+    private addTargetGroup;
+    private removeTargetGroup;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,10 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { IAmazonClassicLoadBalancerUpsertCommand } from '../../../domain';
+import './AdvancedSettings.css';
+export interface IAdvancedSettingsProps {
+    formik: FormikProps<IAmazonClassicLoadBalancerUpsertCommand>;
+}
+export declare class AdvancedSettings extends React.Component<IAdvancedSettingsProps> {
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAmazonClassicLoadBalancer, IAmazonClassicLoadBalancerUpsertCommand } from '../../../domain';
+import '../common/configure.less';
+export interface ICreateClassicLoadBalancerProps extends ILoadBalancerModalProps {
+    loadBalancer: IAmazonClassicLoadBalancer;
+}
+export interface ICreateClassicLoadBalancerState {
+    isNew: boolean;
+    loadBalancerCommand: IAmazonClassicLoadBalancerUpsertCommand;
+    taskMonitor: TaskMonitor;
+}
+export declare class CreateClassicLoadBalancer extends React.Component<ICreateClassicLoadBalancerProps, ICreateClassicLoadBalancerState> {
+    static defaultProps: Partial<ICreateClassicLoadBalancerProps>;
+    private _isUnmounted;
+    private refreshUnsubscribe;
+    private certificateTypes;
+    static show(props: ICreateClassicLoadBalancerProps): Promise<IAmazonClassicLoadBalancerUpsertCommand>;
+    constructor(props: ICreateClassicLoadBalancerProps);
+    protected certificateIdAsARN(accountId: string, certificateId: string, region: string, certificateType: string): string;
+    protected formatListeners(command: IAmazonClassicLoadBalancerUpsertCommand): PromiseLike<void>;
+    private clearSecurityGroupsIfNotInVpc;
+    private addHealthCheckToCommand;
+    setAvailabilityZones(loadBalancerCommand: IAmazonClassicLoadBalancerUpsertCommand): void;
+    protected formatCommand(command: IAmazonClassicLoadBalancerUpsertCommand): void;
+    protected onApplicationRefresh(values: IAmazonClassicLoadBalancerUpsertCommand): void;
+    componentWillUnmount(): void;
+    private onTaskComplete;
+    private submit;
+    private validate;
+    render(): React.ReactElement<CreateClassicLoadBalancer>;
+}

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

@@ -0,0 +1,11 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { IAmazonClassicLoadBalancerUpsertCommand } from '../../../domain';
+export interface IHealthCheckProps {
+    formik: FormikProps<IAmazonClassicLoadBalancerUpsertCommand>;
+}
+export declare class HealthCheck extends React.Component<IHealthCheckProps> {
+    requiresHealthCheckPath(): boolean;
+    private healthCheckPathChanged;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,34 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { Application } from '@spinnaker/core';
+import type { IAmazonCertificate, IAmazonClassicLoadBalancerUpsertCommand } from '../../../domain';
+import './Listeners.less';
+export interface IListenersProps {
+    formik: FormikProps<IAmazonClassicLoadBalancerUpsertCommand>;
+    app: Application;
+}
+export interface IListenersState {
+    certificates: {
+        [accountId: number]: IAmazonCertificate[];
+    };
+}
+export declare class Listeners extends React.Component<IListenersProps, IListenersState> {
+    protocols: string[];
+    secureProtocols: string[];
+    private certificateTypes;
+    state: IListenersState;
+    componentDidMount(): void;
+    private loadCertificates;
+    private updateListeners;
+    private showCertificateSelect;
+    private listenerExternalProtocolChanged;
+    private listenerInternalProtocolChanged;
+    private listenerExternalPortChanged;
+    private listenerInternalPortChanged;
+    private listenerCertificateTypeChanged;
+    private handleListenerCertificateChanged;
+    private removeListener;
+    private addListener;
+    private renderCertificateSelector;
+    render(): JSX.Element;
+}

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { Application } from '@spinnaker/core';
+import type { IAmazonCertificate } from '../../../domain';
+export interface IAmazonCertificateSelectFieldProps {
+    certificates: {
+        [accountName: string]: IAmazonCertificate[];
+    };
+    accountName: string;
+    currentValue: string;
+    onCertificateSelect: (certificateName: string) => void;
+    app: Application;
+}
+export declare class AmazonCertificateSelectField extends React.Component<IAmazonCertificateSelectFieldProps> {
+    render(): JSX.Element;
+}