@aws-sdk/client-apprunner 3.51.0 → 3.54.0

package/dist-es/AppRunner.js

@@ -4,18 +4,22 @@ import { AssociateCustomDomainCommand, } from "./commands/AssociateCustomDomainC
 import { CreateAutoScalingConfigurationCommand, } from "./commands/CreateAutoScalingConfigurationCommand";
 import { CreateConnectionCommand, } from "./commands/CreateConnectionCommand";
 import { CreateServiceCommand, } from "./commands/CreateServiceCommand";
+import { CreateVpcConnectorCommand, } from "./commands/CreateVpcConnectorCommand";
 import { DeleteAutoScalingConfigurationCommand, } from "./commands/DeleteAutoScalingConfigurationCommand";
 import { DeleteConnectionCommand, } from "./commands/DeleteConnectionCommand";
 import { DeleteServiceCommand, } from "./commands/DeleteServiceCommand";
+import { DeleteVpcConnectorCommand, } from "./commands/DeleteVpcConnectorCommand";
 import { DescribeAutoScalingConfigurationCommand, } from "./commands/DescribeAutoScalingConfigurationCommand";
 import { DescribeCustomDomainsCommand, } from "./commands/DescribeCustomDomainsCommand";
 import { DescribeServiceCommand, } from "./commands/DescribeServiceCommand";
+import { DescribeVpcConnectorCommand, } from "./commands/DescribeVpcConnectorCommand";
 import { DisassociateCustomDomainCommand, } from "./commands/DisassociateCustomDomainCommand";
 import { ListAutoScalingConfigurationsCommand, } from "./commands/ListAutoScalingConfigurationsCommand";
 import { ListConnectionsCommand, } from "./commands/ListConnectionsCommand";
 import { ListOperationsCommand, } from "./commands/ListOperationsCommand";
 import { ListServicesCommand, } from "./commands/ListServicesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { ListVpcConnectorsCommand, } from "./commands/ListVpcConnectorsCommand";
 import { PauseServiceCommand, } from "./commands/PauseServiceCommand";
 import { ResumeServiceCommand, } from "./commands/ResumeServiceCommand";
 import { StartDeploymentCommand, } from "./commands/StartDeploymentCommand";
