@aws-sdk/client-compute-optimizer 3.235.0 → 3.237.0

package/dist-es/commands/ExportECSServiceRecommendationsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ExportECSServiceRecommendationsRequestFilterSensitiveLog, ExportECSServiceRecommendationsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0ExportECSServiceRecommendationsCommand, serializeAws_json1_0ExportECSServiceRecommendationsCommand, } from "../protocols/Aws_json1_0";
+export class ExportECSServiceRecommendationsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ExportECSServiceRecommendationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComputeOptimizerClient";
+        const commandName = "ExportECSServiceRecommendationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ExportECSServiceRecommendationsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ExportECSServiceRecommendationsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0ExportECSServiceRecommendationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0ExportECSServiceRecommendationsCommand(output, context);
+    }
+}

package/dist-es/commands/GetECSServiceRecommendationProjectedMetricsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetECSServiceRecommendationProjectedMetricsRequestFilterSensitiveLog, GetECSServiceRecommendationProjectedMetricsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetECSServiceRecommendationProjectedMetricsCommand, serializeAws_json1_0GetECSServiceRecommendationProjectedMetricsCommand, } from "../protocols/Aws_json1_0";
+export class GetECSServiceRecommendationProjectedMetricsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetECSServiceRecommendationProjectedMetricsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComputeOptimizerClient";
+        const commandName = "GetECSServiceRecommendationProjectedMetricsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetECSServiceRecommendationProjectedMetricsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetECSServiceRecommendationProjectedMetricsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetECSServiceRecommendationProjectedMetricsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetECSServiceRecommendationProjectedMetricsCommand(output, context);
+    }
+}

package/dist-es/commands/GetECSServiceRecommendationsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetECSServiceRecommendationsRequestFilterSensitiveLog, GetECSServiceRecommendationsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetECSServiceRecommendationsCommand, serializeAws_json1_0GetECSServiceRecommendationsCommand, } from "../protocols/Aws_json1_0";
+export class GetECSServiceRecommendationsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetECSServiceRecommendationsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComputeOptimizerClient";
+        const commandName = "GetECSServiceRecommendationsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetECSServiceRecommendationsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetECSServiceRecommendationsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetECSServiceRecommendationsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetECSServiceRecommendationsCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -3,11 +3,14 @@ export * from "./DescribeRecommendationExportJobsCommand";
 export * from "./ExportAutoScalingGroupRecommendationsCommand";
 export * from "./ExportEBSVolumeRecommendationsCommand";
 export * from "./ExportEC2InstanceRecommendationsCommand";
+export * from "./ExportECSServiceRecommendationsCommand";
 export * from "./ExportLambdaFunctionRecommendationsCommand";
 export * from "./GetAutoScalingGroupRecommendationsCommand";
 export * from "./GetEBSVolumeRecommendationsCommand";
 export * from "./GetEC2InstanceRecommendationsCommand";
 export * from "./GetEC2RecommendationProjectedMetricsCommand";
+export * from "./GetECSServiceRecommendationProjectedMetricsCommand";
+export * from "./GetECSServiceRecommendationsCommand";
 export * from "./GetEffectiveRecommendationPreferencesCommand";
 export * from "./GetEnrollmentStatusCommand";
 export * from "./GetEnrollmentStatusesForOrganizationCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const s = "fn", t = "argv", u = "ref";
