@spinnaker/amazon 0.0.0-2025.1-0

package/dist/aws.module.d.ts

@@ -0,0 +1,5 @@
+import './deploymentStrategy/rollingPush.strategy';
+import './help/amazon.help';
+import './validation/ApplicationNameValidator';
+import './logo/aws.logo.less';
+export declare const AMAZON_MODULE = "spinnaker.amazon";

package/dist/aws.settings.d.ts

@@ -0,0 +1,59 @@
+import type { IProviderSettings } from '@spinnaker/core';
+export interface IClassicLaunchAllowlist {
+    region: string;
+    credentials: string;
+}
+export interface IAWSProviderSettings extends IProviderSettings {
+    adHocInfraWritesEnabled?: boolean;
+    bakeWarning?: string;
+    classicLaunchLockout?: number;
+    classicLaunchAllowlist?: IClassicLaunchAllowlist[];
+    createLoadBalancerWarnings?: {
+        application?: string;
+        classic?: string;
+        network?: string;
+    };
+    crossAccountIngressExclusions?: {
+        [credentials: string]: string | string[];
+    };
+    securityGroupExclusions?: string[];
+    defaults: {
+        account?: string;
+        iamRole?: string;
+        region?: string;
+        subnetType?: string;
+        vpc?: string;
+    };
+    defaultSecurityGroups?: string[];
+    disableSpotPricing?: boolean;
+    dockerBakeryDeprecated?: boolean;
+    dockerBakeWarning?: string;
+    instanceTypes?: {
+        exclude?: {
+            categories?: string[];
+            families?: string[];
+        };
+    };
+    loadBalancers?: {
+        certificateTypes?: string[];
+        disableManualOidcDialog?: boolean;
+        inferInternalFlagFromSubnet: boolean;
+    };
+    metrics?: {
+        customNamespaces?: string[];
+    };
+    minRootVolumeSize?: number;
+    serverGroups?: {
+        enableLaunchTemplates?: boolean;
+        enableIPv6?: boolean;
+        setIPv6InTest?: boolean;
+        enableIMDSv2?: boolean;
+        defaultIMDSv2AppAgeLimit?: number;
+        accountDenyListIMDSv2?: string[];
+        enableCpuCredits?: boolean;
+        recommendedSubnets?: string[];
+        subnetWarning?: string;
+    };
+    useAmiBlockDeviceMappings?: boolean;
+}
+export declare const AWSProviderSettings: IAWSProviderSettings;

package/dist/aws.validators.d.ts

@@ -0,0 +1,7 @@
+export declare const iamRoleValidator: (value: string, label: string) => string;
+export declare const s3BucketNameValidator: (value: string, label: string) => string;
+export declare const awsArnValidator: (value: string, label: string) => string;
+export declare const awsTagsValidator: (value: string | {
+    [key: string]: string;
+}, label: string) => string;
+export declare const simpleStringValidator: (value: string, label: string) => string;

package/dist/certificates/AmazonCertificateReader.d.ts

@@ -0,0 +1,6 @@
+import type { IAmazonCertificate } from '../domain';
+export declare class AmazonCertificateReader {
+    static listCertificates(): PromiseLike<{
+        [accountId: string]: IAmazonCertificate[];
+    }>;
+}

package/dist/certificates/index.d.ts

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

package/dist/common/AwsModalFooter.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+export interface IAwsModalFooterProps {
+    account: string;
+    isValid?: boolean;
+    onCancel: () => void;
+    onSubmit: () => void;
+}
+export interface IAwsModalFooterState {
+    verified: boolean;
+    requireVerification: boolean;
+}
+export declare class AwsModalFooter extends React.Component<IAwsModalFooterProps, IAwsModalFooterState> {
+    static defaultProps: Partial<IAwsModalFooterProps>;
+    state: {
+        verified: boolean;
+        requireVerification: boolean;
+    };
+    componentDidMount(): void;
+    private handleVerification;
+    render(): JSX.Element;
+}

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

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

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

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

package/dist/common/index.d.ts

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

package/dist/deploymentStrategy/AdditionalFields.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { IDeploymentStrategyAdditionalFieldsProps } from '@spinnaker/core';
+import type { IRollingPushCommand } from './rollingPush.strategy';
+export interface IRollingPushStrategyAdditionalFieldsProps extends IDeploymentStrategyAdditionalFieldsProps {
+    command: IRollingPushCommand;
+}
+export declare class AdditionalFields extends React.Component<IRollingPushStrategyAdditionalFieldsProps> {
+    private handleChange;
+    render(): JSX.Element;
+}

package/dist/deploymentStrategy/rollingPush.strategy.d.ts

@@ -0,0 +1,10 @@
+import type { IServerGroupCommand } from '@spinnaker/core';
+export interface IRollingPushTermination {
+    concurrentRelaunches: number;
+    relaunchAllInstances: boolean;
+    totalRelaunches: number;
+    [key: string]: any;
+}
+export interface IRollingPushCommand extends IServerGroupCommand {
+    termination: IRollingPushTermination;
+}

package/dist/domain/IAmazonBlockDeviceMapping.d.ts

@@ -0,0 +1,15 @@
+export interface IEbsBlockDevice {
+    deleteOnTermination?: boolean;
+    encrypted?: boolean;
+    iops?: number;
+    kmsKeyId?: string;
+    snapshotId?: string;
+    volumeSize?: number;
+    volumeType?: string;
+}
+export interface IBlockDeviceMapping {
+    deviceName?: string;
+    ebs?: IEbsBlockDevice;
+    noDevice?: string;
+    virtualName?: string;
+}

package/dist/domain/IAmazonCertificate.d.ts

@@ -0,0 +1,5 @@
+import type { ICertificate } from '@spinnaker/core';
+export interface IAmazonCertificate extends ICertificate {
+    arn: string;
+    uploadDate: number;
+}

package/dist/domain/IAmazonFunction.d.ts

@@ -0,0 +1,65 @@
+import type { IFunction, IFunctionDeleteCommand, IFunctionUpsertCommand } from '@spinnaker/core';
+export interface IAmazonFunction extends IFunction {
+    credentials?: string;
+    role?: string;
+    runtime: string;
+    s3bucket: string;
+    s3key: string;
+    handler: string;
+    functionName: string;
+    publish: boolean;
+    description: string;
+    tags: string | {
+        [key: string]: string;
+    };
+    memorySize: number;
+    timeout: number;
+    envVariables: {};
+    environment: {
+        variables: {};
+    };
+    tracingConfig: {
+        mode: string;
+    };
+    deadLetterConfig: {
+        targetArn: string;
+    };
+    kmskeyArn: string;
+    vpcConfig: {
+        securityGroupIds: [];
+        subnetIds: [];
+        vpcId: string;
+    };
+    targetGroups: string | string[];
+}
+export interface IAmazonFunctionUpsertCommand extends IFunctionUpsertCommand {
+    role?: string;
+    runtime: string;
+    s3bucket: string;
+    s3key: string;
+    handler: string;
+    tags: string | {
+        [key: string]: string;
+    };
+    memorySize: number;
+    timeout: number;
+    envVariables: {};
+    publish: boolean;
+    tracingConfig: {
+        mode: string;
+    };
+    deadLetterConfig: {
+        targetArn: string;
+    };
+    kmskeyArn: string;
+    securityGroupIds: string[];
+    subnetIds: string[];
+    vpcId: string;
+    targetGroups: string | string[];
+}
+export interface IAmazonFunctionDeleteCommand extends IFunctionDeleteCommand {
+    cloudProvider: string;
+    functionName: string;
+    region: string;
+    credentials: string;
+}

package/dist/domain/IAmazonFunctionSourceData.d.ts

@@ -0,0 +1,46 @@
+import type { IFunctionSourceData } from '@spinnaker/core';
+export interface IAmazonFunctionSourceData extends IFunctionSourceData {
+    account: string;
+    cloudProvider: string;
+    createdTime: number;
+    functionName: string;
+    runtime: string;
+    region: string;
+    publish: boolean;
+    description: string;
+    eventSourceMappings: string[];
+    aliasConfigurations: string[];
+    functionArn: string;
+    handler: string;
+    layers: string;
+    lastModified: number;
+    type: string;
+    memorySize: number;
+    revisionId: string;
+    revisions: {};
+    role: string;
+    timeout: number;
+    tracingConfig: {
+        mode: string;
+    };
+    version: string;
+    envVariables: {};
+    environment: {
+        variables: {};
+    };
+    vpcConfig: {
+        subnetIds: [];
+        securityGroupIds: [];
+        vpcId: '';
+    };
+    s3bucket: string;
+    s3key: string;
+    tags: string | {
+        [key: string]: string;
+    };
+    deadLetterConfig: {
+        targetArn: string;
+    };
+    kmskeyArn: string;
+    targetGroups: string[];
+}

package/dist/domain/IAmazonHealth.d.ts