@@ -83,6 +87,20 @@ var AppRunner = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    AppRunner.prototype.createVpcConnector = function (args, optionsOrCb, cb) {
+        var command = new CreateVpcConnectorCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     AppRunner.prototype.deleteAutoScalingConfiguration = function (args, optionsOrCb, cb) {
         var command = new DeleteAutoScalingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -125,6 +143,20 @@ var AppRunner = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    AppRunner.prototype.deleteVpcConnector = function (args, optionsOrCb, cb) {
+        var command = new DeleteVpcConnectorCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     AppRunner.prototype.describeAutoScalingConfiguration = function (args, optionsOrCb, cb) {
         var command = new DescribeAutoScalingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -167,6 +199,20 @@ var AppRunner = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    AppRunner.prototype.describeVpcConnector = function (args, optionsOrCb, cb) {
+        var command = new DescribeVpcConnectorCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     AppRunner.prototype.disassociateCustomDomain = function (args, optionsOrCb, cb) {
         var command = new DisassociateCustomDomainCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -251,6 +297,20 @@ var AppRunner = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    AppRunner.prototype.listVpcConnectors = function (args, optionsOrCb, cb) {
+        var command = new ListVpcConnectorsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     AppRunner.prototype.pauseService = function (args, optionsOrCb, cb) {
         var command = new PauseServiceCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateVpcConnectorCommand.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 { CreateVpcConnectorRequest, CreateVpcConnectorResponse } from "../models/models_0";
+import { deserializeAws_json1_0CreateVpcConnectorCommand, serializeAws_json1_0CreateVpcConnectorCommand, } from "../protocols/Aws_json1_0";
+var CreateVpcConnectorCommand = (function (_super) {
+    __extends(CreateVpcConnectorCommand, _super);
+    function CreateVpcConnectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateVpcConnectorCommand.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 = "AppRunnerClient";
+        var commandName = "CreateVpcConnectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateVpcConnectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateVpcConnectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateVpcConnectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateVpcConnectorCommand(input, context);
+    };
+    CreateVpcConnectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateVpcConnectorCommand(output, context);
+    };
+    return CreateVpcConnectorCommand;
+}($Command));
+export { CreateVpcConnectorCommand };

package/dist-es/commands/DeleteVpcConnectorCommand.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 { DeleteVpcConnectorRequest, DeleteVpcConnectorResponse } from "../models/models_0";
+import { deserializeAws_json1_0DeleteVpcConnectorCommand, serializeAws_json1_0DeleteVpcConnectorCommand, } from "../protocols/Aws_json1_0";
+var DeleteVpcConnectorCommand = (function (_super) {
+    __extends(DeleteVpcConnectorCommand, _super);
+    function DeleteVpcConnectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteVpcConnectorCommand.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 = "AppRunnerClient";
+        var commandName = "DeleteVpcConnectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteVpcConnectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteVpcConnectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteVpcConnectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteVpcConnectorCommand(input, context);
+    };
+    DeleteVpcConnectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteVpcConnectorCommand(output, context);
+    };
+    return DeleteVpcConnectorCommand;
+}($Command));
+export { DeleteVpcConnectorCommand };

package/dist-es/commands/DescribeVpcConnectorCommand.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 { DescribeVpcConnectorRequest, DescribeVpcConnectorResponse } from "../models/models_0";
+import { deserializeAws_json1_0DescribeVpcConnectorCommand, serializeAws_json1_0DescribeVpcConnectorCommand, } from "../protocols/Aws_json1_0";
+var DescribeVpcConnectorCommand = (function (_super) {
+    __extends(DescribeVpcConnectorCommand, _super);
+    function DescribeVpcConnectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeVpcConnectorCommand.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 = "AppRunnerClient";
+        var commandName = "DescribeVpcConnectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeVpcConnectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeVpcConnectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeVpcConnectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DescribeVpcConnectorCommand(input, context);
+    };
+    DescribeVpcConnectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DescribeVpcConnectorCommand(output, context);
+    };
+    return DescribeVpcConnectorCommand;
+}($Command));
+export { DescribeVpcConnectorCommand };

package/dist-es/commands/ListVpcConnectorsCommand.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 { ListVpcConnectorsRequest, ListVpcConnectorsResponse } from "../models/models_0";
+import { deserializeAws_json1_0ListVpcConnectorsCommand, serializeAws_json1_0ListVpcConnectorsCommand, } from "../protocols/Aws_json1_0";
+var ListVpcConnectorsCommand = (function (_super) {
+    __extends(ListVpcConnectorsCommand, _super);
+    function ListVpcConnectorsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListVpcConnectorsCommand.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 = "AppRunnerClient";
+        var commandName = "ListVpcConnectorsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListVpcConnectorsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListVpcConnectorsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListVpcConnectorsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListVpcConnectorsCommand(input, context);
+    };
+    ListVpcConnectorsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListVpcConnectorsCommand(output, context);
+    };
+    return ListVpcConnectorsCommand;
+}($Command));
+export { ListVpcConnectorsCommand };

package/dist-es/commands/index.js

@@ -2,18 +2,22 @@ export * from "./AssociateCustomDomainCommand";
 export * from "./CreateAutoScalingConfigurationCommand";
 export * from "./CreateConnectionCommand";
 export * from "./CreateServiceCommand";
+export * from "./CreateVpcConnectorCommand";
 export * from "./DeleteAutoScalingConfigurationCommand";
 export * from "./DeleteConnectionCommand";
 export * from "./DeleteServiceCommand";
+export * from "./DeleteVpcConnectorCommand";
 export * from "./DescribeAutoScalingConfigurationCommand";
 export * from "./DescribeCustomDomainsCommand";
 export * from "./DescribeServiceCommand";
