@aws-sdk/client-apprunner 3.199.0 → 3.200.0

package/dist-es/AppRunner.js

@@ -5,16 +5,19 @@ import { CreateConnectionCommand, } from "./commands/CreateConnectionCommand";
 import { CreateObservabilityConfigurationCommand, } from "./commands/CreateObservabilityConfigurationCommand";
 import { CreateServiceCommand, } from "./commands/CreateServiceCommand";
 import { CreateVpcConnectorCommand, } from "./commands/CreateVpcConnectorCommand";
+import { CreateVpcIngressConnectionCommand, } from "./commands/CreateVpcIngressConnectionCommand";
 import { DeleteAutoScalingConfigurationCommand, } from "./commands/DeleteAutoScalingConfigurationCommand";
 import { DeleteConnectionCommand, } from "./commands/DeleteConnectionCommand";
 import { DeleteObservabilityConfigurationCommand, } from "./commands/DeleteObservabilityConfigurationCommand";
 import { DeleteServiceCommand, } from "./commands/DeleteServiceCommand";
 import { DeleteVpcConnectorCommand, } from "./commands/DeleteVpcConnectorCommand";
+import { DeleteVpcIngressConnectionCommand, } from "./commands/DeleteVpcIngressConnectionCommand";
 import { DescribeAutoScalingConfigurationCommand, } from "./commands/DescribeAutoScalingConfigurationCommand";
 import { DescribeCustomDomainsCommand, } from "./commands/DescribeCustomDomainsCommand";
 import { DescribeObservabilityConfigurationCommand, } from "./commands/DescribeObservabilityConfigurationCommand";
 import { DescribeServiceCommand, } from "./commands/DescribeServiceCommand";
 import { DescribeVpcConnectorCommand, } from "./commands/DescribeVpcConnectorCommand";
+import { DescribeVpcIngressConnectionCommand, } from "./commands/DescribeVpcIngressConnectionCommand";
 import { DisassociateCustomDomainCommand, } from "./commands/DisassociateCustomDomainCommand";
 import { ListAutoScalingConfigurationsCommand, } from "./commands/ListAutoScalingConfigurationsCommand";
 import { ListConnectionsCommand, } from "./commands/ListConnectionsCommand";
@@ -23,12 +26,14 @@ import { ListOperationsCommand, } from "./commands/ListOperationsCommand";
 import { ListServicesCommand, } from "./commands/ListServicesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ListVpcConnectorsCommand, } from "./commands/ListVpcConnectorsCommand";
+import { ListVpcIngressConnectionsCommand, } from "./commands/ListVpcIngressConnectionsCommand";
 import { PauseServiceCommand, } from "./commands/PauseServiceCommand";
 import { ResumeServiceCommand, } from "./commands/ResumeServiceCommand";
 import { StartDeploymentCommand, } from "./commands/StartDeploymentCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateServiceCommand, } from "./commands/UpdateServiceCommand";
+import { UpdateVpcIngressConnectionCommand, } from "./commands/UpdateVpcIngressConnectionCommand";
 export class AppRunner extends AppRunnerClient {
     associateCustomDomain(args, optionsOrCb, cb) {
         const command = new AssociateCustomDomainCommand(args);
@@ -114,6 +119,20 @@ export class AppRunner extends AppRunnerClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createVpcIngressConnection(args, optionsOrCb, cb) {
+        const command = new CreateVpcIngressConnectionCommand(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);
+        }
+    }
     deleteAutoScalingConfiguration(args, optionsOrCb, cb) {
         const command = new DeleteAutoScalingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -184,6 +203,20 @@ export class AppRunner extends AppRunnerClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteVpcIngressConnection(args, optionsOrCb, cb) {
+        const command = new DeleteVpcIngressConnectionCommand(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);
+        }
+    }
     describeAutoScalingConfiguration(args, optionsOrCb, cb) {
         const command = new DescribeAutoScalingConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -254,6 +287,20 @@ export class AppRunner extends AppRunnerClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeVpcIngressConnection(args, optionsOrCb, cb) {
+        const command = new DescribeVpcIngressConnectionCommand(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);
+        }
+    }
     disassociateCustomDomain(args, optionsOrCb, cb) {
         const command = new DisassociateCustomDomainCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -366,6 +413,20 @@ export class AppRunner extends AppRunnerClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listVpcIngressConnections(args, optionsOrCb, cb) {
+        const command = new ListVpcIngressConnectionsCommand(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);
+        }
+    }
     pauseService(args, optionsOrCb, cb) {
         const command = new PauseServiceCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -450,4 +511,18 @@ export class AppRunner extends AppRunnerClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateVpcIngressConnection(args, optionsOrCb, cb) {
+        const command = new UpdateVpcIngressConnectionCommand(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);
+        }
+    }
 }

package/dist-es/commands/CreateVpcIngressConnectionCommand.js

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

package/dist-es/commands/DeleteVpcIngressConnectionCommand.js

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

package/dist-es/commands/DescribeVpcIngressConnectionCommand.js

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

package/dist-es/commands/ListVpcIngressConnectionsCommand.js

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

package/dist-es/commands/UpdateVpcIngressConnectionCommand.js

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

