@aws-sdk/client-ec2 3.49.0 → 3.50.0

package/dist-es/commands/RestoreImageFromRecycleBinCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RestoreImageFromRecycleBinRequest, RestoreImageFromRecycleBinResult } from "../models/models_6";
+import { deserializeAws_ec2RestoreImageFromRecycleBinCommand, serializeAws_ec2RestoreImageFromRecycleBinCommand, } from "../protocols/Aws_ec2";
+var RestoreImageFromRecycleBinCommand = (function (_super) {
+    __extends(RestoreImageFromRecycleBinCommand, _super);
+    function RestoreImageFromRecycleBinCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RestoreImageFromRecycleBinCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EC2Client";
+        var commandName = "RestoreImageFromRecycleBinCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RestoreImageFromRecycleBinRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: RestoreImageFromRecycleBinResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RestoreImageFromRecycleBinCommand.prototype.serialize = function (input, context) {
+        return serializeAws_ec2RestoreImageFromRecycleBinCommand(input, context);
+    };
+    RestoreImageFromRecycleBinCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_ec2RestoreImageFromRecycleBinCommand(output, context);
+    };
+    return RestoreImageFromRecycleBinCommand;
+}($Command));
+export { RestoreImageFromRecycleBinCommand };

package/dist-es/commands/index.js

@@ -398,6 +398,7 @@ export * from "./ImportInstanceCommand";
 export * from "./ImportKeyPairCommand";
 export * from "./ImportSnapshotCommand";
 export * from "./ImportVolumeCommand";
+export * from "./ListImagesInRecycleBinCommand";
 export * from "./ListSnapshotsInRecycleBinCommand";
 export * from "./ModifyAddressAttributeCommand";
 export * from "./ModifyAvailabilityZoneGroupCommand";
@@ -492,6 +493,7 @@ export * from "./ResetInstanceAttributeCommand";
 export * from "./ResetNetworkInterfaceAttributeCommand";
 export * from "./ResetSnapshotAttributeCommand";
 export * from "./RestoreAddressToClassicCommand";
+export * from "./RestoreImageFromRecycleBinCommand";
 export * from "./RestoreManagedPrefixListVersionCommand";
 export * from "./RestoreSnapshotFromRecycleBinCommand";
 export * from "./RestoreSnapshotTierCommand";

package/dist-es/models/models_5.js

@@ -361,6 +361,18 @@ export var ImportVolumeResult;
 (function (ImportVolumeResult) {
     ImportVolumeResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ImportVolumeResult || (ImportVolumeResult = {}));
+export var ListImagesInRecycleBinRequest;
+(function (ListImagesInRecycleBinRequest) {
+    ListImagesInRecycleBinRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListImagesInRecycleBinRequest || (ListImagesInRecycleBinRequest = {}));
+export var ImageRecycleBinInfo;
+(function (ImageRecycleBinInfo) {
+    ImageRecycleBinInfo.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ImageRecycleBinInfo || (ImageRecycleBinInfo = {}));
+export var ListImagesInRecycleBinResult;
+(function (ListImagesInRecycleBinResult) {
+    ListImagesInRecycleBinResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListImagesInRecycleBinResult || (ListImagesInRecycleBinResult = {}));
 export var ListSnapshotsInRecycleBinRequest;
 (function (ListSnapshotsInRecycleBinRequest) {
     ListSnapshotsInRecycleBinRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -1170,15 +1182,3 @@ export var ResetImageAttributeRequest;
 (function (ResetImageAttributeRequest) {
     ResetImageAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ResetImageAttributeRequest || (ResetImageAttributeRequest = {}));
-export var ResetInstanceAttributeRequest;
-(function (ResetInstanceAttributeRequest) {
-    ResetInstanceAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(ResetInstanceAttributeRequest || (ResetInstanceAttributeRequest = {}));
-export var ResetNetworkInterfaceAttributeRequest;
-(function (ResetNetworkInterfaceAttributeRequest) {
-    ResetNetworkInterfaceAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(ResetNetworkInterfaceAttributeRequest || (ResetNetworkInterfaceAttributeRequest = {}));
-export var ResetSnapshotAttributeRequest;
-(function (ResetSnapshotAttributeRequest) {
-    ResetSnapshotAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
-})(ResetSnapshotAttributeRequest || (ResetSnapshotAttributeRequest = {}));

package/dist-es/models/models_6.js

@@ -1,4 +1,16 @@
 import { __assign } from "tslib";
+export var ResetInstanceAttributeRequest;
+(function (ResetInstanceAttributeRequest) {
+    ResetInstanceAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResetInstanceAttributeRequest || (ResetInstanceAttributeRequest = {}));
+export var ResetNetworkInterfaceAttributeRequest;
+(function (ResetNetworkInterfaceAttributeRequest) {
+    ResetNetworkInterfaceAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResetNetworkInterfaceAttributeRequest || (ResetNetworkInterfaceAttributeRequest = {}));
+export var ResetSnapshotAttributeRequest;
+(function (ResetSnapshotAttributeRequest) {
+    ResetSnapshotAttributeRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ResetSnapshotAttributeRequest || (ResetSnapshotAttributeRequest = {}));
 export var RestoreAddressToClassicRequest;
 (function (RestoreAddressToClassicRequest) {
     RestoreAddressToClassicRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -7,6 +19,14 @@ export var RestoreAddressToClassicResult;
 (function (RestoreAddressToClassicResult) {
     RestoreAddressToClassicResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(RestoreAddressToClassicResult || (RestoreAddressToClassicResult = {}));
+export var RestoreImageFromRecycleBinRequest;
+(function (RestoreImageFromRecycleBinRequest) {
+    RestoreImageFromRecycleBinRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RestoreImageFromRecycleBinRequest || (RestoreImageFromRecycleBinRequest = {}));
+export var RestoreImageFromRecycleBinResult;
+(function (RestoreImageFromRecycleBinResult) {
+    RestoreImageFromRecycleBinResult.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(RestoreImageFromRecycleBinResult || (RestoreImageFromRecycleBinResult = {}));
 export var RestoreManagedPrefixListVersionRequest;
 (function (RestoreManagedPrefixListVersionRequest) {
     RestoreManagedPrefixListVersionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListImagesInRecycleBinPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ListImagesInRecycleBinCommand, } from "../commands/ListImagesInRecycleBinCommand";
+import { EC2 } from "../EC2";
+import { EC2Client } from "../EC2Client";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListImagesInRecycleBinCommand(input)], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listImagesInRecycleBin.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListImagesInRecycleBin(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListImagesInRecycleBin_1() {
+        var token, hasNext, page;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof EC2)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof EC2Client)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments))))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected EC2 | EC2Client");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    token = page.NextToken;
+                    hasNext = !!token;
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -113,6 +113,7 @@ export * from "./GetTransitGatewayPrefixListReferencesPaginator";
 export * from "./GetTransitGatewayRouteTableAssociationsPaginator";
 export * from "./GetTransitGatewayRouteTablePropagationsPaginator";
 export * from "./GetVpnConnectionDeviceTypesPaginator";
+export * from "./ListImagesInRecycleBinPaginator";
 export * from "./ListSnapshotsInRecycleBinPaginator";
 export * from "./SearchLocalGatewayRoutesPaginator";
 export * from "./SearchTransitGatewayMulticastGroupsPaginator";

package/dist-es/protocols/Aws_ec2.js

@@ -4004,6 +4004,16 @@ export var serializeAws_ec2ImportVolumeCommand = function (input, context) { ret
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2ListImagesInRecycleBinCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2ListImagesInRecycleBinRequest(input, context)), { Action: "ListImagesInRecycleBin", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2ListSnapshotsInRecycleBinCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -4944,6 +4954,16 @@ export var serializeAws_ec2RestoreAddressToClassicCommand = function (input, con
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2RestoreImageFromRecycleBinCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2RestoreImageFromRecycleBinRequest(input, context)), { Action: "RestoreImageFromRecycleBin", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2RestoreManagedPrefixListVersionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -22794,6 +22814,50 @@ var deserializeAws_ec2ImportVolumeCommandError = function (output, context) { re
         }
     });
 }); };
+export var deserializeAws_ec2ListImagesInRecycleBinCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2ListImagesInRecycleBinCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2ListImagesInRecycleBinResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2ListImagesInRecycleBinCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, message;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = "UnknownError";
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        errorCode = parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode;
+                        response = __assign(__assign({}, parsedBody.Errors.Error), { name: "" + errorCode, message: parsedBody.Errors.Error.message || parsedBody.Errors.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
+                }
+                message = response.message || response.Message || errorCode;
+                response.message = message;
+                delete response.Message;
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
+        }
+    });
+}); };
 export var deserializeAws_ec2ListSnapshotsInRecycleBinCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -26930,6 +26994,50 @@ var deserializeAws_ec2RestoreAddressToClassicCommandError = function (output, co
         }
     });
 }); };
+export var deserializeAws_ec2RestoreImageFromRecycleBinCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2RestoreImageFromRecycleBinCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2RestoreImageFromRecycleBinResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2RestoreImageFromRecycleBinCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody, message;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = "UnknownError";
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        errorCode = parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode;
+                        response = __assign(__assign({}, parsedBody.Errors.Error), { name: "" + errorCode, message: parsedBody.Errors.Error.message || parsedBody.Errors.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
+                }
+                message = response.message || response.Message || errorCode;
+                response.message = message;
+                delete response.Message;
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
+        }
+    });
+}); };
 export var deserializeAws_ec2RestoreManagedPrefixListVersionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -41447,6 +41555,27 @@ var serializeAws_ec2LicenseSpecificationListRequest = function (input, context)
     }
     return entries;
 };
+var serializeAws_ec2ListImagesInRecycleBinRequest = function (input, context) {
+    var entries = {};
+    if (input.ImageIds !== undefined && input.ImageIds !== null) {
+        var memberEntries = serializeAws_ec2ImageIdStringList(input.ImageIds, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "ImageId." + key.substring(key.indexOf(".") + 1);
+            entries[loc] = value;
+        });
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults !== undefined && input.MaxResults !== null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2ListSnapshotsInRecycleBinRequest = function (input, context) {
     var entries = {};
     if (input.MaxResults !== undefined && input.MaxResults !== null) {
@@ -46264,6 +46393,16 @@ var serializeAws_ec2RestoreAddressToClassicRequest = function (input, context) {
     }
     return entries;
 };
+var serializeAws_ec2RestoreImageFromRecycleBinRequest = function (input, context) {
+    var entries = {};
+    if (input.ImageId !== undefined && input.ImageId !== null) {
+        entries["ImageId"] = input.ImageId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2RestoreManagedPrefixListVersionRequest = function (input, context) {
     var entries = {};
     if (input.DryRun !== undefined && input.DryRun !== null) {
@@ -59326,6 +59465,41 @@ var deserializeAws_ec2ImageList = function (output, context) {
         return deserializeAws_ec2Image(entry, context);
     });
 };
+var deserializeAws_ec2ImageRecycleBinInfo = function (output, context) {
+    var contents = {
+        ImageId: undefined,
+        Name: undefined,
+        Description: undefined,
+        RecycleBinEnterTime: undefined,
+        RecycleBinExitTime: undefined,
+    };
+    if (output["imageId"] !== undefined) {
+        contents.ImageId = __expectString(output["imageId"]);
+    }
+    if (output["name"] !== undefined) {
+        contents.Name = __expectString(output["name"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output["recycleBinEnterTime"] !== undefined) {
+        contents.RecycleBinEnterTime = __expectNonNull(__parseRfc3339DateTime(output["recycleBinEnterTime"]));
+    }
+    if (output["recycleBinExitTime"] !== undefined) {
+        contents.RecycleBinExitTime = __expectNonNull(__parseRfc3339DateTime(output["recycleBinExitTime"]));
+    }
+    return contents;
+};
+var deserializeAws_ec2ImageRecycleBinInfoList = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_ec2ImageRecycleBinInfo(entry, context);
+    });
+};
 var deserializeAws_ec2ImportClientVpnClientCertificateRevocationListResult = function (output, context) {
     var contents = {
         Return: undefined,
@@ -63003,6 +63177,22 @@ var deserializeAws_ec2LicenseList = function (output, context) {
         return deserializeAws_ec2LicenseConfiguration(entry, context);
     });
 };
+var deserializeAws_ec2ListImagesInRecycleBinResult = function (output, context) {
+    var contents = {
+        Images: undefined,
+        NextToken: undefined,
+    };
+    if (output.imageSet === "") {
+        contents.Images = [];
+    }
+    if (output["imageSet"] !== undefined && output["imageSet"]["item"] !== undefined) {
+        contents.Images = deserializeAws_ec2ImageRecycleBinInfoList(__getArrayIfSingleItem(output["imageSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 var deserializeAws_ec2ListSnapshotsInRecycleBinResult = function (output, context) {
     var contents = {
         Snapshots: undefined,
@@ -66993,6 +67183,15 @@ var deserializeAws_ec2RestoreAddressToClassicResult = function (output, context)
     }
     return contents;
 };
+var deserializeAws_ec2RestoreImageFromRecycleBinResult = function (output, context) {
+    var contents = {
+        Return: undefined,
+    };
+    if (output["return"] !== undefined) {
+        contents.Return = __parseBoolean(output["return"]);
+    }
+    return contents;
+};
 var deserializeAws_ec2RestoreManagedPrefixListVersionResult = function (output, context) {
     var contents = {
         PrefixList: undefined,

package/dist-types/EC2.d.ts

@@ -399,6 +399,7 @@ import { ImportInstanceCommandInput, ImportInstanceCommandOutput } from "./comma
 import { ImportKeyPairCommandInput, ImportKeyPairCommandOutput } from "./commands/ImportKeyPairCommand";
 import { ImportSnapshotCommandInput, ImportSnapshotCommandOutput } from "./commands/ImportSnapshotCommand";
 import { ImportVolumeCommandInput, ImportVolumeCommandOutput } from "./commands/ImportVolumeCommand";
+import { ListImagesInRecycleBinCommandInput, ListImagesInRecycleBinCommandOutput } from "./commands/ListImagesInRecycleBinCommand";
 import { ListSnapshotsInRecycleBinCommandInput, ListSnapshotsInRecycleBinCommandOutput } from "./commands/ListSnapshotsInRecycleBinCommand";
 import { ModifyAddressAttributeCommandInput, ModifyAddressAttributeCommandOutput } from "./commands/ModifyAddressAttributeCommand";
 import { ModifyAvailabilityZoneGroupCommandInput, ModifyAvailabilityZoneGroupCommandOutput } from "./commands/ModifyAvailabilityZoneGroupCommand";
@@ -493,6 +494,7 @@ import { ResetInstanceAttributeCommandInput, ResetInstanceAttributeCommandOutput
 import { ResetNetworkInterfaceAttributeCommandInput, ResetNetworkInterfaceAttributeCommandOutput } from "./commands/ResetNetworkInterfaceAttributeCommand";
 import { ResetSnapshotAttributeCommandInput, ResetSnapshotAttributeCommandOutput } from "./commands/ResetSnapshotAttributeCommand";
 import { RestoreAddressToClassicCommandInput, RestoreAddressToClassicCommandOutput } from "./commands/RestoreAddressToClassicCommand";
+import { RestoreImageFromRecycleBinCommandInput, RestoreImageFromRecycleBinCommandOutput } from "./commands/RestoreImageFromRecycleBinCommand";
 import { RestoreManagedPrefixListVersionCommandInput, RestoreManagedPrefixListVersionCommandOutput } from "./commands/RestoreManagedPrefixListVersionCommand";
 import { RestoreSnapshotFromRecycleBinCommandInput, RestoreSnapshotFromRecycleBinCommandOutput } from "./commands/RestoreSnapshotFromRecycleBinCommand";
 import { RestoreSnapshotTierCommandInput, RestoreSnapshotTierCommandOutput } from "./commands/RestoreSnapshotTierCommand";
@@ -1329,6 +1331,12 @@ export declare class EC2 extends EC2Client {
     /**
      * <p>Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance
      *      	that is either running or stopped.</p>
+     *          <important>
+     *             <p>By default, Amazon EC2 shuts down and reboots the instance before creating the AMI to ensure that everything on
+     *          the instance is stopped and in a consistent state during the creation process. If you're confident that your
+     *          instance is in a consistent state appropriate for AMI creation, use the <b>NoReboot</b>
+     *          parameter to prevent Amazon EC2 from shutting down and rebooting the instance. </p>
+     *          </important>
      *
      *
      *
@@ -2564,10 +2572,18 @@ export declare class EC2 extends EC2Client {
     deprovisionPublicIpv4PoolCidr(args: DeprovisionPublicIpv4PoolCidrCommandInput, cb: (err: any, data?: DeprovisionPublicIpv4PoolCidrCommandOutput) => void): void;
     deprovisionPublicIpv4PoolCidr(args: DeprovisionPublicIpv4PoolCidrCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeprovisionPublicIpv4PoolCidrCommandOutput) => void): void;
     /**
-     * <p>Deregisters the specified AMI. After you deregister an AMI, it can't be used to launch
-     * 			new instances; however, it doesn't affect any instances that you've already launched
-     * 			from the AMI. You'll continue to incur usage costs for those instances until you
-     * 			terminate them.</p>
+     * <p>Deregisters the specified AMI. After you deregister an AMI, it can't be used to
+     *        launch new instances.</p>
+     *
+     *
+     *          <p>If you deregister an AMI that matches a Recycle Bin retention rule, the AMI is
+     *       retained in the Recycle Bin for the specified retention period. For more information,
+     *       see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
+     *         Bin</a> in the Amazon Elastic Compute Cloud User Guide.</p>
+     *
+     *          <p>When you deregister an AMI, it doesn't affect any instances that you've already
+     *        launched from the AMI. You'll continue to incur usage costs for those instances until
+     *        you terminate them.</p>
      *    	     <p>When you deregister an Amazon EBS-backed AMI, it doesn't affect the snapshot that was
      * 			created for the root volume of the instance during the AMI creation process. When you
      * 			deregister an instance store-backed AMI, it doesn't affect the files that you uploaded
@@ -3901,6 +3917,9 @@ export declare class EC2 extends EC2Client {
      * <p>Discontinue faster launching for a Windows AMI, and clean up existing pre-provisioned snapshots.
      * 			When you disable faster launching, the AMI uses the standard launch process for each
      * 			instance. All pre-provisioned snapshots must be removed before you can enable faster launching again.</p>
+     * 		       <note>
+     * 			         <p>To change these settings, you must own the AMI.</p>
+     * 		       </note>
      */
     disableFastLaunch(args: DisableFastLaunchCommandInput, options?: __HttpHandlerOptions): Promise<DisableFastLaunchCommandOutput>;
     disableFastLaunch(args: DisableFastLaunchCommandInput, cb: (err: any, data?: DisableFastLaunchCommandOutput) => void): void;
@@ -4096,6 +4115,9 @@ export declare class EC2 extends EC2Client {
      * 			Then it creates a set of reserved snapshots that are used for subsequent launches. The
      * 			reserved snapshots are automatically replenished as they are used, depending on your
      * 			settings for launch frequency.</p>
+     * 		       <note>
+     * 			         <p>To change these settings, you must own the AMI.</p>
+     * 		       </note>
      */
     enableFastLaunch(args: EnableFastLaunchCommandInput, options?: __HttpHandlerOptions): Promise<EnableFastLaunchCommandOutput>;
     enableFastLaunch(args: EnableFastLaunchCommandInput, cb: (err: any, data?: EnableFastLaunchCommandOutput) => void): void;
@@ -4562,6 +4584,14 @@ export declare class EC2 extends EC2Client {
     importVolume(args: ImportVolumeCommandInput, options?: __HttpHandlerOptions): Promise<ImportVolumeCommandOutput>;
     importVolume(args: ImportVolumeCommandInput, cb: (err: any, data?: ImportVolumeCommandOutput) => void): void;
     importVolume(args: ImportVolumeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ImportVolumeCommandOutput) => void): void;
+    /**
+     * <p>Lists one or more AMIs that are currently in the Recycle Bin. For more information,
+     *       see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
+     *         Bin</a> in the Amazon Elastic Compute Cloud User Guide.</p>
+     */
+    listImagesInRecycleBin(args: ListImagesInRecycleBinCommandInput, options?: __HttpHandlerOptions): Promise<ListImagesInRecycleBinCommandOutput>;
+    listImagesInRecycleBin(args: ListImagesInRecycleBinCommandInput, cb: (err: any, data?: ListImagesInRecycleBinCommandOutput) => void): void;
+    listImagesInRecycleBin(args: ListImagesInRecycleBinCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListImagesInRecycleBinCommandOutput) => void): void;
     /**
      * <p>Lists one or more snapshots that are currently in the Recycle Bin.</p>
      */
@@ -5676,6 +5706,12 @@ export declare class EC2 extends EC2Client {
     restoreAddressToClassic(args: RestoreAddressToClassicCommandInput, options?: __HttpHandlerOptions): Promise<RestoreAddressToClassicCommandOutput>;
     restoreAddressToClassic(args: RestoreAddressToClassicCommandInput, cb: (err: any, data?: RestoreAddressToClassicCommandOutput) => void): void;
     restoreAddressToClassic(args: RestoreAddressToClassicCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RestoreAddressToClassicCommandOutput) => void): void;
+    /**
+     * <p>Restores an AMI from the Recycle Bin. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle Bin</a> in the Amazon Elastic Compute Cloud User Guide.</p>
+     */
+    restoreImageFromRecycleBin(args: RestoreImageFromRecycleBinCommandInput, options?: __HttpHandlerOptions): Promise<RestoreImageFromRecycleBinCommandOutput>;
+    restoreImageFromRecycleBin(args: RestoreImageFromRecycleBinCommandInput, cb: (err: any, data?: RestoreImageFromRecycleBinCommandOutput) => void): void;
+    restoreImageFromRecycleBin(args: RestoreImageFromRecycleBinCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RestoreImageFromRecycleBinCommandOutput) => void): void;
     /**
      * <p>Restores the entries from a previous version of a managed prefix list to a new version of the prefix list.</p>
      */