+export * from "./DescribeVpcConnectorCommand";
 export * from "./DisassociateCustomDomainCommand";
 export * from "./ListAutoScalingConfigurationsCommand";
 export * from "./ListConnectionsCommand";
 export * from "./ListOperationsCommand";
 export * from "./ListServicesCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./ListVpcConnectorsCommand";
 export * from "./PauseServiceCommand";
 export * from "./ResumeServiceCommand";
 export * from "./StartDeploymentCommand";

package/dist-es/endpoints.js

@@ -1,6 +1,31 @@
 import { __assign, __awaiter, __generator } from "tslib";
 import { getRegionInfo } from "@aws-sdk/config-resolver";
-var regionHash = {};
+var regionHash = {
+    "us-east-1": {
+        variants: [
+            {
+                hostname: "apprunner-fips.us-east-1.amazonaws.com",
+                tags: ["fips"],
+            },
+        ],
+    },
+    "us-east-2": {
+        variants: [
+            {
+                hostname: "apprunner-fips.us-east-2.amazonaws.com",
+                tags: ["fips"],
+            },
+        ],
+    },
+    "us-west-2": {
+        variants: [
+            {
+                hostname: "apprunner-fips.us-west-2.amazonaws.com",
+                tags: ["fips"],
+            },
+        ],
+    },
+};
 var partitionHash = {
     aws: {
         regions: [
@@ -20,6 +45,9 @@ var partitionHash = {
             "eu-west-1",
             "eu-west-2",
             "eu-west-3",
+            "fips-us-east-1",
+            "fips-us-east-2",
+            "fips-us-west-2",
             "me-south-1",
             "sa-east-1",
             "us-east-1",

package/dist-es/index.js

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

package/dist-es/models/AppRunnerServiceException.js

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

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 { AppRunnerServiceException as __BaseException } from "./AppRunnerServiceException";
 export var AssociateCustomDomainRequest;
 (function (AssociateCustomDomainRequest) {
     AssociateCustomDomainRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -32,6 +33,45 @@ export var AssociateCustomDomainResponse;
 (function (AssociateCustomDomainResponse) {
     AssociateCustomDomainResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AssociateCustomDomainResponse || (AssociateCustomDomainResponse = {}));
+var InternalServiceErrorException = (function (_super) {
+    __extends(InternalServiceErrorException, _super);
+    function InternalServiceErrorException(opts) {
+        var _this = _super.call(this, __assign({ name: "InternalServiceErrorException", $fault: "server" }, opts)) || this;
+        _this.name = "InternalServiceErrorException";
+        _this.$fault = "server";
+        Object.setPrototypeOf(_this, InternalServiceErrorException.prototype);
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InternalServiceErrorException;
+}(__BaseException));
+export { InternalServiceErrorException };
+var InvalidRequestException = (function (_super) {
+    __extends(InvalidRequestException, _super);
+    function InvalidRequestException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidRequestException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidRequestException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidRequestException.prototype);
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidRequestException;
+}(__BaseException));
+export { InvalidRequestException };
+var InvalidStateException = (function (_super) {
+    __extends(InvalidStateException, _super);
+    function InvalidStateException(opts) {
+        var _this = _super.call(this, __assign({ name: "InvalidStateException", $fault: "client" }, opts)) || this;
+        _this.name = "InvalidStateException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, InvalidStateException.prototype);
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return InvalidStateException;
+}(__BaseException));
+export { InvalidStateException };
 export var Tag;
 (function (Tag) {
     Tag.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -53,6 +93,19 @@ export var CreateAutoScalingConfigurationResponse;
 (function (CreateAutoScalingConfigurationResponse) {
     CreateAutoScalingConfigurationResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(CreateAutoScalingConfigurationResponse || (CreateAutoScalingConfigurationResponse = {}));
+var ServiceQuotaExceededException = (function (_super) {
+    __extends(ServiceQuotaExceededException, _super);
+    function ServiceQuotaExceededException(opts) {
+        var _this = _super.call(this, __assign({ name: "ServiceQuotaExceededException", $fault: "client" }, opts)) || this;
+        _this.name = "ServiceQuotaExceededException";
+        _this.$fault = "client";
+        Object.setPrototypeOf(_this, ServiceQuotaExceededException.prototype);
+        _this.Message = opts.Message;
+        return _this;
+    }
+    return ServiceQuotaExceededException;
+}(__BaseException));
+export { ServiceQuotaExceededException };
 export var ProviderType;
 (function (ProviderType) {
     ProviderType["GITHUB"] = "GITHUB";
@@ -93,13 +146,29 @@ export var InstanceConfiguration;
 (function (InstanceConfiguration) {
     InstanceConfiguration.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(InstanceConfiguration || (InstanceConfiguration = {}));
+export var EgressType;
+(function (EgressType) {
+    EgressType["DEFAULT"] = "DEFAULT";
+    EgressType["VPC"] = "VPC";
+})(EgressType || (EgressType = {}));
+export var EgressConfiguration;
+(function (EgressConfiguration) {
+    EgressConfiguration.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(EgressConfiguration || (EgressConfiguration = {}));
+export var NetworkConfiguration;
+(function (NetworkConfiguration) {
+    NetworkConfiguration.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(NetworkConfiguration || (NetworkConfiguration = {}));
 export var AuthenticationConfiguration;
 (function (AuthenticationConfiguration) {
     AuthenticationConfiguration.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(AuthenticationConfiguration || (AuthenticationConfiguration = {}));
 export var Runtime;
 (function (Runtime) {
+    Runtime["CORRETTO_11"] = "CORRETTO_11";
+    Runtime["CORRETTO_8"] = "CORRETTO_8";
     Runtime["NODEJS_12"] = "NODEJS_12";
+    Runtime["NODEJS_14"] = "NODEJS_14";
     Runtime["PYTHON_3"] = "PYTHON_3";
 })(Runtime || (Runtime = {}));
 export var CodeConfigurationValues;
@@ -131,7 +200,7 @@ export var CodeRepository;
 })(CodeRepository || (CodeRepository = {}));
 export var ImageConfiguration;
 (function (ImageConfiguration) {
-    ImageConfiguration.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.RuntimeEnvironmentVariables && { RuntimeEnvironmentVariables: SENSITIVE_STRING }))); };
+    ImageConfiguration.filterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.RuntimeEnvironmentVariables && { RuntimeEnvironmentVariables: SENSITIVE_STRING })), (obj.StartCommand && { StartCommand: SENSITIVE_STRING }))); };
 })(ImageConfiguration || (ImageConfiguration = {}));
 export var ImageRepositoryType;
 (function (ImageRepositoryType) {
@@ -177,6 +246,23 @@ export var CreateServiceResponse;
 (function (CreateServiceResponse) {
     CreateServiceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Service && { Service: Service.filterSensitiveLog(obj.Service) }))); };
 })(CreateServiceResponse || (CreateServiceResponse = {}));
+export var CreateVpcConnectorRequest;
+(function (CreateVpcConnectorRequest) {
+    CreateVpcConnectorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateVpcConnectorRequest || (CreateVpcConnectorRequest = {}));
+export var VpcConnectorStatus;
+(function (VpcConnectorStatus) {
+    VpcConnectorStatus["ACTIVE"] = "ACTIVE";
+    VpcConnectorStatus["INACTIVE"] = "INACTIVE";
+})(VpcConnectorStatus || (VpcConnectorStatus = {}));
+export var VpcConnector;
+(function (VpcConnector) {
+    VpcConnector.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(VpcConnector || (VpcConnector = {}));
+export var CreateVpcConnectorResponse;
+(function (CreateVpcConnectorResponse) {
+    CreateVpcConnectorResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(CreateVpcConnectorResponse || (CreateVpcConnectorResponse = {}));
 export var DeleteAutoScalingConfigurationRequest;
 (function (DeleteAutoScalingConfigurationRequest) {
     DeleteAutoScalingConfigurationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -185,6 +271,19 @@ export var DeleteAutoScalingConfigurationResponse;
 (function (DeleteAutoScalingConfigurationResponse) {
     DeleteAutoScalingConfigurationResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DeleteAutoScalingConfigurationResponse || (DeleteAutoScalingConfigurationResponse = {}));
+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.Message = opts.Message;
+        return _this;
+    }
+    return ResourceNotFoundException;
+}(__BaseException));
+export { ResourceNotFoundException };
 export var DeleteConnectionRequest;
 (function (DeleteConnectionRequest) {
     DeleteConnectionRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -201,6 +300,14 @@ export var DeleteServiceResponse;
 (function (DeleteServiceResponse) {
     DeleteServiceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Service && { Service: Service.filterSensitiveLog(obj.Service) }))); };
 })(DeleteServiceResponse || (DeleteServiceResponse = {}));
+export var DeleteVpcConnectorRequest;
+(function (DeleteVpcConnectorRequest) {
+    DeleteVpcConnectorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteVpcConnectorRequest || (DeleteVpcConnectorRequest = {}));
+export var DeleteVpcConnectorResponse;
+(function (DeleteVpcConnectorResponse) {
+    DeleteVpcConnectorResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DeleteVpcConnectorResponse || (DeleteVpcConnectorResponse = {}));
 export var DescribeAutoScalingConfigurationRequest;
 (function (DescribeAutoScalingConfigurationRequest) {
     DescribeAutoScalingConfigurationRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -225,6 +332,14 @@ export var DescribeServiceResponse;
 (function (DescribeServiceResponse) {
     DescribeServiceResponse.filterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Service && { Service: Service.filterSensitiveLog(obj.Service) }))); };
 })(DescribeServiceResponse || (DescribeServiceResponse = {}));
+export var DescribeVpcConnectorRequest;
+(function (DescribeVpcConnectorRequest) {
+    DescribeVpcConnectorRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeVpcConnectorRequest || (DescribeVpcConnectorRequest = {}));
+export var DescribeVpcConnectorResponse;
+(function (DescribeVpcConnectorResponse) {
+    DescribeVpcConnectorResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeVpcConnectorResponse || (DescribeVpcConnectorResponse = {}));
 export var DisassociateCustomDomainRequest;
 (function (DisassociateCustomDomainRequest) {
     DisassociateCustomDomainRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -303,6 +418,14 @@ export var ListTagsForResourceResponse;
 (function (ListTagsForResourceResponse) {
     ListTagsForResourceResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(ListTagsForResourceResponse || (ListTagsForResourceResponse = {}));
+export var ListVpcConnectorsRequest;
+(function (ListVpcConnectorsRequest) {
+    ListVpcConnectorsRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListVpcConnectorsRequest || (ListVpcConnectorsRequest = {}));
+export var ListVpcConnectorsResponse;
+(function (ListVpcConnectorsResponse) {
+    ListVpcConnectorsResponse.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ListVpcConnectorsResponse || (ListVpcConnectorsResponse = {}));
 export var PauseServiceRequest;
 (function (PauseServiceRequest) {
     PauseServiceRequest.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListVpcConnectorsPaginator.js

@@ -0,0 +1,74 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { AppRunner } from "../AppRunner";
+import { AppRunnerClient } from "../AppRunnerClient";
+import { ListVpcConnectorsCommand, } from "../commands/ListVpcConnectorsCommand";
+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 ListVpcConnectorsCommand(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.listVpcConnectors.apply(client, __spreadArray([input], __read(args)))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListVpcConnectors(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListVpcConnectors_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 AppRunner)) 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 AppRunnerClient)) 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 AppRunner | AppRunnerClient");
+                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

@@ -4,3 +4,4 @@ export * from "./ListAutoScalingConfigurationsPaginator";
 export * from "./ListConnectionsPaginator";
 export * from "./ListOperationsPaginator";
 export * from "./ListServicesPaginator";
+export * from "./ListVpcConnectorsPaginator";