package/dist-es/commands/index.js

@@ -4,16 +4,19 @@ export * from "./CreateConnectionCommand";
 export * from "./CreateObservabilityConfigurationCommand";
 export * from "./CreateServiceCommand";
 export * from "./CreateVpcConnectorCommand";
+export * from "./CreateVpcIngressConnectionCommand";
 export * from "./DeleteAutoScalingConfigurationCommand";
 export * from "./DeleteConnectionCommand";
 export * from "./DeleteObservabilityConfigurationCommand";
 export * from "./DeleteServiceCommand";
 export * from "./DeleteVpcConnectorCommand";
+export * from "./DeleteVpcIngressConnectionCommand";
 export * from "./DescribeAutoScalingConfigurationCommand";
 export * from "./DescribeCustomDomainsCommand";
 export * from "./DescribeObservabilityConfigurationCommand";
 export * from "./DescribeServiceCommand";
 export * from "./DescribeVpcConnectorCommand";
+export * from "./DescribeVpcIngressConnectionCommand";
 export * from "./DisassociateCustomDomainCommand";
 export * from "./ListAutoScalingConfigurationsCommand";
 export * from "./ListConnectionsCommand";
@@ -22,9 +25,11 @@ export * from "./ListOperationsCommand";
 export * from "./ListServicesCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ListVpcConnectorsCommand";
+export * from "./ListVpcIngressConnectionsCommand";
 export * from "./PauseServiceCommand";
 export * from "./ResumeServiceCommand";
 export * from "./StartDeploymentCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateServiceCommand";
+export * from "./UpdateVpcIngressConnectionCommand";

package/dist-es/models/models_0.js

@@ -144,6 +144,17 @@ export var VpcConnectorStatus;
     VpcConnectorStatus["ACTIVE"] = "ACTIVE";
     VpcConnectorStatus["INACTIVE"] = "INACTIVE";
 })(VpcConnectorStatus || (VpcConnectorStatus = {}));
+export var VpcIngressConnectionStatus;
+(function (VpcIngressConnectionStatus) {
+    VpcIngressConnectionStatus["AVAILABLE"] = "AVAILABLE";
+    VpcIngressConnectionStatus["DELETED"] = "DELETED";
+    VpcIngressConnectionStatus["FAILED_CREATION"] = "FAILED_CREATION";
+    VpcIngressConnectionStatus["FAILED_DELETION"] = "FAILED_DELETION";
+    VpcIngressConnectionStatus["FAILED_UPDATE"] = "FAILED_UPDATE";
+    VpcIngressConnectionStatus["PENDING_CREATION"] = "PENDING_CREATION";
+    VpcIngressConnectionStatus["PENDING_DELETION"] = "PENDING_DELETION";
+    VpcIngressConnectionStatus["PENDING_UPDATE"] = "PENDING_UPDATE";
+})(VpcIngressConnectionStatus || (VpcIngressConnectionStatus = {}));
 export class ResourceNotFoundException extends __BaseException {
     constructor(opts) {
         super({
@@ -184,6 +195,9 @@ export const CertificateValidationRecordFilterSensitiveLog = (obj) => ({
 export const CustomDomainFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const VpcDNSTargetFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const AssociateCustomDomainResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -232,6 +246,9 @@ export const InstanceConfigurationFilterSensitiveLog = (obj) => ({
 export const EgressConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const IngressConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const NetworkConfigurationFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -302,6 +319,18 @@ export const VpcConnectorFilterSensitiveLog = (obj) => ({
 export const CreateVpcConnectorResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const IngressVpcConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateVpcIngressConnectionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VpcIngressConnectionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateVpcIngressConnectionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const DeleteAutoScalingConfigurationRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -333,6 +362,12 @@ export const DeleteVpcConnectorRequestFilterSensitiveLog = (obj) => ({
 export const DeleteVpcConnectorResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const DeleteVpcIngressConnectionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteVpcIngressConnectionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const DescribeAutoScalingConfigurationRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -364,6 +399,12 @@ export const DescribeVpcConnectorRequestFilterSensitiveLog = (obj) => ({
 export const DescribeVpcConnectorResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const DescribeVpcIngressConnectionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DescribeVpcIngressConnectionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const DisassociateCustomDomainRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -424,6 +465,18 @@ export const ListVpcConnectorsRequestFilterSensitiveLog = (obj) => ({
 export const ListVpcConnectorsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const ListVpcIngressConnectionsFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListVpcIngressConnectionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VpcIngressConnectionSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListVpcIngressConnectionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const PauseServiceRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -466,3 +519,9 @@ export const UpdateServiceResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.Service && { Service: ServiceFilterSensitiveLog(obj.Service) }),
 });
+export const UpdateVpcIngressConnectionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateVpcIngressConnectionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/ListVpcIngressConnectionsPaginator.js

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

package/dist-es/pagination/index.js

@@ -6,3 +6,4 @@ export * from "./ListObservabilityConfigurationsPaginator";
 export * from "./ListOperationsPaginator";
 export * from "./ListServicesPaginator";
 export * from "./ListVpcConnectorsPaginator";
+export * from "./ListVpcIngressConnectionsPaginator";