@aws-sdk/client-lambda 3.51.0 → 3.54.0

package/dist-cjs/waiters/index.js

@@ -2,5 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./waitForFunctionActive"), exports);
+tslib_1.__exportStar(require("./waitForFunctionActiveV2"), exports);
 tslib_1.__exportStar(require("./waitForFunctionExists"), exports);
 tslib_1.__exportStar(require("./waitForFunctionUpdated"), exports);
+tslib_1.__exportStar(require("./waitForFunctionUpdatedV2"), exports);

package/dist-cjs/waiters/waitForFunctionActiveV2.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilFunctionActiveV2 = exports.waitForFunctionActiveV2 = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const GetFunctionCommand_1 = require("../commands/GetFunctionCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetFunctionCommand_1.GetFunctionCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Active") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Failed") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.State;
+            };
+            if (returnComparator() === "Pending") {
+                return { state: util_waiter_1.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForFunctionActiveV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    return util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForFunctionActiveV2 = waitForFunctionActiveV2;
+const waitUntilFunctionActiveV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    const result = await util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return util_waiter_1.checkExceptions(result);
+};
+exports.waitUntilFunctionActiveV2 = waitUntilFunctionActiveV2;

package/dist-cjs/waiters/waitForFunctionUpdatedV2.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilFunctionUpdatedV2 = exports.waitForFunctionUpdatedV2 = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const GetFunctionCommand_1 = require("../commands/GetFunctionCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetFunctionCommand_1.GetFunctionCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.Configuration.LastUpdateStatus;
+            };
+            if (returnComparator() === "Successful") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.LastUpdateStatus;
+            };
+            if (returnComparator() === "Failed") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.Configuration.LastUpdateStatus;
+            };
+            if (returnComparator() === "InProgress") {
+                return { state: util_waiter_1.WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForFunctionUpdatedV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    return util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForFunctionUpdatedV2 = waitForFunctionUpdatedV2;
+const waitUntilFunctionUpdatedV2 = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    const result = await util_waiter_1.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return util_waiter_1.checkExceptions(result);
+};
+exports.waitUntilFunctionUpdatedV2 = waitUntilFunctionUpdatedV2;

package/dist-es/index.js

@@ -4,3 +4,4 @@ export * from "./commands";
 export * from "./models";
 export * from "./pagination";
 export * from "./waiters";
+export { LambdaServiceException } from "./models/LambdaServiceException";

package/dist-es/models/LambdaServiceException.js

@@ -0,0 +1,12 @@
+import { __extends } from "tslib";
+import { ServiceException as __ServiceException, } from "@aws-sdk/smithy-client";
+var LambdaServiceException = (function (_super) {
+    __extends(LambdaServiceException, _super);
+    function LambdaServiceException(options) {
+        var _this = _super.call(this, options) || this;
+        Object.setPrototypeOf(_this, LambdaServiceException.prototype);
+        return _this;
+    }
+    return LambdaServiceException;
+}(__ServiceException));
+export { LambdaServiceException };

package/dist-es/models/models_0.js

@@ -1,5 +1,6 @@
-import { __assign } from "tslib";
+import { __assign, __extends } from "tslib";
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { LambdaServiceException as __BaseException } from "./LambdaServiceException";
 export var AccountLimit;
 (function (AccountLimit) {
     AccountLimit.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -16,6 +17,86 @@ export var AddLayerVersionPermissionResponse;
 (function (AddLayerVersionPermissionResponse) {
     AddLayerVersionPermissionResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AddLayerVersionPermissionResponse || (AddLayerVersionPermissionResponse = {}));
+var InvalidParameterValueException = (function (_super) {
+    __extends(InvalidParameterValueException, _super);
+    function InvalidParameterValueException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidParameterValueException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidParameterValueException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidParameterValueException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return InvalidParameterValueException;
+}(__BaseException));
+export { InvalidParameterValueException };
+var PolicyLengthExceededException = (function (_super) {
+    __extends(PolicyLengthExceededException, _super);
+    function PolicyLengthExceededException(opts) {
+        var _this = _super.call(this, __assign({ name: "PolicyLengthExceededException", $fault: "client" }, opts)) || this;
+        _this.name = "PolicyLengthExceededException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, PolicyLengthExceededException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return PolicyLengthExceededException;
+}(__BaseException));
+export { PolicyLengthExceededException };
+var PreconditionFailedException = (function (_super) {
+    __extends(PreconditionFailedException, _super);
+    function PreconditionFailedException(opts) {
+        var _this = _super.call(this, __assign({ name: "PreconditionFailedException", $fault: "client" }, opts)) || this;
+        _this.name = "PreconditionFailedException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, PreconditionFailedException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return PreconditionFailedException;
+}(__BaseException));
+export { PreconditionFailedException };
+var ResourceConflictException = (function (_super) {
+    __extends(ResourceConflictException, _super);
+    function ResourceConflictException(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceConflictException", $fault: "client" }, opts)) || this;
+        _this.name = "ResourceConflictException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ResourceConflictException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return ResourceConflictException;
+}(__BaseException));
+export { ResourceConflictException };
+var ResourceNotFoundException = (function (_super) {
+    __extends(ResourceNotFoundException, _super);
+    function ResourceNotFoundException(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceNotFoundException", $fault: "client" }, opts)) || this;
+        _this.name = "ResourceNotFoundException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ResourceNotFoundException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return ResourceNotFoundException;
+}(__BaseException));
+export { ResourceNotFoundException };
+var ServiceException = (function (_super) {
+    __extends(ServiceException, _super);
+    function ServiceException(opts) {
+        var _this = _super.call(this, __assign({ name: "ServiceException", $fault: "server" }, opts)) || this;
+        _this.name = "ServiceException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, ServiceException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return ServiceException;
+}(__BaseException));
+export { ServiceException };
 export var ThrottleReason;
 (function (ThrottleReason) {
     ThrottleReason["CallerRateLimitExceeded"] = "CallerRateLimitExceeded";
@@ -24,6 +105,21 @@ export var ThrottleReason;
     ThrottleReason["ReservedFunctionConcurrentInvocationLimitExceeded"] = "ReservedFunctionConcurrentInvocationLimitExceeded";
     ThrottleReason["ReservedFunctionInvocationRateLimitExceeded"] = "ReservedFunctionInvocationRateLimitExceeded";
 })(ThrottleReason || (ThrottleReason = {}));
+var TooManyRequestsException = (function (_super) {
+    __extends(TooManyRequestsException, _super);
+    function TooManyRequestsException(opts) {
+        var _this = _super.call(this, __assign({ name: "TooManyRequestsException", $fault: "client" }, opts)) || this;
+        _this.name = "TooManyRequestsException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, TooManyRequestsException.prototype);
+        _this.retryAfterSeconds = opts.retryAfterSeconds;
+        _this.Type = opts.Type;
+        _this.Reason = opts.Reason;
+        return _this;
+    }
+    return TooManyRequestsException;
+}(__BaseException));
+export { TooManyRequestsException };
 export var AddPermissionRequest;
 (function (AddPermissionRequest) {
     AddPermissionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -135,6 +231,47 @@ export var EventSourceMappingConfiguration;
 (function (EventSourceMappingConfiguration) {
     EventSourceMappingConfiguration.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(EventSourceMappingConfiguration || (EventSourceMappingConfiguration = {}));
+var CodeSigningConfigNotFoundException = (function (_super) {
+    __extends(CodeSigningConfigNotFoundException, _super);
+    function CodeSigningConfigNotFoundException(opts) {
+        var _this = _super.call(this, __assign({ name: "CodeSigningConfigNotFoundException", $fault: "client" }, opts)) || this;
+        _this.name = "CodeSigningConfigNotFoundException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, CodeSigningConfigNotFoundException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return CodeSigningConfigNotFoundException;
+}(__BaseException));
+export { CodeSigningConfigNotFoundException };
+var CodeStorageExceededException = (function (_super) {
+    __extends(CodeStorageExceededException, _super);
+    function CodeStorageExceededException(opts) {
+        var _this = _super.call(this, __assign({ name: "CodeStorageExceededException", $fault: "client" }, opts)) || this;
+        _this.name = "CodeStorageExceededException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, CodeStorageExceededException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return CodeStorageExceededException;
+}(__BaseException));
+export { CodeStorageExceededException };
+var CodeVerificationFailedException = (function (_super) {
+    __extends(CodeVerificationFailedException, _super);
+    function CodeVerificationFailedException(opts) {
+        var _this = _super.call(this, __assign({ name: "CodeVerificationFailedException", $fault: "client" }, opts)) || this;
+        _this.name = "CodeVerificationFailedException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, CodeVerificationFailedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return CodeVerificationFailedException;
+}(__BaseException));
+export { CodeVerificationFailedException };
 export var FunctionCode;
 (function (FunctionCode) {
     FunctionCode.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.ZipFile && { ZipFile: SENSITIVE_STRING }))); };
@@ -162,6 +299,7 @@ export var PackageType;
 })(PackageType || (PackageType = {}));
 export var Runtime;
 (function (Runtime) {
+    Runtime["dotnet6"] = "dotnet6";
     Runtime["dotnetcore10"] = "dotnetcore1.0";
     Runtime["dotnetcore20"] = "dotnetcore2.0";
     Runtime["dotnetcore21"] = "dotnetcore2.1";
@@ -281,6 +419,20 @@ export var FunctionConfiguration;
         ImageConfigResponse: ImageConfigResponse.filterSensitiveLog(obj.ImageConfigResponse),
     }))); };
 })(FunctionConfiguration || (FunctionConfiguration = {}));
+var InvalidCodeSignatureException = (function (_super) {
+    __extends(InvalidCodeSignatureException, _super);
+    function InvalidCodeSignatureException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidCodeSignatureException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidCodeSignatureException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidCodeSignatureException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidCodeSignatureException;
+}(__BaseException));
+export { InvalidCodeSignatureException };
 export var DeleteAliasRequest;
 (function (DeleteAliasRequest) {
     DeleteAliasRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -297,6 +449,20 @@ export var DeleteEventSourceMappingRequest;
 (function (DeleteEventSourceMappingRequest) {
     DeleteEventSourceMappingRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DeleteEventSourceMappingRequest || (DeleteEventSourceMappingRequest = {}));
+var ResourceInUseException = (function (_super) {
+    __extends(ResourceInUseException, _super);
+    function ResourceInUseException(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceInUseException", $fault: "client" }, opts)) || this;
+        _this.name = "ResourceInUseException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ResourceInUseException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return ResourceInUseException;
+}(__BaseException));
+export { ResourceInUseException };
 export var DeleteFunctionRequest;
 (function (DeleteFunctionRequest) {
     DeleteFunctionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -435,6 +601,201 @@ export var GetProvisionedConcurrencyConfigResponse;
 (function (GetProvisionedConcurrencyConfigResponse) {
     GetProvisionedConcurrencyConfigResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(GetProvisionedConcurrencyConfigResponse || (GetProvisionedConcurrencyConfigResponse = {}));
+var ProvisionedConcurrencyConfigNotFoundException = (function (_super) {
+    __extends(ProvisionedConcurrencyConfigNotFoundException, _super);
+    function ProvisionedConcurrencyConfigNotFoundException(opts) {
+        var _this = _super.call(this, __assign({ name: "ProvisionedConcurrencyConfigNotFoundException", $fault: "client" }, opts)) || this;
+        _this.name = "ProvisionedConcurrencyConfigNotFoundException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ProvisionedConcurrencyConfigNotFoundException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return ProvisionedConcurrencyConfigNotFoundException;
+}(__BaseException));
+export { ProvisionedConcurrencyConfigNotFoundException };
+var EC2AccessDeniedException = (function (_super) {
+    __extends(EC2AccessDeniedException, _super);
+    function EC2AccessDeniedException(opts) {
+        var _this = _super.call(this, __assign({ name: "EC2AccessDeniedException", $fault: "server" }, opts)) || this;
+        _this.name = "EC2AccessDeniedException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, EC2AccessDeniedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EC2AccessDeniedException;
+}(__BaseException));
+export { EC2AccessDeniedException };
+var EC2ThrottledException = (function (_super) {
+    __extends(EC2ThrottledException, _super);
+    function EC2ThrottledException(opts) {
+        var _this = _super.call(this, __assign({ name: "EC2ThrottledException", $fault: "server" }, opts)) || this;
+        _this.name = "EC2ThrottledException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, EC2ThrottledException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EC2ThrottledException;
+}(__BaseException));
+export { EC2ThrottledException };
+var EC2UnexpectedException = (function (_super) {
+    __extends(EC2UnexpectedException, _super);
+    function EC2UnexpectedException(opts) {
+        var _this = _super.call(this, __assign({ name: "EC2UnexpectedException", $fault: "server" }, opts)) || this;
+        _this.name = "EC2UnexpectedException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, EC2UnexpectedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        _this.EC2ErrorCode = opts.EC2ErrorCode;
+        return _this;
+    }
+    return EC2UnexpectedException;
+}(__BaseException));
+export { EC2UnexpectedException };
+var EFSIOException = (function (_super) {
+    __extends(EFSIOException, _super);
+    function EFSIOException(opts) {
+        var _this = _super.call(this, __assign({ name: "EFSIOException", $fault: "client" }, opts)) || this;
+        _this.name = "EFSIOException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, EFSIOException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EFSIOException;
+}(__BaseException));
+export { EFSIOException };
+var EFSMountConnectivityException = (function (_super) {
+    __extends(EFSMountConnectivityException, _super);
+    function EFSMountConnectivityException(opts) {
+        var _this = _super.call(this, __assign({ name: "EFSMountConnectivityException", $fault: "client" }, opts)) || this;
+        _this.name = "EFSMountConnectivityException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, EFSMountConnectivityException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EFSMountConnectivityException;
+}(__BaseException));
+export { EFSMountConnectivityException };
+var EFSMountFailureException = (function (_super) {
+    __extends(EFSMountFailureException, _super);
+    function EFSMountFailureException(opts) {
+        var _this = _super.call(this, __assign({ name: "EFSMountFailureException", $fault: "client" }, opts)) || this;
+        _this.name = "EFSMountFailureException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, EFSMountFailureException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EFSMountFailureException;
+}(__BaseException));
+export { EFSMountFailureException };
+var EFSMountTimeoutException = (function (_super) {
+    __extends(EFSMountTimeoutException, _super);
+    function EFSMountTimeoutException(opts) {
+        var _this = _super.call(this, __assign({ name: "EFSMountTimeoutException", $fault: "client" }, opts)) || this;
+        _this.name = "EFSMountTimeoutException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, EFSMountTimeoutException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return EFSMountTimeoutException;
+}(__BaseException));
+export { EFSMountTimeoutException };
+var ENILimitReachedException = (function (_super) {
+    __extends(ENILimitReachedException, _super);
+    function ENILimitReachedException(opts) {
+        var _this = _super.call(this, __assign({ name: "ENILimitReachedException", $fault: "server" }, opts)) || this;
+        _this.name = "ENILimitReachedException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, ENILimitReachedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return ENILimitReachedException;
+}(__BaseException));
+export { ENILimitReachedException };
+var InvalidRequestContentException = (function (_super) {
+    __extends(InvalidRequestContentException, _super);
+    function InvalidRequestContentException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidRequestContentException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidRequestContentException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidRequestContentException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return InvalidRequestContentException;
+}(__BaseException));
+export { InvalidRequestContentException };
+var InvalidRuntimeException = (function (_super) {
+    __extends(InvalidRuntimeException, _super);
+    function InvalidRuntimeException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidRuntimeException", $fault: "server" }, opts)) || this;
+        _this.name = "InvalidRuntimeException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InvalidRuntimeException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidRuntimeException;
+}(__BaseException));
+export { InvalidRuntimeException };
+var InvalidSecurityGroupIDException = (function (_super) {
+    __extends(InvalidSecurityGroupIDException, _super);
+    function InvalidSecurityGroupIDException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidSecurityGroupIDException", $fault: "server" }, opts)) || this;
+        _this.name = "InvalidSecurityGroupIDException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InvalidSecurityGroupIDException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidSecurityGroupIDException;
+}(__BaseException));
+export { InvalidSecurityGroupIDException };
+var InvalidSubnetIDException = (function (_super) {
+    __extends(InvalidSubnetIDException, _super);
+    function InvalidSubnetIDException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidSubnetIDException", $fault: "server" }, opts)) || this;
+        _this.name = "InvalidSubnetIDException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InvalidSubnetIDException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidSubnetIDException;
+}(__BaseException));
+export { InvalidSubnetIDException };
+var InvalidZipFileException = (function (_super) {
+    __extends(InvalidZipFileException, _super);
+    function InvalidZipFileException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidZipFileException", $fault: "server" }, opts)) || this;
+        _this.name = "InvalidZipFileException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InvalidZipFileException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidZipFileException;
+}(__BaseException));
+export { InvalidZipFileException };
 export var InvocationType;
 (function (InvocationType) {
     InvocationType["DryRun"] = "DryRun";
@@ -454,6 +815,115 @@ export var InvocationResponse;
 (function (InvocationResponse) {
     InvocationResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Payload && { Payload: SENSITIVE_STRING }))); };
 })(InvocationResponse || (InvocationResponse = {}));
+var KMSAccessDeniedException = (function (_super) {
+    __extends(KMSAccessDeniedException, _super);
+    function KMSAccessDeniedException(opts) {
+        var _this = _super.call(this, __assign({ name: "KMSAccessDeniedException", $fault: "server" }, opts)) || this;
+        _this.name = "KMSAccessDeniedException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, KMSAccessDeniedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return KMSAccessDeniedException;
+}(__BaseException));
+export { KMSAccessDeniedException };
+var KMSDisabledException = (function (_super) {
+    __extends(KMSDisabledException, _super);
+    function KMSDisabledException(opts) {
+        var _this = _super.call(this, __assign({ name: "KMSDisabledException", $fault: "server" }, opts)) || this;
+        _this.name = "KMSDisabledException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, KMSDisabledException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return KMSDisabledException;
+}(__BaseException));
+export { KMSDisabledException };
+var KMSInvalidStateException = (function (_super) {
+    __extends(KMSInvalidStateException, _super);
+    function KMSInvalidStateException(opts) {
+        var _this = _super.call(this, __assign({ name: "KMSInvalidStateException", $fault: "server" }, opts)) || this;
+        _this.name = "KMSInvalidStateException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, KMSInvalidStateException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return KMSInvalidStateException;
+}(__BaseException));
+export { KMSInvalidStateException };
+var KMSNotFoundException = (function (_super) {
+    __extends(KMSNotFoundException, _super);
+    function KMSNotFoundException(opts) {
+        var _this = _super.call(this, __assign({ name: "KMSNotFoundException", $fault: "server" }, opts)) || this;
+        _this.name = "KMSNotFoundException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, KMSNotFoundException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return KMSNotFoundException;
+}(__BaseException));
+export { KMSNotFoundException };
+var RequestTooLargeException = (function (_super) {
+    __extends(RequestTooLargeException, _super);
+    function RequestTooLargeException(opts) {
+        var _this = _super.call(this, __assign({ name: "RequestTooLargeException", $fault: "client" }, opts)) || this;
+        _this.name = "RequestTooLargeException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, RequestTooLargeException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return RequestTooLargeException;
+}(__BaseException));
+export { RequestTooLargeException };
+var ResourceNotReadyException = (function (_super) {
+    __extends(ResourceNotReadyException, _super);
+    function ResourceNotReadyException(opts) {
+        var _this = _super.call(this, __assign({ name: "ResourceNotReadyException", $fault: "server" }, opts)) || this;
+        _this.name = "ResourceNotReadyException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, ResourceNotReadyException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return ResourceNotReadyException;
+}(__BaseException));
+export { ResourceNotReadyException };
+var SubnetIPAddressLimitReachedException = (function (_super) {
+    __extends(SubnetIPAddressLimitReachedException, _super);
+    function SubnetIPAddressLimitReachedException(opts) {
+        var _this = _super.call(this, __assign({ name: "SubnetIPAddressLimitReachedException", $fault: "server" }, opts)) || this;
+        _this.name = "SubnetIPAddressLimitReachedException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, SubnetIPAddressLimitReachedException.prototype);
+        _this.Type = opts.Type;
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return SubnetIPAddressLimitReachedException;
+}(__BaseException));
+export { SubnetIPAddressLimitReachedException };
+var UnsupportedMediaTypeException = (function (_super) {
+    __extends(UnsupportedMediaTypeException, _super);
+    function UnsupportedMediaTypeException(opts) {
+        var _this = _super.call(this, __assign({ name: "UnsupportedMediaTypeException", $fault: "client" }, opts)) || this;
+        _this.name = "UnsupportedMediaTypeException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, UnsupportedMediaTypeException.prototype);
+        _this.Type = opts.Type;
+        return _this;
+    }
+    return UnsupportedMediaTypeException;
+}(__BaseException));
+export { UnsupportedMediaTypeException };
 export var InvokeAsyncRequest;
 (function (InvokeAsyncRequest) {
     InvokeAsyncRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };