@aws-sdk/client-auto-scaling 3.934.0 → 3.935.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,427 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const AcceleratorManufacturer: {
+    readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+    readonly AMD: "amd";
+    readonly NVIDIA: "nvidia";
+    readonly XILINX: "xilinx";
+};
+/**
+ * @public
+ */
+export type AcceleratorManufacturer = (typeof AcceleratorManufacturer)[keyof typeof AcceleratorManufacturer];
+/**
+ * @public
+ * @enum
+ */
+export declare const AcceleratorName: {
+    readonly A100: "a100";
+    readonly K80: "k80";
+    readonly M60: "m60";
+    readonly RADEON_PRO_V520: "radeon-pro-v520";
+    readonly T4: "t4";
+    readonly V100: "v100";
+    readonly VU9P: "vu9p";
+};
+/**
+ * @public
+ */
+export type AcceleratorName = (typeof AcceleratorName)[keyof typeof AcceleratorName];
+/**
+ * @public
+ * @enum
+ */
+export declare const AcceleratorType: {
+    readonly FPGA: "fpga";
+    readonly GPU: "gpu";
+    readonly INFERENCE: "inference";
+};
+/**
+ * @public
+ */
+export type AcceleratorType = (typeof AcceleratorType)[keyof typeof AcceleratorType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScalingActivityStatusCode: {
+    readonly Cancelled: "Cancelled";
+    readonly Failed: "Failed";
+    readonly InProgress: "InProgress";
+    readonly MidLifecycleAction: "MidLifecycleAction";
+    readonly PendingSpotBidPlacement: "PendingSpotBidPlacement";
+    readonly PreInService: "PreInService";
+    readonly Successful: "Successful";
+    readonly WaitingForConnectionDraining: "WaitingForConnectionDraining";
+    readonly WaitingForELBConnectionDraining: "WaitingForELBConnectionDraining";
+    readonly WaitingForInstanceId: "WaitingForInstanceId";
+    readonly WaitingForInstanceWarmup: "WaitingForInstanceWarmup";
+    readonly WaitingForSpotInstanceId: "WaitingForSpotInstanceId";
+    readonly WaitingForSpotInstanceRequestId: "WaitingForSpotInstanceRequestId";
+};
+/**
+ * @public
+ */
+export type ScalingActivityStatusCode = (typeof ScalingActivityStatusCode)[keyof typeof ScalingActivityStatusCode];
+/**
+ * @public
+ * @enum
+ */
+export declare const CapacityDistributionStrategy: {
+    readonly BALANCED_BEST_EFFORT: "balanced-best-effort";
+    readonly BALANCED_ONLY: "balanced-only";
+};
+/**
+ * @public
+ */
+export type CapacityDistributionStrategy = (typeof CapacityDistributionStrategy)[keyof typeof CapacityDistributionStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const ImpairedZoneHealthCheckBehavior: {
+    readonly IgnoreUnhealthy: "IgnoreUnhealthy";
+    readonly ReplaceUnhealthy: "ReplaceUnhealthy";
+};
+/**
+ * @public
+ */
+export type ImpairedZoneHealthCheckBehavior = (typeof ImpairedZoneHealthCheckBehavior)[keyof typeof ImpairedZoneHealthCheckBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const CapacityReservationPreference: {
+    readonly CapacityReservationsFirst: "capacity-reservations-first";
+    readonly CapacityReservationsOnly: "capacity-reservations-only";
+    readonly Default: "default";
+    readonly None: "none";
+};
+/**
+ * @public
+ */
+export type CapacityReservationPreference = (typeof CapacityReservationPreference)[keyof typeof CapacityReservationPreference];
+/**
+ * @public
+ * @enum
+ */
+export declare const BareMetal: {
+    readonly EXCLUDED: "excluded";
+    readonly INCLUDED: "included";
+    readonly REQUIRED: "required";
+};
+/**
+ * @public
+ */
+export type BareMetal = (typeof BareMetal)[keyof typeof BareMetal];
+/**
+ * @public
+ * @enum
+ */
+export declare const BurstablePerformance: {
+    readonly EXCLUDED: "excluded";
+    readonly INCLUDED: "included";
+    readonly REQUIRED: "required";
+};
+/**
+ * @public
+ */
+export type BurstablePerformance = (typeof BurstablePerformance)[keyof typeof BurstablePerformance];
+/**
+ * @public
+ * @enum
+ */
+export declare const CpuManufacturer: {
+    readonly AMAZON_WEB_SERVICES: "amazon-web-services";
+    readonly AMD: "amd";
+    readonly APPLE: "apple";
+    readonly INTEL: "intel";
+};
+/**
+ * @public
+ */
+export type CpuManufacturer = (typeof CpuManufacturer)[keyof typeof CpuManufacturer];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceGeneration: {
+    readonly CURRENT: "current";
+    readonly PREVIOUS: "previous";
+};
+/**
+ * @public
+ */
+export type InstanceGeneration = (typeof InstanceGeneration)[keyof typeof InstanceGeneration];
+/**
+ * @public
+ * @enum
+ */
+export declare const LocalStorage: {
+    readonly EXCLUDED: "excluded";
+    readonly INCLUDED: "included";
+    readonly REQUIRED: "required";
+};
+/**
+ * @public
+ */
+export type LocalStorage = (typeof LocalStorage)[keyof typeof LocalStorage];
+/**
+ * @public
+ * @enum
+ */
+export declare const LocalStorageType: {
+    readonly HDD: "hdd";
+    readonly SSD: "ssd";
+};
+/**
+ * @public
+ */
+export type LocalStorageType = (typeof LocalStorageType)[keyof typeof LocalStorageType];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceMetadataEndpointState: {
+    readonly Disabled: "disabled";
+    readonly Enabled: "enabled";
+};
+/**
+ * @public
+ */
+export type InstanceMetadataEndpointState = (typeof InstanceMetadataEndpointState)[keyof typeof InstanceMetadataEndpointState];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceMetadataHttpTokensState: {
+    readonly Optional: "optional";
+    readonly Required: "required";
+};
+/**
+ * @public
+ */
+export type InstanceMetadataHttpTokensState = (typeof InstanceMetadataHttpTokensState)[keyof typeof InstanceMetadataHttpTokensState];
+/**
+ * @public
+ * @enum
+ */
+export declare const LifecycleState: {
+    readonly DETACHED: "Detached";
+    readonly DETACHING: "Detaching";
+    readonly ENTERING_STANDBY: "EnteringStandby";
+    readonly IN_SERVICE: "InService";
+    readonly PENDING: "Pending";
+    readonly PENDING_PROCEED: "Pending:Proceed";
+    readonly PENDING_WAIT: "Pending:Wait";
+    readonly QUARANTINED: "Quarantined";
+    readonly STANDBY: "Standby";
+    readonly TERMINATED: "Terminated";
+    readonly TERMINATING: "Terminating";
+    readonly TERMINATING_PROCEED: "Terminating:Proceed";
+    readonly TERMINATING_WAIT: "Terminating:Wait";
+    readonly WARMED_HIBERNATED: "Warmed:Hibernated";
+    readonly WARMED_PENDING: "Warmed:Pending";
+    readonly WARMED_PENDING_PROCEED: "Warmed:Pending:Proceed";
+    readonly WARMED_PENDING_WAIT: "Warmed:Pending:Wait";
+    readonly WARMED_RUNNING: "Warmed:Running";
+    readonly WARMED_STOPPED: "Warmed:Stopped";
+    readonly WARMED_TERMINATED: "Warmed:Terminated";
+    readonly WARMED_TERMINATING: "Warmed:Terminating";
+    readonly WARMED_TERMINATING_PROCEED: "Warmed:Terminating:Proceed";
+    readonly WARMED_TERMINATING_WAIT: "Warmed:Terminating:Wait";
+};
+/**
+ * @public
+ */
+export type LifecycleState = (typeof LifecycleState)[keyof typeof LifecycleState];
+/**
+ * @public
+ * @enum
+ */
+export declare const WarmPoolState: {
+    readonly Hibernated: "Hibernated";
+    readonly Running: "Running";
+    readonly Stopped: "Stopped";
+};
+/**
+ * @public
+ */
+export type WarmPoolState = (typeof WarmPoolState)[keyof typeof WarmPoolState];
+/**
+ * @public
+ * @enum
+ */
+export declare const WarmPoolStatus: {
+    readonly PendingDelete: "PendingDelete";
+};
+/**
+ * @public
+ */
+export type WarmPoolStatus = (typeof WarmPoolStatus)[keyof typeof WarmPoolStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScaleInProtectedInstances: {
+    readonly Ignore: "Ignore";
+    readonly Refresh: "Refresh";
+    readonly Wait: "Wait";
+};
+/**
+ * @public
+ */
+export type ScaleInProtectedInstances = (typeof ScaleInProtectedInstances)[keyof typeof ScaleInProtectedInstances];
+/**
+ * @public
+ * @enum
+ */
+export declare const StandbyInstances: {
+    readonly Ignore: "Ignore";
+    readonly Terminate: "Terminate";
+    readonly Wait: "Wait";
+};
+/**
+ * @public
+ */
+export type StandbyInstances = (typeof StandbyInstances)[keyof typeof StandbyInstances];
+/**
+ * @public
+ * @enum
+ */
+export declare const InstanceRefreshStatus: {
+    readonly Baking: "Baking";
+    readonly Cancelled: "Cancelled";
+    readonly Cancelling: "Cancelling";
+    readonly Failed: "Failed";
+    readonly InProgress: "InProgress";
+    readonly Pending: "Pending";
+    readonly RollbackFailed: "RollbackFailed";
+    readonly RollbackInProgress: "RollbackInProgress";
+    readonly RollbackSuccessful: "RollbackSuccessful";
+    readonly Successful: "Successful";
+};
+/**
+ * @public
+ */
+export type InstanceRefreshStatus = (typeof InstanceRefreshStatus)[keyof typeof InstanceRefreshStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const PredictiveScalingMaxCapacityBreachBehavior: {
+    readonly HonorMaxCapacity: "HonorMaxCapacity";
+    readonly IncreaseMaxCapacity: "IncreaseMaxCapacity";
+};
+/**
+ * @public
+ */
+export type PredictiveScalingMaxCapacityBreachBehavior = (typeof PredictiveScalingMaxCapacityBreachBehavior)[keyof typeof PredictiveScalingMaxCapacityBreachBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const PredefinedLoadMetricType: {
+    readonly ALBTargetGroupRequestCount: "ALBTargetGroupRequestCount";
+    readonly ASGTotalCPUUtilization: "ASGTotalCPUUtilization";
+    readonly ASGTotalNetworkIn: "ASGTotalNetworkIn";
+    readonly ASGTotalNetworkOut: "ASGTotalNetworkOut";
+};
+/**
+ * @public
+ */
+export type PredefinedLoadMetricType = (typeof PredefinedLoadMetricType)[keyof typeof PredefinedLoadMetricType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PredefinedMetricPairType: {
+    readonly ALBRequestCount: "ALBRequestCount";
+    readonly ASGCPUUtilization: "ASGCPUUtilization";
+    readonly ASGNetworkIn: "ASGNetworkIn";
+    readonly ASGNetworkOut: "ASGNetworkOut";
+};
+/**
+ * @public
+ */
+export type PredefinedMetricPairType = (typeof PredefinedMetricPairType)[keyof typeof PredefinedMetricPairType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PredefinedScalingMetricType: {
+    readonly ALBRequestCountPerTarget: "ALBRequestCountPerTarget";
+    readonly ASGAverageCPUUtilization: "ASGAverageCPUUtilization";
+    readonly ASGAverageNetworkIn: "ASGAverageNetworkIn";
+    readonly ASGAverageNetworkOut: "ASGAverageNetworkOut";
+};
+/**
+ * @public
+ */
+export type PredefinedScalingMetricType = (typeof PredefinedScalingMetricType)[keyof typeof PredefinedScalingMetricType];
+/**
+ * @public
+ * @enum
+ */
+export declare const PredictiveScalingMode: {
+    readonly ForecastAndScale: "ForecastAndScale";
+    readonly ForecastOnly: "ForecastOnly";
+};
+/**
+ * @public
+ */
+export type PredictiveScalingMode = (typeof PredictiveScalingMode)[keyof typeof PredictiveScalingMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetricStatistic: {
+    readonly Average: "Average";
+    readonly Maximum: "Maximum";
+    readonly Minimum: "Minimum";
+    readonly SampleCount: "SampleCount";
+    readonly Sum: "Sum";
+};
+/**
+ * @public
+ */
+export type MetricStatistic = (typeof MetricStatistic)[keyof typeof MetricStatistic];
+/**
+ * @public
+ * @enum
+ */
+export declare const MetricType: {
+    readonly ALBRequestCountPerTarget: "ALBRequestCountPerTarget";
+    readonly ASGAverageCPUUtilization: "ASGAverageCPUUtilization";
+    readonly ASGAverageNetworkIn: "ASGAverageNetworkIn";
+    readonly ASGAverageNetworkOut: "ASGAverageNetworkOut";
+};
+/**
+ * @public
+ */
+export type MetricType = (typeof MetricType)[keyof typeof MetricType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RetryStrategy: {
+    readonly NONE: "none";
+    readonly RETRY_WITH_GROUP_CONFIGURATION: "retry-with-group-configuration";
+};
+/**
+ * @public
+ */
+export type RetryStrategy = (typeof RetryStrategy)[keyof typeof RetryStrategy];
+/**
+ * @public
+ * @enum
+ */
+export declare const RefreshStrategy: {
+    readonly Rolling: "Rolling";
+};
+/**
+ * @public
+ */
+export type RefreshStrategy = (typeof RefreshStrategy)[keyof typeof RefreshStrategy];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,147 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { AutoScalingServiceException as __BaseException } from "./AutoScalingServiceException";
+/**
+ * <p>The request failed because an active instance refresh or rollback for the specified
+ *             Auto Scaling group was not found.</p>
+ * @public
+ */
+export declare class ActiveInstanceRefreshNotFoundFault extends __BaseException {
+    readonly name: "ActiveInstanceRefreshNotFoundFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ActiveInstanceRefreshNotFoundFault, __BaseException>);
+}
+/**
+ * <p>You already have an Auto Scaling group or launch configuration with this name.</p>
+ * @public
+ */
+export declare class AlreadyExistsFault extends __BaseException {
+    readonly name: "AlreadyExistsFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AlreadyExistsFault, __BaseException>);
+}
+/**
+ * <p>You already have a pending update to an Amazon EC2 Auto Scaling resource (for example, an Auto Scaling group,
+ *             instance, or load balancer).</p>
+ * @public
+ */
+export declare class ResourceContentionFault extends __BaseException {
+    readonly name: "ResourceContentionFault";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceContentionFault, __BaseException>);
+}
+/**
+ * <p>The service-linked role is not yet ready for use.</p>
+ * @public
+ */
+export declare class ServiceLinkedRoleFailure extends __BaseException {
+    readonly name: "ServiceLinkedRoleFailure";
+    readonly $fault: "server";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ServiceLinkedRoleFailure, __BaseException>);
+}
+/**
+ * <p>You have already reached a limit for your Amazon EC2 Auto Scaling
+ *             resources (for example, Auto Scaling groups, launch configurations, or lifecycle hooks). For
+ *             more information, see <a href="https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_DescribeAccountLimits.html">DescribeAccountLimits</a> in the <i>Amazon EC2 Auto Scaling API
+ *             Reference</i>.</p>
+ * @public
+ */
+export declare class LimitExceededFault extends __BaseException {
+    readonly name: "LimitExceededFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededFault, __BaseException>);
+}
+/**
+ * <p>The operation can't be performed because the resource is in use.</p>
+ * @public
+ */
+export declare class ResourceInUseFault extends __BaseException {
+    readonly name: "ResourceInUseFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceInUseFault, __BaseException>);
+}
+/**
+ * <p>The operation can't be performed because there are scaling activities in
+ *             progress.</p>
+ * @public
+ */
+export declare class ScalingActivityInProgressFault extends __BaseException {
+    readonly name: "ScalingActivityInProgressFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ScalingActivityInProgressFault, __BaseException>);
+}
+/**
+ * <p>The <code>NextToken</code> value is not valid.</p>
+ * @public
+ */
+export declare class InvalidNextToken extends __BaseException {
+    readonly name: "InvalidNextToken";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidNextToken, __BaseException>);
+}
+/**
+ * <p>
+ *             Indicates that the parameters in the current request do not match the parameters from a previous request with the same client token within the idempotency window.
+ *         </p>
+ * @public
+ */
+export declare class IdempotentParameterMismatchError extends __BaseException {
+    readonly name: "IdempotentParameterMismatchError";
+    readonly $fault: "client";
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IdempotentParameterMismatchError, __BaseException>);
+}
+/**
+ * <p>The request failed because a desired configuration was not found or an incompatible
+ *             launch template (uses a Systems Manager parameter instead of an AMI ID) or launch
+ *             template version (<code>$Latest</code> or <code>$Default</code>) is present on the Auto Scaling
+ *             group.</p>
+ * @public
+ */
+export declare class IrreversibleInstanceRefreshFault extends __BaseException {
+    readonly name: "IrreversibleInstanceRefreshFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IrreversibleInstanceRefreshFault, __BaseException>);
+}
+/**
+ * <p>The request failed because an active instance refresh already exists for the specified
+ *             Auto Scaling group.</p>
+ * @public
+ */
+export declare class InstanceRefreshInProgressFault extends __BaseException {
+    readonly name: "InstanceRefreshInProgressFault";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InstanceRefreshInProgressFault, __BaseException>);
+}