@spinnaker/amazon 0.0.0-2025.1-0

package/dist/domain/IAmazonLoadBalancerSourceData.d.ts

@@ -0,0 +1,170 @@
+import type { ILoadBalancerSourceData } from '@spinnaker/core';
+import type { IListenerAction, NLBListenerProtocol } from './IAmazonLoadBalancer';
+import type { IListenerRule } from './IAmazonLoadBalancer';
+export interface IAmazonContainerServerGroupSourceData {
+    detachedInstances: string[];
+    isDisabled: boolean;
+    name: string;
+    region: string;
+}
+export interface IAmazonLoadBalancerServerGroupSourceData extends IAmazonContainerServerGroupSourceData {
+    instances: IAmazonLoadBalancerInstanceSourceData[];
+}
+export interface IAmazonTargetGroupServerGroupSourceData extends IAmazonContainerServerGroupSourceData {
+    instances: IAmazonTargetGroupInstanceSourceData[];
+}
+export interface IAmazonInstanceHealthSourceData {
+    type: string;
+    state: 'InService' | 'OutOfService' | 'Unknown';
+    reasonCode: 'ELB' | 'Instance' | 'N/A';
+    description: string;
+}
+export interface IAmazonTargetHealthSourceData {
+    description: string;
+    reason: string;
+    state: 'initial' | 'healthy' | 'unhealthy' | 'unused' | 'draining';
+}
+export interface IClassicListenerSourceData {
+    instancePort: number;
+    instanceProtocol: string;
+    loadBalancerPort: number;
+    protocol: string;
+}
+export interface IAmazonLoadBalancerSourceData extends ILoadBalancerSourceData {
+    account: string;
+    availabilityZones: string[];
+    cloudProvider: string;
+    createdTime: number;
+    dnsname: string;
+    loadBalancerName: string;
+    loadBalancerType?: string;
+    name: string;
+    region: string;
+    scheme: 'internal' | 'internet-facing';
+    securityGroups: string[];
+    serverGroups: IAmazonLoadBalancerServerGroupSourceData[];
+    subnets: string[];
+    type: string;
+    vpcId: string;
+    vpcid?: string;
+}
+export interface IAmazonLoadBalancerInstanceSourceData {
+    id: string;
+    zone: string;
+    health: IAmazonInstanceHealthSourceData;
+}
+export interface IAmazonTargetGroupInstanceSourceData {
+    id: string;
+    zone: string;
+    health: IAmazonTargetHealthSourceData;
+}
+export interface IAmazonTargetGroupSourceData {
+    account: string;
+    attributes: {
+        'deregistration_delay.timeout_seconds': number;
+        'stickiness.enabled': boolean;
+        'stickiness.lb_cookie.duration_seconds': number;
+        'stickiness.type': 'lb_cookie';
+        'lambda.multi_value_headers.enabled': boolean;
+    };
+    cloudProvider: string;
+    healthCheckIntervalSeconds: number;
+    healthCheckPath: string;
+    healthCheckPort: string;
+    healthCheckProtocol: string;
+    healthCheckTimeoutSeconds: number;
+    healthyThresholdCount: number;
+    instances: string[];
+    loadBalancerNames: string[];
+    matcher: {
+        httpCode: string;
+    };
+    name: string;
+    port: number;
+    protocol: string;
+    region: string;
+    serverGroups: IAmazonTargetGroupServerGroupSourceData[];
+    targetGroupArn: string;
+    targetGroupName: string;
+    targetType: string;
+    type: string;
+    unhealthyThresholdCount: number;
+    vpcId: string;
+}
+export interface IApplicationLoadBalancerCertificateSourceData {
+    certificateArn: string;
+}
+export interface IApplicationLoadBalancerListenerSourceData {
+    certificates?: IApplicationLoadBalancerCertificateSourceData[];
+    defaultActions: IListenerAction[];
+    listenerArn: string;
+    loadBalancerName: string;
+    port: number;
+    protocol: 'HTTP' | 'HTTPS';
+    rules: IListenerRule[];
+    sslPolicy?: string;
+}
+export interface IApplicationLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+    ipAddressType: 'ipv4' | 'dualstack';
+    listeners: IApplicationLoadBalancerListenerSourceData[];
+    loadBalancerArn: string;
+    loadBalancerType: 'application';
+    state: {
+        code: 'active' | 'provisioning' | 'failed';
+        reason?: string;
+    };
+    targetGroups: IAmazonTargetGroupSourceData[];
+}
+export interface INetworkLoadBalancerListenerSourceData {
+    certificates?: IApplicationLoadBalancerCertificateSourceData[];
+    defaultActions: Array<{
+        targetGroupName: string;
+        type: 'forward';
+    }>;
+    listenerArn: string;
+    loadBalancerName: string;
+    port: number;
+    protocol: NLBListenerProtocol;
+    rules: IListenerRule[];
+    sslPolicy?: string;
+}
+export interface INetworkLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+    ipAddressType: 'ipv4' | 'dualstack';
+    listeners: INetworkLoadBalancerListenerSourceData[];
+    loadBalancerArn: string;
+    loadBalancerType: 'network';
+    state: {
+        code: 'active' | 'provisioning' | 'failed';
+        reason?: string;
+    };
+    targetGroups: IAmazonTargetGroupSourceData[];
+}
+export interface IClassicLoadBalancerSourceData extends IAmazonLoadBalancerSourceData {
+    healthCheck: {
+        healthyThreshold: number;
+        interval: number;
+        target: string;
+        timeout: number;
+        unhealthyThreshold: number;
+    };
+    instances: string[];
+    listenerDescriptions: Array<{
+        listener: IClassicListenerSourceData;
+        policyNames: string[];
+    }>;
+    policies: {
+        appCookieStickinessPolicies: Array<{
+            CookieName: string;
+            PolicyName: string;
+        }>;
+        lbcookieStickinessPolicies: Array<{
+            CookieExpirationPeriod: string;
+            PolicyName: string;
+        }>;
+        otherPolicies: any[];
+    };
+    sourceSecurityGroup: {
+        groupName: string;
+        ownerAlias: string;
+    };
+}

