@aws-sdk/client-application-auto-scaling 3.294.0 → 3.295.0

package/dist-es/commands/RegisterScalableTargetCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { RegisterScalableTargetRequestFilterSensitiveLog, RegisterScalableTargetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1RegisterScalableTargetCommand, serializeAws_json1_1RegisterScalableTargetCommand, } from "../protocols/Aws_json1_1";
 export class RegisterScalableTargetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class RegisterScalableTargetCommand extends $Command {
             UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
         };
     }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         this.middlewareStack.use(getEndpointPlugin(configuration, RegisterScalableTargetCommand.getEndpointParameterInstructions()));

package/dist-es/commands/TagResourceCommand.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 { TagResourceRequestFilterSensitiveLog, TagResourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1TagResourceCommand, serializeAws_json1_1TagResourceCommand, } from "../protocols/Aws_json1_1";
+export class TagResourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, TagResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ApplicationAutoScalingClient";
+        const commandName = "TagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: TagResourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: TagResourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1TagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1TagResourceCommand(output, context);
+    }
+}

package/dist-es/commands/UntagResourceCommand.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 { UntagResourceRequestFilterSensitiveLog, UntagResourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1UntagResourceCommand, serializeAws_json1_1UntagResourceCommand, } from "../protocols/Aws_json1_1";
+export class UntagResourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UntagResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ApplicationAutoScalingClient";
+        const commandName = "UntagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UntagResourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UntagResourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1UntagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1UntagResourceCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -5,6 +5,9 @@ export * from "./DescribeScalableTargetsCommand";
 export * from "./DescribeScalingActivitiesCommand";
 export * from "./DescribeScalingPoliciesCommand";
 export * from "./DescribeScheduledActionsCommand";
+export * from "./ListTagsForResourceCommand";
 export * from "./PutScalingPolicyCommand";
 export * from "./PutScheduledActionCommand";
 export * from "./RegisterScalableTargetCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";

package/dist-es/models/models_0.js

@@ -175,6 +175,20 @@ export class FailedResourceAccessException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+        this.ResourceName = opts.ResourceName;
+    }
+}
 export class LimitExceededException extends __BaseException {
     constructor(opts) {
         super({
@@ -188,6 +202,20 @@ export class LimitExceededException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export class TooManyTagsException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TooManyTagsException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+        this.Message = opts.Message;
+        this.ResourceName = opts.ResourceName;
+    }
+}
 export const AlarmFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -284,6 +312,12 @@ export const ScheduledActionFilterSensitiveLog = (obj) => ({
 export const DescribeScheduledActionsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ListTagsForResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const PutScalingPolicyRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -302,3 +336,15 @@ export const RegisterScalableTargetRequestFilterSensitiveLog = (obj) => ({
 export const RegisterScalableTargetResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const TagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/protocols/Aws_json1_1.js

@@ -1,7 +1,7 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseDouble as __limitedParseDouble, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { ApplicationAutoScalingServiceException as __BaseException } from "../models/ApplicationAutoScalingServiceException";
-import { ConcurrentUpdateException, FailedResourceAccessException, InternalServiceException, InvalidNextTokenException, LimitExceededException, ObjectNotFoundException, ValidationException, } from "../models/models_0";
+import { ConcurrentUpdateException, FailedResourceAccessException, InternalServiceException, InvalidNextTokenException, LimitExceededException, ObjectNotFoundException, ResourceNotFoundException, TooManyTagsException, ValidationException, } from "../models/models_0";
 export const serializeAws_json1_1DeleteScalingPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
@@ -65,6 +65,15 @@ export const serializeAws_json1_1DescribeScheduledActionsCommand = async (input,
     body = JSON.stringify(serializeAws_json1_1DescribeScheduledActionsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AnyScaleFrontendService.ListTagsForResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_json1_1PutScalingPolicyCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
@@ -92,6 +101,24 @@ export const serializeAws_json1_1RegisterScalableTargetCommand = async (input, c
     body = JSON.stringify(serializeAws_json1_1RegisterScalableTargetRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AnyScaleFrontendService.TagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1TagResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AnyScaleFrontendService.UntagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1UntagResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const deserializeAws_json1_1DeleteScalingPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_json1_1DeleteScalingPolicyCommandError(output, context);
@@ -389,6 +416,39 @@ const deserializeAws_json1_1DescribeScheduledActionsCommandError = async (output
             });
     }
 };
+export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListTagsForResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_json1_1PutScalingPolicyCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_json1_1PutScalingPolicyCommandError(output, context);
@@ -524,6 +584,81 @@ const deserializeAws_json1_1RegisterScalableTargetCommandError = async (output,
             });
     }
 };
+export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1TagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1TagResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.applicationautoscaling#TooManyTagsException":
+            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.applicationautoscaling#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1UntagResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ResourceNotFoundException":
+        case "com.amazonaws.applicationautoscaling#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.applicationautoscaling#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 const deserializeAws_json1_1ConcurrentUpdateExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_json1_1ConcurrentUpdateException(body, context);
@@ -578,6 +713,24 @@ const deserializeAws_json1_1ObjectNotFoundExceptionResponse = async (parsedOutpu
     });
     return __decorateServiceException(exception, body);
 };
+const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
+    const exception = new TooManyTagsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
 const deserializeAws_json1_1ValidationExceptionResponse = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = deserializeAws_json1_1ValidationException(body, context);
@@ -667,6 +820,11 @@ const serializeAws_json1_1DescribeScheduledActionsRequest = (input, context) =>
         ...(input.ServiceNamespace != null && { ServiceNamespace: input.ServiceNamespace }),
     };
 };