@@ -0,0 +1,11 @@
+import type { IHealth, ILoadBalancerHealth } from '@spinnaker/core';
+export interface IAmazonHealth extends IHealth {
+    targetGroups: IAmazonTargetGroupHealth[];
+}
+export interface IAmazonTargetGroupHealth extends ILoadBalancerHealth {
+    targetGroupName: string;
+    name: never;
+    healthCheckProtocol?: string;
+    healthCheckPath?: string;
+    instanceId?: string;
+}

package/dist/domain/IAmazonInstance.d.ts

@@ -0,0 +1,24 @@
+import type { IInstance } from '@spinnaker/core';
+import type { IAmazonSecurityGroup } from './IAmazonSecurityGroup';
+interface IInstancePlacement {
+    containerIp: string;
+    host: string;
+    region: string;
+    zone: string;
+}
+export interface IAmazonInstance extends IInstance {
+    imageId?: string;
+    instancePort?: string;
+    instanceType?: string;
+    capacityType?: string;
+    permanentIps?: string[];
+    placement: IInstancePlacement;
+    privateDnsName?: string;
+    privateIpAddress?: string;
+    publicDnsName?: string;
+    publicIpAddress?: string;
+    securityGroups?: IAmazonSecurityGroup[];
+    subnetId?: string;
+    targetGroups?: string[];
+}
+export {};

package/dist/domain/IAmazonLaunchTemplate.d.ts

@@ -0,0 +1,91 @@
+import type { IBlockDeviceMapping } from './IAmazonBlockDeviceMapping';
+export interface IIamInstanceProfile {
+    arn?: string;
+    name: string;
+}
+export interface ICpuOptions {
+    coreCount?: number;
+    threadsPerCore?: number;
+}
+export interface IElasticGpuSpecification {
+    type?: string;
+}
+export interface IElasticInterfaceAccelerator {
+    count?: number;
+    type?: string;
+}
+export interface ISpotMarketOptions {
+    blockDurationMinutes?: number;
+    instanceInterruptionBehavior?: string;
+    maxPrice?: string;
+    spotInstanceType?: 'one-time' | 'persistent';
+    validUntil?: string;
+}
+export interface IInstanceMarketOptions {
+    marketType?: string;
+    spotOptions?: ISpotMarketOptions;
+}
+export interface ILicenseConfig {
+    licenseConfigurationArn?: string;
+}
+export interface IMetadataOptions {
+    httpEndpoint?: 'disabled' | 'enabled';
+    httpPutResponseHopLimit?: number;
+    httpTokens?: 'required' | 'optional';
+    state?: 'pending' | 'applied';
+}
+export interface INetworkInterface {
+    deviceIndex: number;
+    groups: string[];
+    ipv6AddressCount?: number;
+    associatePublicIpAddress?: boolean;
+    ipv6Addresses?: string[];
+}
+export interface ITagSpecification {
+    resourceType?: string;
+    tagSet?: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+export interface ICreditSpecification {
+    cpuCredits?: string;
+}
+export interface ILaunchTemplateData {
+    [attribute: string]: any;
+    blockDeviceMappings?: IBlockDeviceMapping[];
+    cpuOptions?: ICpuOptions;
+    creditSpecification?: ICreditSpecification;
+    disableApiTermination?: boolean;
+    ebsOptimized: boolean;
+    elasticGpuSpecifications?: IElasticGpuSpecification[];
+    elasticInferenceAccelerators?: IElasticInterfaceAccelerator[];
+    iamInstanceProfile: IIamInstanceProfile;
+    imageId: string;
+    instanceInitiatedShutdownBehavior?: 'stop' | 'terminate';
+    instanceMarketOptions?: IInstanceMarketOptions;
+    instanceType: string;
+    kernelId?: string;
+    keyName: string;
+    licenseSpecifications?: ILicenseConfig[];
+    metadataOptions: IMetadataOptions;
+    monitoring: {
+        enabled: boolean;
+    };
+    networkInterfaces?: INetworkInterface[];
+    ramDiskId?: string;
+    securityGroupIds: string[];
+    securityGroups: string[];
+    tagSpecifications?: ITagSpecification[];
+    userData?: string;
+}
+export interface IAmazonLaunchTemplate {
+    createdBy: string;
+    createdTime: number;
+    defaultVersion: boolean;
+    launchTemplateData: ILaunchTemplateData;
+    launchTemplateId: string;
+    launchTemplateName: string;
+    versionDescription?: string;
+    versionNumber: number;
+}

package/dist/domain/IAmazonLoadBalancer.d.ts

@@ -0,0 +1,230 @@
+import type { IInstance, IInstanceCounts, ILoadBalancer, ILoadBalancerDeleteCommand, ILoadBalancerUpsertCommand, ISubnet } from '@spinnaker/core';
+import type { IAmazonLoadBalancerSourceData } from './IAmazonLoadBalancerSourceData';
+import type { IAmazonServerGroup } from './IAmazonServerGroup';
+import type { IAuthenticateOidcActionConfig } from '../loadBalancer/OidcConfigReader';
+export type ClassicListenerProtocol = 'HTTP' | 'HTTPS' | 'TCP' | 'SSL';
+export type ALBListenerProtocol = 'HTTP' | 'HTTPS';
+export type IListenerActionType = 'forward' | 'authenticate-oidc' | 'redirect';
+export type NLBListenerProtocol = 'TCP' | 'TLS' | 'UDP';
+export interface IAmazonLoadBalancer extends ILoadBalancer {
+    availabilityZones?: string[];
+    credentials?: string;
+    detachedInstances?: IInstance[];
+    elb?: IAmazonLoadBalancerSourceData;
+    isInternal?: boolean;
+    regionZones: string[];
+    serverGroups: IAmazonServerGroup[];
+    subnets?: string[];
+    subnetDetails?: ISubnet[];
+    subnetType?: string;
+}
+export interface IClassicListener {
+    internalProtocol: ClassicListenerProtocol;
+    internalPort: number;
+    externalProtocol: ClassicListenerProtocol;
+    externalPort: number;
+    sslCertificateType?: string;
+}
+export interface IAmazonClassicLoadBalancer extends IAmazonLoadBalancer {
+    healthCheckPath: string;
+    healthCheckPort: number;
+    healthCheckProtocol: string;
+    healthTimeout: number;
+    healthInterval: number;
+    healthyThreshold: number;
+    listeners: IClassicListener[];
+    unhealthyThreshold: number;
+    idleTimeout?: number;
+}
+export interface IAmazonApplicationLoadBalancer extends IAmazonLoadBalancer {
+    listeners: IALBListener[];
+    targetGroups: ITargetGroup[];
+    ipAddressType?: string;
+    deletionProtection: boolean;
+    idleTimeout: number;
+    loadBalancingCrossZone: boolean;
+}
+export interface IAmazonNetworkLoadBalancer extends IAmazonLoadBalancer {
+    listeners: INLBListener[];
+    targetGroups: ITargetGroup[];
+    ipAddressType?: string;
+    deletionProtection: boolean;
+    idleTimeout: number;
+    loadBalancingCrossZone: boolean;
+}
+export interface IRedirectActionConfig {
+    host?: string;
+    path?: string;
+    port?: string;
+    protocol?: 'HTTP' | 'HTTPS' | '#{protocol}';
+    query?: string;
+    statusCode: 'HTTP_301' | 'HTTP_302';
+}
+export interface IListenerAction {
+    authenticateOidcConfig?: IAuthenticateOidcActionConfig;
+    order?: number;
+    redirectActionConfig?: IRedirectActionConfig;
+    redirectConfig?: IRedirectActionConfig;
+    targetGroupName?: string;
+    type: IListenerActionType;
+}
+export interface IALBListenerCertificate {
+    certificateArn: string;
+    type: string;
+    name: string;
+}
+export interface IALBListener {
+    certificates: IALBListenerCertificate[];
+    defaultActions: IListenerAction[];
+    port: number;
+    protocol: string;
+    rules: IListenerRule[];
+    sslPolicy?: string;
+}
+export interface INLBListener {
+    certificates: IALBListenerCertificate[];
+    defaultActions: IListenerAction[];
+    port: number;
+    protocol: string;
+    rules: IListenerRule[];
+    sslPolicy?: string;
+}
+export interface IListenerRule {
+    actions: IListenerAction[];
+    default?: boolean;
+    conditions: IListenerRuleCondition[];
+    priority: number | 'default';
+}
+export type ListenerRuleConditionField = 'path-pattern' | 'host-header' | 'http-request-method';
+export interface IListenerRuleCondition {
+    field: ListenerRuleConditionField;
+    httpRequestMethodConfig?: {
+        values: string[];
+    };
+    values: string[];
+}
+export interface ITargetGroupAttributes {
+    deregistrationDelay: number;
+    stickinessEnabled: boolean;
+    stickinessType: string;
+    stickinessDuration: number;
+}
+export interface ITargetGroup {
+    account: string;
+    attributes?: ITargetGroupAttributes;
+    cloudProvider: string;
+    detachedInstances?: IInstance[];
+    healthCheckProtocol: string;
+    healthCheckPort: number | 'traffic-port';
+    healthCheckPath: string;
+    healthTimeout: number;
+    healthInterval: number;
+    healthyThreshold: number;
+    unhealthyThreshold: number;
+    instanceCounts?: IInstanceCounts;
+    instances?: IInstance[];
+    loadBalancerNames: string[];
+    name: string;
+    port: number;
+    protocol: string;
+    provider?: string;
+    region: string;
+    serverGroups?: IAmazonServerGroup[];
+    targetType?: string;
+    type: string;
+    vpcId?: string;
+    vpcName?: string;
+}
+export interface IListenerDescription {
+    certificates?: IALBListenerCertificate[];
+    protocol: ALBListenerProtocol | NLBListenerProtocol;
+    port: number;
+    sslPolicy?: string;
+    defaultActions: IListenerAction[];
+    rules?: IListenerRule[];
+}
+export interface IALBTargetGroupDescription {
+    name: string;
+    protocol: 'HTTP' | 'HTTPS' | 'TCP' | 'TLS';
+    port: number;
+    targetType: 'instance' | 'ip' | 'lambda';
+    attributes: {
+        deregistrationDelay?: number;
+        stickinessEnabled?: boolean;
+        stickinessType?: 'lb_cookie';
+        stickinessDuration?: number;
+        multiValueHeadersEnabled?: boolean;
+    };
+    healthCheckInterval?: number;
+    healthCheckMatcher?: string;
+    healthCheckPath: string;
+    healthCheckPort: string;
+    healthCheckProtocol: 'HTTP' | 'HTTPS' | 'TCP';
+    healthyThreshold?: number;
+    healthCheckTimeout?: number;
+    unhealthyThreshold?: number;
+}
+export interface INLBTargetGroupDescription {
+    name: string;
+    protocol: 'TCP';
+    port: number;
+    targetType: 'instance' | 'ip';
+    attributes: {
+        deregistrationDelay?: number;
+        deregistrationDelayConnectionTermination?: boolean;
+        preserveClientIp?: boolean;
+    };
+    healthCheckInterval?: number;
+    healthCheckPort: string;
+    healthCheckProtocol: 'TCP' | 'HTTP' | 'HTTPS';
+    healthCheckPath: string;
+    healthyThreshold?: number;
+    healthCheckTimeout?: number;
+    unhealthyThreshold?: number;
+}
+export interface IAmazonLoadBalancerUpsertCommand extends ILoadBalancerUpsertCommand {
+    availabilityZones: {
+        [region: string]: string[];
+    };
+    isInternal: boolean;
+    listeners: any[];
+    loadBalancerType?: 'classic' | 'application' | 'network';
+    regionZones: string[];
+    securityGroups: string[];
+    subnetType: string;
+    usePreferredZones?: boolean;
+    vpcId: string;
+}
+export interface IAmazonLoadBalancerDeleteCommand extends ILoadBalancerDeleteCommand {
+    loadBalancerType: string;
+}
+export interface IClassicListenerDescription extends IClassicListener {
+    sslCertificateId?: string;
+    sslCertificateName?: string;
+    policyNames?: string[];
+}
+export interface IAmazonClassicLoadBalancerUpsertCommand extends IAmazonLoadBalancerUpsertCommand {
+    healthCheck: string;
+    healthCheckPath: string;
+    healthCheckProtocol: string;
+    healthCheckPort: number;
+    healthInterval?: number;
+    healthTimeout?: number;
+    healthyThreshold?: number;
+    listeners: IClassicListenerDescription[];
+    unhealthyThreshold?: number;
+    idleTimeout?: number;
+}
+export interface IAmazonApplicationLoadBalancerUpsertCommand extends IAmazonLoadBalancerUpsertCommand {
+    deletionProtection: boolean;
+    ipAddressType?: string;
+    idleTimeout: number;
+    listeners: IListenerDescription[];
+    targetGroups: IALBTargetGroupDescription[];
+}
+export interface IAmazonNetworkLoadBalancerUpsertCommand extends IAmazonLoadBalancerUpsertCommand {
+    deletionProtection: boolean;
+    loadBalancingCrossZone: boolean;
+    listeners: IListenerDescription[];
+    targetGroups: INLBTargetGroupDescription[];
+}