package/dist/domain/IAmazonScalingPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { IScalingPolicy, IScalingPolicyAlarm, IStepAdjustment } from './IScalingPolicy';
+import type { ITargetTrackingConfiguration } from './ITargetTrackingPolicy';
+export interface IScalingAdjustmentView extends IStepAdjustment {
+    operator: string;
+    absAdjustment: number;
+}
+export interface IScalingPolicyAlarmView extends IScalingPolicyAlarm {
+    name?: string;
+    description?: string;
+    disableEditingDimensions?: boolean;
+    comparator?: '<' | '>' | '≤' | '≥';
+}
+export interface IScalingPolicyView extends IScalingPolicy, IScalingAdjustmentView {
+    alarms: IScalingPolicyAlarmView[];
+    stepAdjustments: IStepAdjustmentView[];
+    operator: string;
+    targetTrackingConfiguration?: ITargetTrackingConfiguration;
+}
+export interface IStepAdjustmentView extends IScalingAdjustmentView, IStepAdjustment {
+    metricIntervalLowerBound: number;
+    metricIntervalUpperBound: number;
+}

package/dist/domain/IAmazonSecurityGroup.d.ts

@@ -0,0 +1,4 @@
+export interface IAmazonSecurityGroup {
+    groupId: string;
+    groupName: string;
+}

package/dist/domain/IAmazonServerGroup.d.ts