+const serializeAws_json1_1ListTagsForResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+    };
+};
 const serializeAws_json1_1MetricDimension = (input, context) => {
     return {
         ...(input.Name != null && { Name: input.Name }),
@@ -727,6 +885,7 @@ const serializeAws_json1_1RegisterScalableTargetRequest = (input, context) => {
         ...(input.SuspendedState != null && {
             SuspendedState: serializeAws_json1_1SuspendedState(input.SuspendedState, context),
         }),
+        ...(input.Tags != null && { Tags: serializeAws_json1_1TagMap(input.Tags, context) }),
     };
 };
 const serializeAws_json1_1ResourceIdsMaxLen1600 = (input, context) => {
@@ -778,6 +937,28 @@ const serializeAws_json1_1SuspendedState = (input, context) => {
         ...(input.ScheduledScalingSuspended != null && { ScheduledScalingSuspended: input.ScheduledScalingSuspended }),
     };
 };
+const serializeAws_json1_1TagKeyList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_json1_1TagResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+        ...(input.Tags != null && { Tags: serializeAws_json1_1TagMap(input.Tags, context) }),
+    };
+};
 const serializeAws_json1_1TargetTrackingMetric = (input, context) => {
     return {
         ...(input.Dimensions != null && {
@@ -839,6 +1020,12 @@ const serializeAws_json1_1TargetTrackingScalingPolicyConfiguration = (input, con
         ...(input.TargetValue != null && { TargetValue: __serializeFloat(input.TargetValue) }),
     };
 };
+const serializeAws_json1_1UntagResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+        ...(input.TagKeys != null && { TagKeys: serializeAws_json1_1TagKeyList(input.TagKeys, context) }),
+    };
+};
 const deserializeAws_json1_1Alarm = (output, context) => {
     return {
         AlarmARN: __expectString(output.AlarmARN),
@@ -934,6 +1121,11 @@ const deserializeAws_json1_1LimitExceededException = (output, context) => {
         Message: __expectString(output.Message),
     };
 };
+const deserializeAws_json1_1ListTagsForResourceResponse = (output, context) => {
+    return {
+        Tags: output.Tags != null ? deserializeAws_json1_1TagMap(output.Tags, context) : undefined,
+    };
+};
 const deserializeAws_json1_1MetricDimension = (output, context) => {
     return {
         Name: __expectString(output.Name),
@@ -991,7 +1183,15 @@ const deserializeAws_json1_1PutScheduledActionResponse = (output, context) => {
     return {};
 };
 const deserializeAws_json1_1RegisterScalableTargetResponse = (output, context) => {
-    return {};
+    return {
+        ScalableTargetARN: __expectString(output.ScalableTargetARN),
+    };
+};
+const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+        ResourceName: __expectString(output.ResourceName),
+    };
 };
 const deserializeAws_json1_1ScalableTarget = (output, context) => {
     return {
@@ -1003,6 +1203,7 @@ const deserializeAws_json1_1ScalableTarget = (output, context) => {
         ResourceId: __expectString(output.ResourceId),
         RoleARN: __expectString(output.RoleARN),
         ScalableDimension: __expectString(output.ScalableDimension),
+        ScalableTargetARN: __expectString(output.ScalableTargetARN),
         ServiceNamespace: __expectString(output.ServiceNamespace),
         SuspendedState: output.SuspendedState != null ? deserializeAws_json1_1SuspendedState(output.SuspendedState, context) : undefined,
     };
@@ -1150,6 +1351,18 @@ const deserializeAws_json1_1SuspendedState = (output, context) => {
         ScheduledScalingSuspended: __expectBoolean(output.ScheduledScalingSuspended),
     };
 };
+const deserializeAws_json1_1TagMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_json1_1TagResourceResponse = (output, context) => {
+    return {};
+};
 const deserializeAws_json1_1TargetTrackingMetric = (output, context) => {
     return {
         Dimensions: output.Dimensions != null
@@ -1219,6 +1432,15 @@ const deserializeAws_json1_1TargetTrackingScalingPolicyConfiguration = (output,
         TargetValue: __limitedParseDouble(output.TargetValue),
     };
 };
+const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+        ResourceName: __expectString(output.ResourceName),
+    };
+};
+const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
+    return {};
+};
 const deserializeAws_json1_1ValidationException = (output, context) => {
     return {
         Message: __expectString(output.Message),

package/dist-types/ApplicationAutoScaling.d.ts

@@ -7,9 +7,12 @@ import { DescribeScalableTargetsCommandInput, DescribeScalableTargetsCommandOutp
 import { DescribeScalingActivitiesCommandInput, DescribeScalingActivitiesCommandOutput } from "./commands/DescribeScalingActivitiesCommand";
 import { DescribeScalingPoliciesCommandInput, DescribeScalingPoliciesCommandOutput } from "./commands/DescribeScalingPoliciesCommand";
 import { DescribeScheduledActionsCommandInput, DescribeScheduledActionsCommandOutput } from "./commands/DescribeScheduledActionsCommand";
+import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { PutScalingPolicyCommandInput, PutScalingPolicyCommandOutput } from "./commands/PutScalingPolicyCommand";
 import { PutScheduledActionCommandInput, PutScheduledActionCommandOutput } from "./commands/PutScheduledActionCommand";
 import { RegisterScalableTargetCommandInput, RegisterScalableTargetCommandOutput } from "./commands/RegisterScalableTargetCommand";
+import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 /**
  * <p>With Application Auto Scaling, you can configure automatic scaling for the following
  *       resources:</p>
@@ -150,6 +153,14 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, options?: __HttpHandlerOptions): Promise<DescribeScheduledActionsCommandOutput>;
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, cb: (err: any, data?: DescribeScheduledActionsCommandOutput) => void): void;
     describeScheduledActions(args: DescribeScheduledActionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeScheduledActionsCommandOutput) => void): void;
+    /**
+     * <p>Returns all the tags on the specified Application Auto Scaling scalable target.</p>
+     *          <p>For general information about tags, including the format and syntax, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services
+     *          resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
+     */
+    listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
+    listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     /**
      * <p>Creates or updates a scaling policy for an Application Auto Scaling scalable target.</p>
      *          <p>Each scalable target is identified by a service namespace, resource ID, and scalable
@@ -173,8 +184,8 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
      *          <p>For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html">Target tracking scaling policies</a> and <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html">Step scaling policies</a> in the <i>Application Auto Scaling User Guide</i>.</p>
      *          <note>
      *             <p>If a scalable target is deregistered, the scalable target is no longer available to
-     *             execute scaling policies. Any scaling policies that were specified for the scalable
-     *             target are deleted.</p>
+     *             use scaling policies. Any scaling policies that were specified for the scalable target
+     *             are deleted.</p>
      *          </note>
      */
     putScalingPolicy(args: PutScalingPolicyCommandInput, options?: __HttpHandlerOptions): Promise<PutScalingPolicyCommandOutput>;
@@ -186,7 +197,7 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
      *          dimension. A scheduled action applies to the scalable target identified by those three
      *          attributes. You cannot create a scheduled action until you have registered the resource as
      *          a scalable target.</p>
-     *          <p>When start and end times are specified with a recurring schedule using a cron expression
+     *          <p>When you specify start and end times with a recurring schedule using a cron expression
      *          or rates, they form the boundaries for when the recurring action starts and stops.</p>
      *          <p>To update a scheduled action, specify the parameters that you want to change. If you
      *          don't specify start and end times, the old values are deleted.</p>
@@ -201,7 +212,8 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
     putScheduledAction(args: PutScheduledActionCommandInput, cb: (err: any, data?: PutScheduledActionCommandOutput) => void): void;
     putScheduledAction(args: PutScheduledActionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: PutScheduledActionCommandOutput) => void): void;
     /**
-     * <p>Registers or updates a scalable target, the resource that you want to scale.</p>
+     * <p>Registers or updates a scalable target, which is the resource that you want to
+     *          scale.</p>
      *          <p>Scalable targets are uniquely identified by the combination of resource ID, scalable
      *          dimension, and namespace, which represents some capacity dimension of the underlying
      *          service.</p>
@@ -209,9 +221,9 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
      *          maximum capacity. If the specified resource is not active in the target service, this
      *          operation does not change the resource's current capacity. Otherwise, it changes the
      *          resource's current capacity to a value that is inside of this range.</p>
-     *          <p>If you choose to add a scaling policy, current capacity is adjustable within the
-     *          specified range when scaling starts. Application Auto Scaling scaling policies will not scale capacity to
-     *          values that are outside of the minimum and maximum range.</p>
+     *          <p>If you add a scaling policy, current capacity is adjustable within the specified range
+     *          when scaling starts. Application Auto Scaling scaling policies will not scale capacity to values that are
+     *          outside of the minimum and maximum range.</p>
      *          <p>After you register a scalable target, you do not need to register it again to use other
      *          Application Auto Scaling operations. To see which resources have been registered, use <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DescribeScalableTargets.html">DescribeScalableTargets</a>. You can also view the scaling policies for a service
      *          namespace by using <a href="https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DescribeScalableTargets.html">DescribeScalableTargets</a>. If you no longer need a scalable target, you can
@@ -220,14 +232,44 @@ export declare class ApplicationAutoScaling extends ApplicationAutoScalingClient
      *          parameters that identify the scalable target: resource ID, scalable dimension, and
      *          namespace. Any parameters that you don't specify are not changed by this update request. </p>
      *          <note>
-     *             <p>If you call the <code>RegisterScalableTarget</code> API to update an existing
-     *             scalable target, Application Auto Scaling retrieves the current capacity of the resource. If it is below
-     *             the minimum capacity or above the maximum capacity, Application Auto Scaling adjusts the capacity of the
-     *             scalable target to place it within these bounds, even if you don't include the
-     *                <code>MinCapacity</code> or <code>MaxCapacity</code> request parameters.</p>
+     *             <p>If you call the <code>RegisterScalableTarget</code> API operation to create a
+     *             scalable target, there might be a brief delay until the operation achieves <a href="https://en.wikipedia.org/wiki/Eventual_consistency">eventual
+     *             consistency</a>. You might become aware of this brief delay if you get unexpected
+     *             errors when performing sequential operations. The typical strategy is to retry the
+     *             request, and some Amazon Web Services SDKs include automatic backoff and retry logic.</p>
+     *             <p>If you call the <code>RegisterScalableTarget</code> API operation to update an
+     *             existing scalable target, Application Auto Scaling retrieves the current capacity of the resource. If
+     *             it's below the minimum capacity or above the maximum capacity, Application Auto Scaling adjusts the
+     *             capacity of the scalable target to place it within these bounds, even if you don't
+     *             include the <code>MinCapacity</code> or <code>MaxCapacity</code> request
+     *             parameters.</p>
      *          </note>
      */
     registerScalableTarget(args: RegisterScalableTargetCommandInput, options?: __HttpHandlerOptions): Promise<RegisterScalableTargetCommandOutput>;
     registerScalableTarget(args: RegisterScalableTargetCommandInput, cb: (err: any, data?: RegisterScalableTargetCommandOutput) => void): void;
     registerScalableTarget(args: RegisterScalableTargetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RegisterScalableTargetCommandOutput) => void): void;
+    /**
+     * <p>Adds or edits tags on an Application Auto Scaling scalable target.</p>
+     *          <p>Each tag consists of a tag key and a tag value, which are both case-sensitive strings.
+     *          To add a tag, specify a new tag key and a tag value. To edit a tag, specify an existing tag
+     *          key and a new tag value.</p>
+     *          <p>You can use this operation to tag an Application Auto Scaling scalable target, but you cannot tag a
+     *          scaling policy or scheduled action.</p>
+     *          <p>You can also add tags to an Application Auto Scaling scalable target while creating it
+     *          (<code>RegisterScalableTarget</code>).</p>
+     *          <p>For general information about tags, including the format and syntax, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services
+     *          resources</a> in the <i>Amazon Web Services General Reference</i>.</p>
+     *          <p>Use tags to control access to a scalable target. For more information, see <a href="https://docs.aws.amazon.com/autoscaling/application/userguide/resource-tagging-support.html">Tagging support
+     *          for Application Auto Scaling</a> in the <i>Application Auto Scaling User Guide</i>.</p>
+     */
+    tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
+    tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    /**
+     * <p>Deletes tags from an Application Auto Scaling scalable target. To delete a tag, specify the tag key and
+     *          the Application Auto Scaling scalable target.</p>
+     */
+    untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
+    untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
+    untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
 }