@aws-sdk/client-auto-scaling 3.301.0 → 3.303.0

package/dist-es/models/models_0.js

@@ -1,27 +1,24 @@
 import { AutoScalingServiceException as __BaseException } from "./AutoScalingServiceException";
-export var AcceleratorManufacturer;
-(function (AcceleratorManufacturer) {
-    AcceleratorManufacturer["AMAZON_WEB_SERVICES"] = "amazon-web-services";
-    AcceleratorManufacturer["AMD"] = "amd";
-    AcceleratorManufacturer["NVIDIA"] = "nvidia";
-    AcceleratorManufacturer["XILINX"] = "xilinx";
-})(AcceleratorManufacturer || (AcceleratorManufacturer = {}));
-export var AcceleratorName;
-(function (AcceleratorName) {
-    AcceleratorName["A100"] = "a100";
-    AcceleratorName["K80"] = "k80";
-    AcceleratorName["M60"] = "m60";
-    AcceleratorName["RADEON_PRO_V520"] = "radeon-pro-v520";
-    AcceleratorName["T4"] = "t4";
-    AcceleratorName["V100"] = "v100";
-    AcceleratorName["VU9P"] = "vu9p";
-})(AcceleratorName || (AcceleratorName = {}));
-export var AcceleratorType;
-(function (AcceleratorType) {
-    AcceleratorType["FPGA"] = "fpga";
-    AcceleratorType["GPU"] = "gpu";
-    AcceleratorType["INFERENCE"] = "inference";
-})(AcceleratorType || (AcceleratorType = {}));
+export const AcceleratorManufacturer = {
+    AMAZON_WEB_SERVICES: "amazon-web-services",
+    AMD: "amd",
+    NVIDIA: "nvidia",
+    XILINX: "xilinx",
+};
+export const AcceleratorName = {
+    A100: "a100",
+    K80: "k80",
+    M60: "m60",
+    RADEON_PRO_V520: "radeon-pro-v520",
+    T4: "t4",
+    V100: "v100",
+    VU9P: "vu9p",
+};
+export const AcceleratorType = {
+    FPGA: "fpga",
+    GPU: "gpu",
+    INFERENCE: "inference",
+};
 export class ActiveInstanceRefreshNotFoundFault extends __BaseException {
     constructor(opts) {
         super({
@@ -34,21 +31,21 @@ export class ActiveInstanceRefreshNotFoundFault extends __BaseException {
         Object.setPrototypeOf(this, ActiveInstanceRefreshNotFoundFault.prototype);
     }
 }
-export var ScalingActivityStatusCode;
-(function (ScalingActivityStatusCode) {
-    ScalingActivityStatusCode["Cancelled"] = "Cancelled";
-    ScalingActivityStatusCode["Failed"] = "Failed";
-    ScalingActivityStatusCode["InProgress"] = "InProgress";
-    ScalingActivityStatusCode["MidLifecycleAction"] = "MidLifecycleAction";
-    ScalingActivityStatusCode["PendingSpotBidPlacement"] = "PendingSpotBidPlacement";
-    ScalingActivityStatusCode["PreInService"] = "PreInService";
-    ScalingActivityStatusCode["Successful"] = "Successful";
-    ScalingActivityStatusCode["WaitingForELBConnectionDraining"] = "WaitingForELBConnectionDraining";
-    ScalingActivityStatusCode["WaitingForInstanceId"] = "WaitingForInstanceId";
-    ScalingActivityStatusCode["WaitingForInstanceWarmup"] = "WaitingForInstanceWarmup";
-    ScalingActivityStatusCode["WaitingForSpotInstanceId"] = "WaitingForSpotInstanceId";
-    ScalingActivityStatusCode["WaitingForSpotInstanceRequestId"] = "WaitingForSpotInstanceRequestId";
-})(ScalingActivityStatusCode || (ScalingActivityStatusCode = {}));
+export const ScalingActivityStatusCode = {
+    Cancelled: "Cancelled",
+    Failed: "Failed",
+    InProgress: "InProgress",
+    MidLifecycleAction: "MidLifecycleAction",
+    PendingSpotBidPlacement: "PendingSpotBidPlacement",
+    PreInService: "PreInService",
+    Successful: "Successful",
+    WaitingForConnectionDraining: "WaitingForConnectionDraining",
+    WaitingForELBConnectionDraining: "WaitingForELBConnectionDraining",
+    WaitingForInstanceId: "WaitingForInstanceId",
+    WaitingForInstanceWarmup: "WaitingForInstanceWarmup",
+    WaitingForSpotInstanceId: "WaitingForSpotInstanceId",
+    WaitingForSpotInstanceRequestId: "WaitingForSpotInstanceRequestId",
+};
 export class AlreadyExistsFault extends __BaseException {
     constructor(opts) {
         super({
@@ -97,50 +94,42 @@ export class LimitExceededFault extends __BaseException {
         Object.setPrototypeOf(this, LimitExceededFault.prototype);
     }
 }
-export var BareMetal;
-(function (BareMetal) {
-    BareMetal["EXCLUDED"] = "excluded";
-    BareMetal["INCLUDED"] = "included";
-    BareMetal["REQUIRED"] = "required";
-})(BareMetal || (BareMetal = {}));
-export var BurstablePerformance;
-(function (BurstablePerformance) {
-    BurstablePerformance["EXCLUDED"] = "excluded";
-    BurstablePerformance["INCLUDED"] = "included";
-    BurstablePerformance["REQUIRED"] = "required";
-})(BurstablePerformance || (BurstablePerformance = {}));
-export var CpuManufacturer;
-(function (CpuManufacturer) {
-    CpuManufacturer["AMAZON_WEB_SERVICES"] = "amazon-web-services";
-    CpuManufacturer["AMD"] = "amd";
-    CpuManufacturer["INTEL"] = "intel";
-})(CpuManufacturer || (CpuManufacturer = {}));
-export var InstanceGeneration;
-(function (InstanceGeneration) {
-    InstanceGeneration["CURRENT"] = "current";
-    InstanceGeneration["PREVIOUS"] = "previous";
-})(InstanceGeneration || (InstanceGeneration = {}));
-export var LocalStorage;
-(function (LocalStorage) {
-    LocalStorage["EXCLUDED"] = "excluded";
-    LocalStorage["INCLUDED"] = "included";
-    LocalStorage["REQUIRED"] = "required";
-})(LocalStorage || (LocalStorage = {}));
-export var LocalStorageType;
-(function (LocalStorageType) {
-    LocalStorageType["HDD"] = "hdd";
-    LocalStorageType["SSD"] = "ssd";
-})(LocalStorageType || (LocalStorageType = {}));
-export var InstanceMetadataEndpointState;
-(function (InstanceMetadataEndpointState) {
-    InstanceMetadataEndpointState["Disabled"] = "disabled";
-    InstanceMetadataEndpointState["Enabled"] = "enabled";
-})(InstanceMetadataEndpointState || (InstanceMetadataEndpointState = {}));
-export var InstanceMetadataHttpTokensState;
-(function (InstanceMetadataHttpTokensState) {
-    InstanceMetadataHttpTokensState["Optional"] = "optional";
-    InstanceMetadataHttpTokensState["Required"] = "required";
-})(InstanceMetadataHttpTokensState || (InstanceMetadataHttpTokensState = {}));
+export const BareMetal = {
+    EXCLUDED: "excluded",
+    INCLUDED: "included",
+    REQUIRED: "required",
+};
+export const BurstablePerformance = {
+    EXCLUDED: "excluded",
+    INCLUDED: "included",
+    REQUIRED: "required",
+};
+export const CpuManufacturer = {
+    AMAZON_WEB_SERVICES: "amazon-web-services",
+    AMD: "amd",
+    INTEL: "intel",
+};
+export const InstanceGeneration = {
+    CURRENT: "current",
+    PREVIOUS: "previous",
+};
+export const LocalStorage = {
+    EXCLUDED: "excluded",
+    INCLUDED: "included",
+    REQUIRED: "required",
+};
+export const LocalStorageType = {
+    HDD: "hdd",
+    SSD: "ssd",
+};
+export const InstanceMetadataEndpointState = {
+    Disabled: "disabled",
+    Enabled: "enabled",
+};
+export const InstanceMetadataHttpTokensState = {
+    Optional: "optional",
+    Required: "required",
+};
 export class ResourceInUseFault extends __BaseException {
     constructor(opts) {
         super({
@@ -165,42 +154,39 @@ export class ScalingActivityInProgressFault extends __BaseException {
         Object.setPrototypeOf(this, ScalingActivityInProgressFault.prototype);
     }
 }
-export var LifecycleState;
-(function (LifecycleState) {
-    LifecycleState["DETACHED"] = "Detached";
-    LifecycleState["DETACHING"] = "Detaching";
-    LifecycleState["ENTERING_STANDBY"] = "EnteringStandby";
-    LifecycleState["IN_SERVICE"] = "InService";
-    LifecycleState["PENDING"] = "Pending";
-    LifecycleState["PENDING_PROCEED"] = "Pending:Proceed";
-    LifecycleState["PENDING_WAIT"] = "Pending:Wait";
-    LifecycleState["QUARANTINED"] = "Quarantined";
-    LifecycleState["STANDBY"] = "Standby";
-    LifecycleState["TERMINATED"] = "Terminated";
-    LifecycleState["TERMINATING"] = "Terminating";
-    LifecycleState["TERMINATING_PROCEED"] = "Terminating:Proceed";
-    LifecycleState["TERMINATING_WAIT"] = "Terminating:Wait";
-    LifecycleState["WARMED_HIBERNATED"] = "Warmed:Hibernated";
-    LifecycleState["WARMED_PENDING"] = "Warmed:Pending";
-    LifecycleState["WARMED_PENDING_PROCEED"] = "Warmed:Pending:Proceed";
-    LifecycleState["WARMED_PENDING_WAIT"] = "Warmed:Pending:Wait";
-    LifecycleState["WARMED_RUNNING"] = "Warmed:Running";
-    LifecycleState["WARMED_STOPPED"] = "Warmed:Stopped";
-    LifecycleState["WARMED_TERMINATED"] = "Warmed:Terminated";
-    LifecycleState["WARMED_TERMINATING"] = "Warmed:Terminating";
-    LifecycleState["WARMED_TERMINATING_PROCEED"] = "Warmed:Terminating:Proceed";
-    LifecycleState["WARMED_TERMINATING_WAIT"] = "Warmed:Terminating:Wait";
-})(LifecycleState || (LifecycleState = {}));
-export var WarmPoolState;
-(function (WarmPoolState) {
-    WarmPoolState["Hibernated"] = "Hibernated";
-    WarmPoolState["Running"] = "Running";
-    WarmPoolState["Stopped"] = "Stopped";
-})(WarmPoolState || (WarmPoolState = {}));
-export var WarmPoolStatus;
-(function (WarmPoolStatus) {
-    WarmPoolStatus["PendingDelete"] = "PendingDelete";
-})(WarmPoolStatus || (WarmPoolStatus = {}));
+export const LifecycleState = {
+    DETACHED: "Detached",
+    DETACHING: "Detaching",
+    ENTERING_STANDBY: "EnteringStandby",
+    IN_SERVICE: "InService",
+    PENDING: "Pending",
+    PENDING_PROCEED: "Pending:Proceed",
+    PENDING_WAIT: "Pending:Wait",
+    QUARANTINED: "Quarantined",
+    STANDBY: "Standby",
+    TERMINATED: "Terminated",
+    TERMINATING: "Terminating",
+    TERMINATING_PROCEED: "Terminating:Proceed",
+    TERMINATING_WAIT: "Terminating:Wait",
+    WARMED_HIBERNATED: "Warmed:Hibernated",
+    WARMED_PENDING: "Warmed:Pending",
+    WARMED_PENDING_PROCEED: "Warmed:Pending:Proceed",
+    WARMED_PENDING_WAIT: "Warmed:Pending:Wait",
+    WARMED_RUNNING: "Warmed:Running",
+    WARMED_STOPPED: "Warmed:Stopped",
+    WARMED_TERMINATED: "Warmed:Terminated",
+    WARMED_TERMINATING: "Warmed:Terminating",
+    WARMED_TERMINATING_PROCEED: "Warmed:Terminating:Proceed",
+    WARMED_TERMINATING_WAIT: "Warmed:Terminating:Wait",
+};
+export const WarmPoolState = {
+    Hibernated: "Hibernated",
+    Running: "Running",
+    Stopped: "Stopped",
+};
+export const WarmPoolStatus = {
+    PendingDelete: "PendingDelete",
+};
 export class InvalidNextToken extends __BaseException {
     constructor(opts) {
         super({
@@ -213,76 +199,66 @@ export class InvalidNextToken extends __BaseException {
         Object.setPrototypeOf(this, InvalidNextToken.prototype);
     }
 }
-export var ScaleInProtectedInstances;
-(function (ScaleInProtectedInstances) {
-    ScaleInProtectedInstances["Ignore"] = "Ignore";
-    ScaleInProtectedInstances["Refresh"] = "Refresh";
-    ScaleInProtectedInstances["Wait"] = "Wait";
-})(ScaleInProtectedInstances || (ScaleInProtectedInstances = {}));
-export var StandbyInstances;
-(function (StandbyInstances) {
-    StandbyInstances["Ignore"] = "Ignore";
-    StandbyInstances["Terminate"] = "Terminate";
-    StandbyInstances["Wait"] = "Wait";
-})(StandbyInstances || (StandbyInstances = {}));
-export var InstanceRefreshStatus;
-(function (InstanceRefreshStatus) {
-    InstanceRefreshStatus["Cancelled"] = "Cancelled";
-    InstanceRefreshStatus["Cancelling"] = "Cancelling";
-    InstanceRefreshStatus["Failed"] = "Failed";
-    InstanceRefreshStatus["InProgress"] = "InProgress";
-    InstanceRefreshStatus["Pending"] = "Pending";
-    InstanceRefreshStatus["RollbackFailed"] = "RollbackFailed";
-    InstanceRefreshStatus["RollbackInProgress"] = "RollbackInProgress";
-    InstanceRefreshStatus["RollbackSuccessful"] = "RollbackSuccessful";
-    InstanceRefreshStatus["Successful"] = "Successful";
-})(InstanceRefreshStatus || (InstanceRefreshStatus = {}));
-export var PredictiveScalingMaxCapacityBreachBehavior;
-(function (PredictiveScalingMaxCapacityBreachBehavior) {
-    PredictiveScalingMaxCapacityBreachBehavior["HonorMaxCapacity"] = "HonorMaxCapacity";
-    PredictiveScalingMaxCapacityBreachBehavior["IncreaseMaxCapacity"] = "IncreaseMaxCapacity";
-})(PredictiveScalingMaxCapacityBreachBehavior || (PredictiveScalingMaxCapacityBreachBehavior = {}));
-export var PredefinedLoadMetricType;
-(function (PredefinedLoadMetricType) {
-    PredefinedLoadMetricType["ALBTargetGroupRequestCount"] = "ALBTargetGroupRequestCount";
-    PredefinedLoadMetricType["ASGTotalCPUUtilization"] = "ASGTotalCPUUtilization";
-    PredefinedLoadMetricType["ASGTotalNetworkIn"] = "ASGTotalNetworkIn";
-    PredefinedLoadMetricType["ASGTotalNetworkOut"] = "ASGTotalNetworkOut";
-})(PredefinedLoadMetricType || (PredefinedLoadMetricType = {}));
-export var PredefinedMetricPairType;
-(function (PredefinedMetricPairType) {
-    PredefinedMetricPairType["ALBRequestCount"] = "ALBRequestCount";
-    PredefinedMetricPairType["ASGCPUUtilization"] = "ASGCPUUtilization";
-    PredefinedMetricPairType["ASGNetworkIn"] = "ASGNetworkIn";
-    PredefinedMetricPairType["ASGNetworkOut"] = "ASGNetworkOut";
-})(PredefinedMetricPairType || (PredefinedMetricPairType = {}));
-export var PredefinedScalingMetricType;
-(function (PredefinedScalingMetricType) {
-    PredefinedScalingMetricType["ALBRequestCountPerTarget"] = "ALBRequestCountPerTarget";
-    PredefinedScalingMetricType["ASGAverageCPUUtilization"] = "ASGAverageCPUUtilization";
-    PredefinedScalingMetricType["ASGAverageNetworkIn"] = "ASGAverageNetworkIn";
-    PredefinedScalingMetricType["ASGAverageNetworkOut"] = "ASGAverageNetworkOut";
-})(PredefinedScalingMetricType || (PredefinedScalingMetricType = {}));
-export var PredictiveScalingMode;
-(function (PredictiveScalingMode) {
-    PredictiveScalingMode["ForecastAndScale"] = "ForecastAndScale";
-    PredictiveScalingMode["ForecastOnly"] = "ForecastOnly";
-})(PredictiveScalingMode || (PredictiveScalingMode = {}));
-export var MetricStatistic;
-(function (MetricStatistic) {
-    MetricStatistic["Average"] = "Average";
-    MetricStatistic["Maximum"] = "Maximum";
-    MetricStatistic["Minimum"] = "Minimum";
-    MetricStatistic["SampleCount"] = "SampleCount";
-    MetricStatistic["Sum"] = "Sum";
-})(MetricStatistic || (MetricStatistic = {}));
-export var MetricType;
-(function (MetricType) {
-    MetricType["ALBRequestCountPerTarget"] = "ALBRequestCountPerTarget";
-    MetricType["ASGAverageCPUUtilization"] = "ASGAverageCPUUtilization";
-    MetricType["ASGAverageNetworkIn"] = "ASGAverageNetworkIn";
-    MetricType["ASGAverageNetworkOut"] = "ASGAverageNetworkOut";
-})(MetricType || (MetricType = {}));
+export const ScaleInProtectedInstances = {
+    Ignore: "Ignore",
+    Refresh: "Refresh",
+    Wait: "Wait",
+};
+export const StandbyInstances = {
+    Ignore: "Ignore",
+    Terminate: "Terminate",
+    Wait: "Wait",
+};
+export const InstanceRefreshStatus = {
+    Cancelled: "Cancelled",
+    Cancelling: "Cancelling",
+    Failed: "Failed",
+    InProgress: "InProgress",
+    Pending: "Pending",
+    RollbackFailed: "RollbackFailed",
+    RollbackInProgress: "RollbackInProgress",
+    RollbackSuccessful: "RollbackSuccessful",
+    Successful: "Successful",
+};
+export const PredictiveScalingMaxCapacityBreachBehavior = {
+    HonorMaxCapacity: "HonorMaxCapacity",
+    IncreaseMaxCapacity: "IncreaseMaxCapacity",
+};
+export const PredefinedLoadMetricType = {
+    ALBTargetGroupRequestCount: "ALBTargetGroupRequestCount",
+    ASGTotalCPUUtilization: "ASGTotalCPUUtilization",
+    ASGTotalNetworkIn: "ASGTotalNetworkIn",
+    ASGTotalNetworkOut: "ASGTotalNetworkOut",
+};
+export const PredefinedMetricPairType = {
+    ALBRequestCount: "ALBRequestCount",
+    ASGCPUUtilization: "ASGCPUUtilization",
+    ASGNetworkIn: "ASGNetworkIn",
+    ASGNetworkOut: "ASGNetworkOut",
+};
+export const PredefinedScalingMetricType = {
+    ALBRequestCountPerTarget: "ALBRequestCountPerTarget",
+    ASGAverageCPUUtilization: "ASGAverageCPUUtilization",
+    ASGAverageNetworkIn: "ASGAverageNetworkIn",
+    ASGAverageNetworkOut: "ASGAverageNetworkOut",
+};
+export const PredictiveScalingMode = {
+    ForecastAndScale: "ForecastAndScale",
+    ForecastOnly: "ForecastOnly",
+};
+export const MetricStatistic = {
+    Average: "Average",
+    Maximum: "Maximum",
+    Minimum: "Minimum",
+    SampleCount: "SampleCount",
+    Sum: "Sum",
+};
+export const MetricType = {
+    ALBRequestCountPerTarget: "ALBRequestCountPerTarget",
+    ASGAverageCPUUtilization: "ASGAverageCPUUtilization",
+    ASGAverageNetworkIn: "ASGAverageNetworkIn",
+    ASGAverageNetworkOut: "ASGAverageNetworkOut",
+};
 export class IrreversibleInstanceRefreshFault extends __BaseException {
     constructor(opts) {
         super({
@@ -307,7 +283,6 @@ export class InstanceRefreshInProgressFault extends __BaseException {
         Object.setPrototypeOf(this, InstanceRefreshInProgressFault.prototype);
     }
 }
-export var RefreshStrategy;
-(function (RefreshStrategy) {
-    RefreshStrategy["Rolling"] = "Rolling";
-})(RefreshStrategy || (RefreshStrategy = {}));
+export const RefreshStrategy = {
+    Rolling: "Rolling",
+};

package/dist-es/pagination/DescribeTrafficSourcesPaginator.js

@@ -0,0 +1,25 @@
+import { AutoScalingClient } from "../AutoScalingClient";
+import { DescribeTrafficSourcesCommand, } from "../commands/DescribeTrafficSourcesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeTrafficSourcesCommand(input), ...args);
+};
+export async function* paginateDescribeTrafficSources(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxRecords"] = config.pageSize;
+        if (config.client instanceof AutoScalingClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected AutoScaling | AutoScalingClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -6,4 +6,5 @@ export * from "./DescribePoliciesPaginator";
 export * from "./DescribeScalingActivitiesPaginator";
 export * from "./DescribeScheduledActionsPaginator";
 export * from "./DescribeTagsPaginator";
+export * from "./DescribeTrafficSourcesPaginator";
 export * from "./Interfaces";

package/dist-es/protocols/Aws_query.js

@@ -5729,6 +5729,9 @@ const serializeAws_queryTrafficSourceIdentifier = (input, context) => {
     if (input.Identifier != null) {
         entries["Identifier"] = input.Identifier;
     }
+    if (input.Type != null) {
+        entries["Type"] = input.Type;
+    }
     return entries;
 };
 const serializeAws_queryTrafficSources = (input, context) => {
@@ -8001,6 +8004,9 @@ const deserializeAws_queryTrafficSourceIdentifier = (output, context) => {
     if (output["Identifier"] !== undefined) {
         contents.Identifier = __expectString(output["Identifier"]);
     }
+    if (output["Type"] !== undefined) {
+        contents.Type = __expectString(output["Type"]);
+    }
     return contents;
 };
 const deserializeAws_queryTrafficSources = (output, context) => {
@@ -8018,6 +8024,12 @@ const deserializeAws_queryTrafficSourceState = (output, context) => {
     if (output["State"] !== undefined) {
         contents.State = __expectString(output["State"]);
     }
+    if (output["Identifier"] !== undefined) {
+        contents.Identifier = __expectString(output["Identifier"]);
+    }
+    if (output["Type"] !== undefined) {
+        contents.Type = __expectString(output["Type"]);
+    }
     return contents;
 };
 const deserializeAws_queryTrafficSourceStates = (output, context) => {