@@ -0,0 +1,67 @@
+import type { IAccountDetails, IAsg, IServerGroup } from '@spinnaker/core';
+import type { IAmazonLaunchTemplate } from './IAmazonLaunchTemplate';
+import type { IScalingPolicyView } from './IAmazonScalingPolicy';
+import type { IScalingPolicy } from './IScalingPolicy';
+import type { ISuspendedProcess } from './IScalingProcess';
+export interface IAmazonAsgTag {
+    key: string;
+    value: string;
+    propagateAtLaunch: boolean;
+    resourceId: string;
+    resourceType: string;
+}
+export interface IAmazonAsg extends IAsg {
+    availabilityZones: string[];
+    autoScalingGroupName: string;
+    defaultCooldown: number;
+    healthCheckType: string;
+    healthCheckGracePeriod: number;
+    loadBalancerNames: string[];
+    terminationPolicies: string[];
+    enabledMetrics: Array<{
+        metric: string;
+    }>;
+    vpczoneIdentifier?: string;
+    suspendedProcesses?: ISuspendedProcess[];
+    capacityRebalance?: boolean;
+    tags: IAmazonAsgTag[];
+}
+export interface IAmazonServerGroup extends IServerGroup {
+    image?: any;
+    scalingPolicies?: IScalingPolicy[];
+    targetGroups?: string[];
+    asg: IAmazonAsg;
+    awsAccount?: string;
+    launchTemplate?: IAmazonLaunchTemplate;
+    mixedInstancesPolicy?: IAmazonMixedInstancesPolicy;
+}
+export interface IScheduledAction {
+    recurrence: number;
+    minSize: number;
+    maxSize: number;
+    desiredCapacity: number;
+}
+export interface IAmazonMixedInstancesPolicy {
+    allowedInstanceTypes: string[];
+    instancesDistribution: IAmazonInstancesDistribution;
+    launchTemplates: IAmazonLaunchTemplate[];
+    launchTemplateOverridesForInstanceType: IAmazonLaunchTemplateOverrides[];
+}
+export interface IAmazonInstancesDistribution {
+    onDemandAllocationStrategy: string;
+    onDemandBaseCapacity: number;
+    onDemandPercentageAboveBaseCapacity: number;
+    spotAllocationStrategy: string;
+    spotInstancePools?: number;
+    spotMaxPrice: string;
+}
+export interface IAmazonLaunchTemplateOverrides {
+    instanceType: string;
+    weightedCapacity?: string;
+    priority?: number;
+}
+export interface IAmazonServerGroupView extends IAmazonServerGroup {
+    accountDetails?: IAccountDetails;
+    scalingPolicies: IScalingPolicyView[];
+    scheduledActions?: IScheduledAction[];
+}

package/dist/domain/IKeyPair.d.ts

@@ -0,0 +1,6 @@
+export interface IKeyPair {
+    account: string;
+    region: string;
+    keyName: string;
+    keyFingerprint: string;
+}

package/dist/domain/IScalingPolicy.d.ts

@@ -0,0 +1,44 @@
+import type { IMetricAlarmDimension } from '@spinnaker/core';
+export interface IScalingPolicyAlarm {
+    alarmName?: string;
+    alarmArn?: string;
+    alarmActionArns?: string[];
+    metricName: string;
+    namespace: string;
+    statistic: AlarmStatisticType;
+    dimensions: IMetricAlarmDimension[];
+    period: number;
+    threshold: number;
+    comparisonOperator: AlarmComparisonOperator;
+    okactions?: string[];
+    insufficientDataActions?: string[];
+    alarmActions?: string[];
+    evaluationPeriods?: number;
+    alarmDescription?: string;
+    unit?: StandardUnitType;
+}
+export type ScalingPolicyAdjustmentType = 'ChangeInCapacity' | 'ExactCapacity' | 'PercentChangeInCapacity';
+export type MetricAggregationType = 'Minimum' | 'Maximum' | 'Average';
+export type AlarmComparisonOperator = 'GreaterThanOrEqualToThreshold' | 'GreaterThanThreshold' | 'LessThanThreshold' | 'LessThanOrEqualToThreshold';
+export type AlarmStatisticType = 'SampleCount' | 'Average' | 'Sum' | 'Minimum' | 'Maximum';
+export type StandardUnitType = 'Seconds' | 'Microseconds' | 'Milliseconds' | 'Bytes' | 'Kilobytes' | 'Megabytes' | 'Gigabytes' | 'Terabytes' | 'Bits' | 'Kilobits' | 'Megabits' | 'Gigabits' | 'Terabits' | 'Percent' | 'Count' | 'BytesSecond' | 'KilobytesSecond' | 'MegabytesSecond' | 'GigabytesSecond' | 'TerabytesSecond' | 'BitsSecond' | 'KilobitsSecond' | 'MegabitsSecond' | 'GigabitsSecond' | 'TerabitsSecond' | 'CountSecond' | 'None';
+export interface IStepAdjustment {
+    metricIntervalLowerBound?: number;
+    metricIntervalUpperBound?: number;
+    scalingAdjustment?: number;
+}
+export interface IScalingPolicy {
+    policyARN?: string;
+    policyName?: string;
+    policyType?: string;
+    id?: string;
+    adjustmentType?: ScalingPolicyAdjustmentType;
+    alarms: IScalingPolicyAlarm[];
+    stepAdjustments?: IStepAdjustment[];
+    metricAggregationType?: MetricAggregationType;
+    estimatedInstanceWarmup?: number;
+    minAdjustmentStep?: number;
+    cooldown?: number;
+    minAdjustmentMagnitude?: number;
+    scalingAdjustment?: number;
+}