-const a = true, b = false, c = "String", d = "Boolean", e = "PartitionResult", f = "tree", g = "error", h = "endpoint", i = { [u]: "Endpoint" }, j = { [s]: "booleanEquals", [t]: [{ [u]: "UseFIPS" }, true] }, k = { [s]: "booleanEquals", [t]: [{ [u]: "UseDualStack" }, true] }, l = {}, m = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: e }, "supportsFIPS"] }] }, n = { [s]: "booleanEquals", [t]: [true, { [s]: "getAttr", [t]: [{ [u]: e }, "supportsDualStack"] }] }, o = [i], p = [j], q = [], r = [k];
-const _data = { version: "1.0", parameters: { Region: { builtIn: "AWS::Region", required: a, documentation: "The AWS region used to dispatch the request.", type: c }, UseDualStack: { builtIn: "AWS::UseDualStack", required: a, default: b, documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.", type: d }, UseFIPS: { builtIn: "AWS::UseFIPS", required: a, default: b, documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.", type: d }, Endpoint: { builtIn: "SDK::Endpoint", required: b, documentation: "Override the endpoint used to send this request", type: c } }, rules: [{ conditions: [{ [s]: "aws.partition", [t]: [{ [u]: "Region" }], assign: e }], type: f, rules: [{ conditions: [{ [s]: "isSet", [t]: o }, { [s]: "parseURL", [t]: o, assign: "url" }], type: f, rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: g }, { conditions: q, type: f, rules: [{ conditions: r, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: g }, { conditions: q, endpoint: { url: i, properties: l, headers: l }, type: h }] }] }, { conditions: [j, k], type: f, rules: [{ conditions: [m, n], type: f, rules: [{ conditions: q, endpoint: { url: "https://compute-optimizer-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: h }] }, { conditions: q, error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: g }] }, { conditions: p, type: f, rules: [{ conditions: [m], type: f, rules: [{ conditions: q, type: f, rules: [{ conditions: q, endpoint: { url: "https://compute-optimizer-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: h }] }] }, { conditions: q, error: "FIPS is enabled but this partition does not support FIPS", type: g }] }, { conditions: r, type: f, rules: [{ conditions: [n], type: f, rules: [{ conditions: q, endpoint: { url: "https://compute-optimizer.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: h }] }, { conditions: q, error: "DualStack is enabled but this partition does not support DualStack", type: g }] }, { conditions: q, endpoint: { url: "https://compute-optimizer.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: h }] }] };
+const q = "fn", r = "argv", s = "ref";
+const a = true, b = false, c = "String", d = "PartitionResult", e = "tree", f = "error", g = "endpoint", h = { "required": true, "default": false, "type": "Boolean" }, i = { [s]: "Endpoint" }, j = { [q]: "booleanEquals", [r]: [{ [s]: "UseFIPS" }, true] }, k = { [q]: "booleanEquals", [r]: [{ [s]: "UseDualStack" }, true] }, l = {}, m = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsFIPS"] }] }, n = { [q]: "booleanEquals", [r]: [true, { [q]: "getAttr", [r]: [{ [s]: d }, "supportsDualStack"] }] }, o = [j], p = [k];
+const _data = { version: "1.0", parameters: { Region: { required: a, type: c }, UseDualStack: h, UseFIPS: h, Endpoint: { required: b, type: c } }, rules: [{ conditions: [{ [q]: "aws.partition", [r]: [{ [s]: "Region" }], assign: d }], type: e, rules: [{ conditions: [{ [q]: "isSet", [r]: [i] }], type: e, rules: [{ conditions: o, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: f }, { type: e, rules: [{ conditions: p, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: f }, { endpoint: { url: i, properties: l, headers: l }, type: g }] }] }, { conditions: [j, k], type: e, rules: [{ conditions: [m, n], type: e, rules: [{ endpoint: { url: "https://compute-optimizer-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: f }] }, { conditions: o, type: e, rules: [{ conditions: [m], type: e, rules: [{ type: e, rules: [{ endpoint: { url: "https://compute-optimizer-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: f }] }, { conditions: p, type: e, rules: [{ conditions: [n], type: e, rules: [{ endpoint: { url: "https://compute-optimizer.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: g }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: f }] }, { endpoint: { url: "https://compute-optimizer.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: g }] }] };
 export const ruleSet = _data;

package/dist-es/index.js

@@ -2,4 +2,5 @@ export * from "./ComputeOptimizer";
 export * from "./ComputeOptimizerClient";
 export * from "./commands";
 export * from "./models";
+export * from "./pagination";
 export { ComputeOptimizerServiceException } from "./models/ComputeOptimizerServiceException";

package/dist-es/models/models_0.js

@@ -18,6 +18,11 @@ export var Status;
     Status["INACTIVE"] = "Inactive";
     Status["PENDING"] = "Pending";
 })(Status || (Status = {}));
+export var AutoScalingConfiguration;
+(function (AutoScalingConfiguration) {
+    AutoScalingConfiguration["TARGET_TRACKING_SCALING_CPU"] = "TargetTrackingScalingCpu";
+    AutoScalingConfiguration["TARGET_TRACKING_SCALING_MEMORY"] = "TargetTrackingScalingMemory";
+})(AutoScalingConfiguration || (AutoScalingConfiguration = {}));
 export var CurrentPerformanceRisk;
 (function (CurrentPerformanceRisk) {
     CurrentPerformanceRisk["HIGH"] = "High";
@@ -109,6 +114,7 @@ export var ResourceType;
     ResourceType["AUTO_SCALING_GROUP"] = "AutoScalingGroup";
     ResourceType["EBS_VOLUME"] = "EbsVolume";
     ResourceType["EC2_INSTANCE"] = "Ec2Instance";
+    ResourceType["ECS_SERVICE"] = "EcsService";
     ResourceType["LAMBDA_FUNCTION"] = "LambdaFunction";
     ResourceType["NOT_APPLICABLE"] = "NotApplicable";
 })(ResourceType || (ResourceType = {}));
@@ -384,6 +390,37 @@ export var ExportableInstanceField;
     ExportableInstanceField["UTILIZATION_METRICS_NETWORK_PACKETS_IN_PER_SECOND_MAXIMUM"] = "UtilizationMetricsNetworkPacketsInPerSecondMaximum";
     ExportableInstanceField["UTILIZATION_METRICS_NETWORK_PACKETS_OUT_PER_SECOND_MAXIMUM"] = "UtilizationMetricsNetworkPacketsOutPerSecondMaximum";
 })(ExportableInstanceField || (ExportableInstanceField = {}));
+export var ExportableECSServiceField;
+(function (ExportableECSServiceField) {
+    ExportableECSServiceField["ACCOUNT_ID"] = "AccountId";
+    ExportableECSServiceField["CURRENT_PERFORMANCE_RISK"] = "CurrentPerformanceRisk";
+    ExportableECSServiceField["CURRENT_SERVICE_CONFIGURATION_AUTO_SCALING_CONFIGURATION"] = "CurrentServiceConfigurationAutoScalingConfiguration";
+    ExportableECSServiceField["CURRENT_SERVICE_CONFIGURATION_CPU"] = "CurrentServiceConfigurationCpu";
+    ExportableECSServiceField["CURRENT_SERVICE_CONFIGURATION_MEMORY"] = "CurrentServiceConfigurationMemory";
+    ExportableECSServiceField["CURRENT_SERVICE_CONFIGURATION_TASK_DEFINITION_ARN"] = "CurrentServiceConfigurationTaskDefinitionArn";
+    ExportableECSServiceField["CURRENT_SERVICE_CONTAINER_CONFIGURATIONS"] = "CurrentServiceContainerConfigurations";
+    ExportableECSServiceField["FINDING"] = "Finding";
+    ExportableECSServiceField["FINDING_REASON_CODES"] = "FindingReasonCodes";
+    ExportableECSServiceField["LAST_REFRESH_TIMESTAMP"] = "LastRefreshTimestamp";
+    ExportableECSServiceField["LAUNCH_TYPE"] = "LaunchType";
+    ExportableECSServiceField["LOOKBACK_PERIOD_IN_DAYS"] = "LookbackPeriodInDays";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_CONTAINER_RECOMMENDATIONS"] = "RecommendationOptionsContainerRecommendations";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_CPU"] = "RecommendationOptionsCpu";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_ESTIMATED_MONTHLY_SAVINGS_CURRENCY"] = "RecommendationOptionsEstimatedMonthlySavingsCurrency";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_ESTIMATED_MONTHLY_SAVINGS_VALUE"] = "RecommendationOptionsEstimatedMonthlySavingsValue";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_MEMORY"] = "RecommendationOptionsMemory";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_PROJECTED_UTILIZATION_METRICS_CPU_MAXIMUM"] = "RecommendationOptionsProjectedUtilizationMetricsCpuMaximum";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_PROJECTED_UTILIZATION_METRICS_MEMORY_MAXIMUM"] = "RecommendationOptionsProjectedUtilizationMetricsMemoryMaximum";
+    ExportableECSServiceField["RECOMMENDATION_OPTIONS_SAVINGS_OPPORTUNITY_PERCENTAGE"] = "RecommendationOptionsSavingsOpportunityPercentage";
+    ExportableECSServiceField["SERVICE_ARN"] = "ServiceArn";
+    ExportableECSServiceField["UTILIZATION_METRICS_CPU_MAXIMUM"] = "UtilizationMetricsCpuMaximum";
+    ExportableECSServiceField["UTILIZATION_METRICS_MEMORY_MAXIMUM"] = "UtilizationMetricsMemoryMaximum";
+})(ExportableECSServiceField || (ExportableECSServiceField = {}));
+export var ECSServiceRecommendationFilterName;
+(function (ECSServiceRecommendationFilterName) {
+    ECSServiceRecommendationFilterName["FINDING"] = "Finding";
+    ECSServiceRecommendationFilterName["FINDING_REASON_CODE"] = "FindingReasonCode";
+})(ECSServiceRecommendationFilterName || (ECSServiceRecommendationFilterName = {}));
 export var ExportableLambdaFunctionField;
 (function (ExportableLambdaFunctionField) {
     ExportableLambdaFunctionField["ACCOUNT_ID"] = "AccountId";
@@ -463,8 +500,37 @@ export var RecommendationSourceType;
     RecommendationSourceType["AUTO_SCALING_GROUP"] = "AutoScalingGroup";
     RecommendationSourceType["EBS_VOLUME"] = "EbsVolume";
     RecommendationSourceType["EC2_INSTANCE"] = "Ec2Instance";
+    RecommendationSourceType["ECS_SERVICE"] = "EcsService";
     RecommendationSourceType["LAMBDA_FUNCTION"] = "LambdaFunction";
 })(RecommendationSourceType || (RecommendationSourceType = {}));
+export var ECSServiceMetricName;
+(function (ECSServiceMetricName) {
+    ECSServiceMetricName["CPU"] = "Cpu";
+    ECSServiceMetricName["MEMORY"] = "Memory";
+})(ECSServiceMetricName || (ECSServiceMetricName = {}));
+export var ECSServiceRecommendationFinding;
+(function (ECSServiceRecommendationFinding) {
+    ECSServiceRecommendationFinding["OPTIMIZED"] = "Optimized";
+    ECSServiceRecommendationFinding["OVER_PROVISIONED"] = "Overprovisioned";
+    ECSServiceRecommendationFinding["UNDER_PROVISIONED"] = "Underprovisioned";
+})(ECSServiceRecommendationFinding || (ECSServiceRecommendationFinding = {}));
+export var ECSServiceRecommendationFindingReasonCode;
+(function (ECSServiceRecommendationFindingReasonCode) {
+    ECSServiceRecommendationFindingReasonCode["CPU_OVER_PROVISIONED"] = "CPUOverprovisioned";
+    ECSServiceRecommendationFindingReasonCode["CPU_UNDER_PROVISIONED"] = "CPUUnderprovisioned";
+    ECSServiceRecommendationFindingReasonCode["MEMORY_OVER_PROVISIONED"] = "MemoryOverprovisioned";
+    ECSServiceRecommendationFindingReasonCode["MEMORY_UNDER_PROVISIONED"] = "MemoryUnderprovisioned";
+})(ECSServiceRecommendationFindingReasonCode || (ECSServiceRecommendationFindingReasonCode = {}));
+export var ECSServiceLaunchType;
+(function (ECSServiceLaunchType) {
+    ECSServiceLaunchType["EC2"] = "EC2";
+    ECSServiceLaunchType["FARGATE"] = "Fargate";
+})(ECSServiceLaunchType || (ECSServiceLaunchType = {}));
+export var ECSServiceMetricStatistic;
+(function (ECSServiceMetricStatistic) {
+    ECSServiceMetricStatistic["AVERAGE"] = "Average";
+    ECSServiceMetricStatistic["MAXIMUM"] = "Maximum";
+})(ECSServiceMetricStatistic || (ECSServiceMetricStatistic = {}));
 export var EnrollmentFilterName;
 (function (EnrollmentFilterName) {
     EnrollmentFilterName["STATUS"] = "Status";
@@ -591,6 +657,15 @@ export const ExportEC2InstanceRecommendationsRequestFilterSensitiveLog = (obj) =
 export const ExportEC2InstanceRecommendationsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ECSServiceRecommendationFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportECSServiceRecommendationsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportECSServiceRecommendationsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const LambdaFunctionRecommendationFilterFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -654,6 +729,48 @@ export const RecommendedOptionProjectedMetricFilterSensitiveLog = (obj) => ({
 export const GetEC2RecommendationProjectedMetricsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const GetECSServiceRecommendationProjectedMetricsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceProjectedMetricFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceRecommendedOptionProjectedMetricFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetECSServiceRecommendationProjectedMetricsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetECSServiceRecommendationsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const MemorySizeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContainerConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ServiceConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ContainerRecommendationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceProjectedUtilizationMetricFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceRecommendationOptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceUtilizationMetricFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ECSServiceRecommendationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetECSServiceRecommendationsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const GetEffectiveRecommendationPreferencesRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/DescribeRecommendationExportJobsPaginator.js

@@ -0,0 +1,32 @@
+import { DescribeRecommendationExportJobsCommand, } from "../commands/DescribeRecommendationExportJobsCommand";
+import { ComputeOptimizer } from "../ComputeOptimizer";
+import { ComputeOptimizerClient } from "../ComputeOptimizerClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new DescribeRecommendationExportJobsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.describeRecommendationExportJobs(input, ...args);
+};
+export async function* paginateDescribeRecommendationExportJobs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof ComputeOptimizer) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ComputeOptimizerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ComputeOptimizer | ComputeOptimizerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/GetEnrollmentStatusesForOrganizationPaginator.js

@@ -0,0 +1,32 @@
+import { GetEnrollmentStatusesForOrganizationCommand, } from "../commands/GetEnrollmentStatusesForOrganizationCommand";
+import { ComputeOptimizer } from "../ComputeOptimizer";
+import { ComputeOptimizerClient } from "../ComputeOptimizerClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetEnrollmentStatusesForOrganizationCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getEnrollmentStatusesForOrganization(input, ...args);
+};
+export async function* paginateGetEnrollmentStatusesForOrganization(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof ComputeOptimizer) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ComputeOptimizerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ComputeOptimizer | ComputeOptimizerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/GetLambdaFunctionRecommendationsPaginator.js

@@ -0,0 +1,32 @@
+import { GetLambdaFunctionRecommendationsCommand, } from "../commands/GetLambdaFunctionRecommendationsCommand";
+import { ComputeOptimizer } from "../ComputeOptimizer";
+import { ComputeOptimizerClient } from "../ComputeOptimizerClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetLambdaFunctionRecommendationsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getLambdaFunctionRecommendations(input, ...args);
+};
+export async function* paginateGetLambdaFunctionRecommendations(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof ComputeOptimizer) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ComputeOptimizerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ComputeOptimizer | ComputeOptimizerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/GetRecommendationPreferencesPaginator.js

@@ -0,0 +1,32 @@
+import { GetRecommendationPreferencesCommand, } from "../commands/GetRecommendationPreferencesCommand";
+import { ComputeOptimizer } from "../ComputeOptimizer";
+import { ComputeOptimizerClient } from "../ComputeOptimizerClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetRecommendationPreferencesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getRecommendationPreferences(input, ...args);
+};
+export async function* paginateGetRecommendationPreferences(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof ComputeOptimizer) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ComputeOptimizerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ComputeOptimizer | ComputeOptimizerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/GetRecommendationSummariesPaginator.js

@@ -0,0 +1,32 @@
+import { GetRecommendationSummariesCommand, } from "../commands/GetRecommendationSummariesCommand";
+import { ComputeOptimizer } from "../ComputeOptimizer";
+import { ComputeOptimizerClient } from "../ComputeOptimizerClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetRecommendationSummariesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getRecommendationSummaries(input, ...args);
+};
+export async function* paginateGetRecommendationSummaries(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof ComputeOptimizer) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof ComputeOptimizerClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ComputeOptimizer | ComputeOptimizerClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/index.js

@@ -0,0 +1,6 @@
+export * from "./DescribeRecommendationExportJobsPaginator";
+export * from "./GetEnrollmentStatusesForOrganizationPaginator";
+export * from "./GetLambdaFunctionRecommendationsPaginator";
+export * from "./GetRecommendationPreferencesPaginator";
+export * from "./GetRecommendationSummariesPaginator";
+export * from "./Interfaces";