package/dist/domain/IScalingProcess.d.ts

@@ -0,0 +1,10 @@
+export interface IScalingProcess {
+    name: string;
+    enabled?: boolean;
+    description: string;
+    suspensionDate?: number;
+}
+export interface ISuspendedProcess {
+    processName: string;
+    suspensionReason: string;
+}

package/dist/domain/ITargetTrackingPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { AlarmStatisticType, IScalingPolicy } from './IScalingPolicy';
+export interface ITargetTrackingPolicy extends IScalingPolicy {
+    autoScalingGroupName?: string;
+    targetTrackingConfiguration: ITargetTrackingConfiguration;
+}
+export interface ITargetTrackingConfiguration {
+    customizedMetricSpecification?: ICustomizedMetricSpecification;
+    predefinedMetricSpecification?: IPredefinedMetricSpecification;
+    disableScaleIn?: boolean;
+    targetValue: number;
+}
+export interface ICustomizedMetricSpecification {
+    metricName: string;
+    namespace: string;
+    dimensions: any[];
+    statistic: AlarmStatisticType;
+}
+export interface IPredefinedMetricSpecification {
+    predefinedMetricType: PredefinedMetricType;
+    resourceLabel?: string;
+}
+export type PredefinedMetricType = 'ASGAverageCPUUtilization' | 'ASGAverageNetworkIn' | 'ASGAverageNetworkOut' | 'ALBRequestCountPerTarget';

package/dist/domain/index.d.ts

@@ -0,0 +1,15 @@
+export * from './IAmazonBlockDeviceMapping';
+export * from './IAmazonCertificate';
+export * from './IAmazonInstance';
+export * from './IAmazonLaunchTemplate';
+export * from './IAmazonLoadBalancer';
+export * from './IAmazonFunction';
+export * from './IAmazonLoadBalancerSourceData';
+export * from './IAmazonFunctionSourceData';
+export * from './IAmazonHealth';
+export * from './IAmazonScalingPolicy';
+export * from './IAmazonServerGroup';
+export * from './IKeyPair';
+export * from './IScalingPolicy';
+export * from './IScalingProcess';
+export * from './ITargetTrackingPolicy';

package/dist/function/CreateLambdaFunction.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { IFunctionModalProps } from '@spinnaker/core';
+import { TaskMonitor } from '@spinnaker/core';
+import type { IAmazonFunction, IAmazonFunctionUpsertCommand } from '../domain';
+export interface IAmazonCreateFunctionProps extends IFunctionModalProps {
+    functionDef: IAmazonFunction;
+}
+export interface IAmazonCreateFunctionState {
+    isNew: boolean;
+    functionCommand: IAmazonFunctionUpsertCommand;
+    taskMonitor: TaskMonitor;
+}
+export declare class CreateLambdaFunction extends React.Component<IAmazonCreateFunctionProps, IAmazonCreateFunctionState> {
+    static defaultProps: Partial<IAmazonCreateFunctionProps>;
+    constructor(props: IAmazonCreateFunctionProps);
+    private _isUnmounted;
+    private refreshUnsubscribe;
+    static show(props: IAmazonCreateFunctionProps): Promise<IAmazonFunctionUpsertCommand>;
+    componentWillUnmount(): void;
+    protected onApplicationRefresh(values: IAmazonFunctionUpsertCommand): void;
+    private onTaskComplete;
+    private checkForS3Update;
+    private submit;
+    render(): JSX.Element;
+}

package/dist/function/configure/ExecutionRole.d.ts

@@ -0,0 +1,15 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IExecutionRoleProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export declare class ExecutionRole extends React.Component<IExecutionRoleProps> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    constructor(props: IExecutionRoleProps);
+    validate(values: IAmazonFunctionUpsertCommand): FormikErrors<IAmazonFunctionUpsertCommand>;
+    render(): JSX.Element;
+}

package/dist/function/configure/FunctionBasicInformation.d.ts

@@ -0,0 +1,26 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { Application, IAccount, IRegion, IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IFunctionProps {
+    app: Application;
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export interface IFunctionState {
+    existingFunctionNames: string[];
+    accounts: IAccount[];
+    regions: IRegion[];
+}
+export declare class FunctionBasicInformation extends React.Component<IFunctionProps, IFunctionState> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    state: IFunctionState;
+    private props$;
+    private destroy$;
+    validate(values: IAmazonFunctionUpsertCommand): FormikErrors<IAmazonFunctionUpsertCommand>;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    render(): JSX.Element;
+}

package/dist/function/configure/FunctionDebugAndErrorHandling.d.ts

@@ -0,0 +1,15 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IFunctionDebugAndErrorHandlingProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export declare class FunctionDebugAndErrorHandling extends React.Component<IFunctionDebugAndErrorHandlingProps> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    constructor(props: IFunctionDebugAndErrorHandlingProps);
+    validate: (values: IAmazonFunctionUpsertCommand) => FormikErrors<IAmazonFunctionUpsertCommand>;
+    render(): JSX.Element;
+}

package/dist/function/configure/FunctionEnvironmentVariables.d.ts

@@ -0,0 +1,14 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IFunctionEnvironmentVariablesProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export declare class FunctionEnvironmentVariables extends React.Component<IFunctionEnvironmentVariablesProps> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    validate: (values: IAmazonFunctionUpsertCommand) => any;
+    render(): JSX.Element;
+}

package/dist/function/configure/FunctionSettings.d.ts

@@ -0,0 +1,14 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IFunctionSettingsProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export declare class FunctionSettings extends React.Component<IFunctionSettingsProps> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    validate: () => any;
+    render(): JSX.Element;
+}

package/dist/function/configure/FunctionTags.d.ts

@@ -0,0 +1,14 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunction } from '../../domain';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface IFunctionTagsProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    functionDef: IAmazonFunction;
+}
+export declare class FunctionTags extends React.Component<IFunctionTagsProps> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    validate: (values: IAmazonFunctionUpsertCommand) => any;
+    render(): JSX.Element;
+}

package/dist/function/configure/Network.d.ts

@@ -0,0 +1,42 @@
+import type { FormikErrors, FormikProps } from 'formik';
+import React from 'react';
+import type { Application, IAccount, IRegion, ISecurityGroupsByAccountSourceData, IWizardPageComponent } from '@spinnaker/core';
+import type { IAmazonFunctionUpsertCommand } from '../../index';
+export interface ISubnetOption {
+    subnetId: string;
+    vpcId: string;
+}
+export interface INetworkProps {
+    formik: FormikProps<IAmazonFunctionUpsertCommand>;
+    isNew?: boolean;
+    app: Application;
+}
+export interface INetworkState {
+    vpcOptions: Array<{}>;
+    accounts: IAccount[];
+    regions: IRegion[];
+    subnets: ISubnetOption[];
+    availableSubnets: ISubnetOption[];
+    securityGroups: ISecurityGroupsByAccountSourceData;
+}
+export declare class Network extends React.Component<INetworkProps, INetworkState> implements IWizardPageComponent<IAmazonFunctionUpsertCommand> {
+    constructor(props: INetworkProps);
+    state: INetworkState;
+    private props$;
+    private destroy$;
+    private getAllVpcs;
+    validate(): FormikErrors<IAmazonFunctionUpsertCommand>;
+    private getAvailableSubnets;
+    private getAvailableSecurityGroups;
+    private makeSubnetOptions;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    private handleSubnetUpdate;
+    private handleSecurityGroupsUpdate;
+    private setVpc;
+    private toSubnetOption;
+    private getSecurityGroupsByVpc;
+    private getSubnetOptions;
+    render(): JSX.Element;
+}

package/dist/function/details/AmazonFunctionDetails.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { Application, IFunction, IOverridableProps } from '@spinnaker/core';
+export interface IFunctionFromStateParams {
+    account: string;
+    region: string;
+    functionName: string;
+}
+export interface IAmazonFunctionDetailsProps extends IOverridableProps {
+    app: Application;
+    functionObj: IFunction;
+}
+export declare class AmazonFunctionDetails extends React.Component<IAmazonFunctionDetailsProps, any> {
+    private destroy$;
+    constructor(props: IAmazonFunctionDetailsProps);
+    extractFunction(): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}

package/dist/function/details/FunctionActions.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { Application } from '@spinnaker/core';
+import type { IFunctionFromStateParams } from './AmazonFunctionDetails';
+import type { IAmazonFunction } from '../../domain';
+export interface IFunctionActionsProps {
+    app: Application;
+    functionDef: IAmazonFunction;
+    functionFromParams: IFunctionFromStateParams;
+}
+export interface IFunctionActionsState {
+    application: Application;
+}
+export declare class FunctionActions extends React.Component<IFunctionActionsProps, IFunctionActionsState> {
+    constructor(props: IFunctionActionsProps);
+    componentDidMount(): void;
+    editFunction: () => void;
+    deleteFunction: () => void;
+    private entityTagUpdate;
+    render(): JSX.Element;
+}

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

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

package/dist/function/function.transformer.d.ts

@@ -0,0 +1,7 @@
+import type { Application } from '@spinnaker/core';
+import type { IAmazonFunction, IAmazonFunctionUpsertCommand } from '../domain';
+export declare class AwsFunctionTransformer {
+    normalizeFunction(functionDef: IAmazonFunction): IAmazonFunction;
+    convertFunctionForEditing: (functionDef: IAmazonFunction) => IAmazonFunctionUpsertCommand;
+    constructNewAwsFunctionTemplate(application: Application): IAmazonFunctionUpsertCommand;
+}

package/dist/function/index.d.ts

@@ -0,0 +1,5 @@
+export * from './function.transformer';
+export * from './CreateLambdaFunction';
+export * from './configure/FunctionBasicInformation';
+export * from './details/AmazonFunctionDetails';
+export * from './details/FunctionActions';

package/dist/help/amazon.help.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/image/image.reader.d.ts

@@ -0,0 +1,25 @@
+export interface IAmazonImage {
+    accounts: string[];
+    amis: {
+        [region: string]: string[];
+    };
+    attributes: {
+        architecture: string;
+        creationDate: string;
+        virtualizationType: string;
+    };
+    imageName: string;
+    tags: {
+        [tag: string]: string;
+    };
+    tagsByImageId: {
+        [imageId: string]: IAmazonImage['tags'];
+    };
+}
+export declare class AwsImageReader {
+    findImages(params: {
+        q: string;
+        region?: string;
+    }): PromiseLike<IAmazonImage[]>;
+    getImage(amiName: string, region: string, credentials: string): PromiseLike<IAmazonImage>;
+}

package/dist/image/index.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { AMAZON_MODULE } from './aws.module';
+export * from './aws.settings';
+export * from './certificates';
+export * from './common';
+export * from './domain';
+export * from './keyPairs';
+export * from './loadBalancer';
+export * from './function';
+export * from './reactShims';
+export * from './serverGroup';
+export * from './subnet';
+export * from './vpc';
+export * from './instance';
+export * from './securityGroup';