@aws-sdk/client-route53resolver 3.370.0 → 3.374.0

package/dist-es/commands/UpdateOutpostResolverCommand.js

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

package/dist-es/commands/index.js

@@ -5,12 +5,14 @@ export * from "./AssociateResolverRuleCommand";
 export * from "./CreateFirewallDomainListCommand";
 export * from "./CreateFirewallRuleCommand";
 export * from "./CreateFirewallRuleGroupCommand";
+export * from "./CreateOutpostResolverCommand";
 export * from "./CreateResolverEndpointCommand";
 export * from "./CreateResolverQueryLogConfigCommand";
 export * from "./CreateResolverRuleCommand";
 export * from "./DeleteFirewallDomainListCommand";
 export * from "./DeleteFirewallRuleCommand";
 export * from "./DeleteFirewallRuleGroupCommand";
+export * from "./DeleteOutpostResolverCommand";
 export * from "./DeleteResolverEndpointCommand";
 export * from "./DeleteResolverQueryLogConfigCommand";
 export * from "./DeleteResolverRuleCommand";
@@ -23,6 +25,7 @@ export * from "./GetFirewallDomainListCommand";
 export * from "./GetFirewallRuleGroupAssociationCommand";
 export * from "./GetFirewallRuleGroupCommand";
 export * from "./GetFirewallRuleGroupPolicyCommand";
+export * from "./GetOutpostResolverCommand";
 export * from "./GetResolverConfigCommand";
 export * from "./GetResolverDnssecConfigCommand";
 export * from "./GetResolverEndpointCommand";
@@ -39,6 +42,7 @@ export * from "./ListFirewallDomainsCommand";
 export * from "./ListFirewallRuleGroupAssociationsCommand";
 export * from "./ListFirewallRuleGroupsCommand";
 export * from "./ListFirewallRulesCommand";
+export * from "./ListOutpostResolversCommand";
 export * from "./ListResolverConfigsCommand";
 export * from "./ListResolverDnssecConfigsCommand";
 export * from "./ListResolverEndpointIpAddressesCommand";
@@ -57,6 +61,7 @@ export * from "./UpdateFirewallConfigCommand";
 export * from "./UpdateFirewallDomainsCommand";
 export * from "./UpdateFirewallRuleCommand";
 export * from "./UpdateFirewallRuleGroupAssociationCommand";
+export * from "./UpdateOutpostResolverCommand";
 export * from "./UpdateResolverConfigCommand";
 export * from "./UpdateResolverDnssecConfigCommand";
 export * from "./UpdateResolverEndpointCommand";

package/dist-es/endpoint/ruleset.js

@@ -1,4 +1,4 @@
-const s = "required", t = "fn", u = "argv", v = "ref";
-const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = "stringEquals", g = { [s]: false, "type": "String" }, h = { [s]: true, "default": false, "type": "Boolean" }, i = { [v]: "Endpoint" }, j = { [t]: "booleanEquals", [u]: [{ [v]: "UseFIPS" }, true] }, k = { [t]: "booleanEquals", [u]: [{ [v]: "UseDualStack" }, true] }, l = {}, m = { [v]: "Region" }, n = { [t]: "booleanEquals", [u]: [true, { [t]: "getAttr", [u]: [{ [v]: e }, "supportsFIPS"] }] }, o = { [t]: "booleanEquals", [u]: [true, { [t]: "getAttr", [u]: [{ [v]: e }, "supportsDualStack"] }] }, p = [j], q = [k], r = [m];
-const _data = { version: "1.0", parameters: { Region: g, UseDualStack: h, UseFIPS: h, Endpoint: g }, rules: [{ conditions: [{ [t]: a, [u]: [i] }], type: b, rules: [{ conditions: p, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: q, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: i, properties: l, headers: l }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [t]: a, [u]: r }], type: b, rules: [{ conditions: [{ [t]: "aws.partition", [u]: r, assign: e }], type: b, rules: [{ conditions: [j, k], type: b, rules: [{ conditions: [n, o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: p, type: b, rules: [{ conditions: [n], type: b, rules: [{ type: b, rules: [{ conditions: [{ [t]: f, [u]: [m, "us-gov-east-1"] }], endpoint: { url: "https://route53resolver.us-gov-east-1.amazonaws.com", properties: l, headers: l }, type: d }, { conditions: [{ [t]: f, [u]: [m, "us-gov-west-1"] }], endpoint: { url: "https://route53resolver.us-gov-west-1.amazonaws.com", properties: l, headers: l }, type: d }, { endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: q, type: b, rules: [{ conditions: [o], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: l, headers: l }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dnsSuffix}", properties: l, headers: l }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://route53resolver.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
 export const ruleSet = _data;

package/dist-es/models/models_0.js

@@ -228,6 +228,28 @@ export const FirewallRuleGroupStatus = {
     DELETING: "DELETING",
     UPDATING: "UPDATING",
 };
+export const OutpostResolverStatus = {
+    ACTION_NEEDED: "ACTION_NEEDED",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED_CREATION: "FAILED_CREATION",
+    FAILED_DELETION: "FAILED_DELETION",
+    OPERATIONAL: "OPERATIONAL",
+    UPDATING: "UPDATING",
+};
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
 export const ResolverQueryLogConfigStatus = {
     Created: "CREATED",
     Creating: "CREATING",
@@ -351,6 +373,7 @@ export const IpAddressStatus = {
     FailedResourceGone: "FAILED_RESOURCE_GONE",
     RemapAttaching: "REMAP_ATTACHING",
     RemapDetaching: "REMAP_DETACHING",
+    UpdateFailed: "UPDATE_FAILED",
     Updating: "UPDATING",
 };
 export const SortOrder = {

package/dist-es/pagination/ListOutpostResolversPaginator.js

@@ -0,0 +1,25 @@
+import { ListOutpostResolversCommand, } from "../commands/ListOutpostResolversCommand";
+import { Route53ResolverClient } from "../Route53ResolverClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListOutpostResolversCommand(input), ...args);
+};
+export async function* paginateListOutpostResolvers(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 Route53ResolverClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected Route53Resolver | Route53ResolverClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -5,6 +5,7 @@ export * from "./ListFirewallDomainsPaginator";
 export * from "./ListFirewallRuleGroupAssociationsPaginator";
 export * from "./ListFirewallRuleGroupsPaginator";
 export * from "./ListFirewallRulesPaginator";
+export * from "./ListOutpostResolversPaginator";
 export * from "./ListResolverConfigsPaginator";
 export * from "./ListResolverDnssecConfigsPaginator";
 export * from "./ListResolverEndpointIpAddressesPaginator";

package/dist-es/protocols/Aws_json1_1.js

@@ -1,7 +1,7 @@
 import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, take, withBaseException, } from "@smithy/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
-import { AccessDeniedException, ConflictException, InternalServiceErrorException, InvalidNextTokenException, InvalidParameterException, InvalidPolicyDocument, InvalidRequestException, InvalidTagException, LimitExceededException, ResourceExistsException, ResourceInUseException, ResourceNotFoundException, ResourceUnavailableException, ThrottlingException, UnknownResourceException, ValidationException, } from "../models/models_0";
+import { AccessDeniedException, ConflictException, InternalServiceErrorException, InvalidNextTokenException, InvalidParameterException, InvalidPolicyDocument, InvalidRequestException, InvalidTagException, LimitExceededException, ResourceExistsException, ResourceInUseException, ResourceNotFoundException, ResourceUnavailableException, ServiceQuotaExceededException, ThrottlingException, UnknownResourceException, ValidationException, } from "../models/models_0";
 import { Route53ResolverServiceException as __BaseException } from "../models/Route53ResolverServiceException";
 export const se_AssociateFirewallRuleGroupCommand = async (input, context) => {
     const headers = sharedHeaders("AssociateFirewallRuleGroup");
@@ -45,6 +45,12 @@ export const se_CreateFirewallRuleGroupCommand = async (input, context) => {
     body = JSON.stringify(se_CreateFirewallRuleGroupRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_CreateOutpostResolverCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateOutpostResolver");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_CreateResolverEndpointCommand = async (input, context) => {
     const headers = sharedHeaders("CreateResolverEndpoint");
     let body;
@@ -81,6 +87,12 @@ export const se_DeleteFirewallRuleGroupCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_DeleteOutpostResolverCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteOutpostResolver");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_DeleteResolverEndpointCommand = async (input, context) => {
     const headers = sharedHeaders("DeleteResolverEndpoint");
     let body;
@@ -153,6 +165,12 @@ export const se_GetFirewallRuleGroupPolicyCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_GetOutpostResolverCommand = async (input, context) => {
+    const headers = sharedHeaders("GetOutpostResolver");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_GetResolverConfigCommand = async (input, context) => {
     const headers = sharedHeaders("GetResolverConfig");
     let body;
@@ -249,6 +267,12 @@ export const se_ListFirewallRulesCommand = async (input, context) => {
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_ListOutpostResolversCommand = async (input, context) => {
+    const headers = sharedHeaders("ListOutpostResolvers");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_ListResolverConfigsCommand = async (input, context) => {
     const headers = sharedHeaders("ListResolverConfigs");
     let body;
@@ -357,6 +381,12 @@ export const se_UpdateFirewallRuleGroupAssociationCommand = async (input, contex
     body = JSON.stringify(_json(input));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const se_UpdateOutpostResolverCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateOutpostResolver");
+    let body;
+    body = JSON.stringify(_json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const se_UpdateResolverConfigCommand = async (input, context) => {
     const headers = sharedHeaders("UpdateResolverConfig");
     let body;
@@ -722,6 +752,53 @@ const de_CreateFirewallRuleGroupCommandError = async (output, context) => {
             });
     }
 };
+export const de_CreateOutpostResolverCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CreateOutpostResolverCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateOutpostResolverCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.route53resolver#InternalServiceErrorException":
+            throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53resolver#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.route53resolver#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53resolver#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateResolverEndpointCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_CreateResolverEndpointCommandError(output, context);
@@ -1010,6 +1087,53 @@ const de_DeleteFirewallRuleGroupCommandError = async (output, context) => {
             });
     }
 };
+export const de_DeleteOutpostResolverCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_DeleteOutpostResolverCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteOutpostResolverCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.route53resolver#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.route53resolver#InternalServiceErrorException":
+            throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53resolver#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53resolver#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DeleteResolverEndpointCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_DeleteResolverEndpointCommandError(output, context);
@@ -1538,6 +1662,50 @@ const de_GetFirewallRuleGroupPolicyCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetOutpostResolverCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_GetOutpostResolverCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetOutpostResolverCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.route53resolver#InternalServiceErrorException":
+            throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53resolver#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53resolver#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetResolverConfigCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_GetResolverConfigCommandError(output, context);
@@ -2236,6 +2404,50 @@ const de_ListFirewallRulesCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListOutpostResolversCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_ListOutpostResolversCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListOutpostResolversCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.route53resolver#InternalServiceErrorException":
+            throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53resolver#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53resolver#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListResolverConfigsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_ListResolverConfigsCommandError(output, context);
@@ -3067,6 +3279,56 @@ const de_UpdateFirewallRuleGroupAssociationCommandError = async (output, context
             });
     }
 };
+export const de_UpdateOutpostResolverCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_UpdateOutpostResolverCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = _json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateOutpostResolverCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.route53resolver#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.route53resolver#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.route53resolver#InternalServiceErrorException":
+            throw await de_InternalServiceErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.route53resolver#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.route53resolver#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.route53resolver#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.route53resolver#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateResolverConfigCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return de_UpdateResolverConfigCommandError(output, context);
@@ -3381,6 +3643,15 @@ const de_ResourceUnavailableExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, body);
 };
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = _json(body);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
 const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
     const body = parsedOutput.body;
     const deserialized = _json(body);

package/dist-types/Route53Resolver.d.ts

@@ -6,12 +6,14 @@ import { AssociateResolverRuleCommandInput, AssociateResolverRuleCommandOutput }
 import { CreateFirewallDomainListCommandInput, CreateFirewallDomainListCommandOutput } from "./commands/CreateFirewallDomainListCommand";
 import { CreateFirewallRuleCommandInput, CreateFirewallRuleCommandOutput } from "./commands/CreateFirewallRuleCommand";
 import { CreateFirewallRuleGroupCommandInput, CreateFirewallRuleGroupCommandOutput } from "./commands/CreateFirewallRuleGroupCommand";
+import { CreateOutpostResolverCommandInput, CreateOutpostResolverCommandOutput } from "./commands/CreateOutpostResolverCommand";
 import { CreateResolverEndpointCommandInput, CreateResolverEndpointCommandOutput } from "./commands/CreateResolverEndpointCommand";
 import { CreateResolverQueryLogConfigCommandInput, CreateResolverQueryLogConfigCommandOutput } from "./commands/CreateResolverQueryLogConfigCommand";
 import { CreateResolverRuleCommandInput, CreateResolverRuleCommandOutput } from "./commands/CreateResolverRuleCommand";
 import { DeleteFirewallDomainListCommandInput, DeleteFirewallDomainListCommandOutput } from "./commands/DeleteFirewallDomainListCommand";
 import { DeleteFirewallRuleCommandInput, DeleteFirewallRuleCommandOutput } from "./commands/DeleteFirewallRuleCommand";
 import { DeleteFirewallRuleGroupCommandInput, DeleteFirewallRuleGroupCommandOutput } from "./commands/DeleteFirewallRuleGroupCommand";
+import { DeleteOutpostResolverCommandInput, DeleteOutpostResolverCommandOutput } from "./commands/DeleteOutpostResolverCommand";
 import { DeleteResolverEndpointCommandInput, DeleteResolverEndpointCommandOutput } from "./commands/DeleteResolverEndpointCommand";
 import { DeleteResolverQueryLogConfigCommandInput, DeleteResolverQueryLogConfigCommandOutput } from "./commands/DeleteResolverQueryLogConfigCommand";
 import { DeleteResolverRuleCommandInput, DeleteResolverRuleCommandOutput } from "./commands/DeleteResolverRuleCommand";
@@ -24,6 +26,7 @@ import { GetFirewallDomainListCommandInput, GetFirewallDomainListCommandOutput }
 import { GetFirewallRuleGroupAssociationCommandInput, GetFirewallRuleGroupAssociationCommandOutput } from "./commands/GetFirewallRuleGroupAssociationCommand";
 import { GetFirewallRuleGroupCommandInput, GetFirewallRuleGroupCommandOutput } from "./commands/GetFirewallRuleGroupCommand";
 import { GetFirewallRuleGroupPolicyCommandInput, GetFirewallRuleGroupPolicyCommandOutput } from "./commands/GetFirewallRuleGroupPolicyCommand";
+import { GetOutpostResolverCommandInput, GetOutpostResolverCommandOutput } from "./commands/GetOutpostResolverCommand";
 import { GetResolverConfigCommandInput, GetResolverConfigCommandOutput } from "./commands/GetResolverConfigCommand";
 import { GetResolverDnssecConfigCommandInput, GetResolverDnssecConfigCommandOutput } from "./commands/GetResolverDnssecConfigCommand";
 import { GetResolverEndpointCommandInput, GetResolverEndpointCommandOutput } from "./commands/GetResolverEndpointCommand";
@@ -40,6 +43,7 @@ import { ListFirewallDomainsCommandInput, ListFirewallDomainsCommandOutput } fro
 import { ListFirewallRuleGroupAssociationsCommandInput, ListFirewallRuleGroupAssociationsCommandOutput } from "./commands/ListFirewallRuleGroupAssociationsCommand";
 import { ListFirewallRuleGroupsCommandInput, ListFirewallRuleGroupsCommandOutput } from "./commands/ListFirewallRuleGroupsCommand";
 import { ListFirewallRulesCommandInput, ListFirewallRulesCommandOutput } from "./commands/ListFirewallRulesCommand";
+import { ListOutpostResolversCommandInput, ListOutpostResolversCommandOutput } from "./commands/ListOutpostResolversCommand";
 import { ListResolverConfigsCommandInput, ListResolverConfigsCommandOutput } from "./commands/ListResolverConfigsCommand";
 import { ListResolverDnssecConfigsCommandInput, ListResolverDnssecConfigsCommandOutput } from "./commands/ListResolverDnssecConfigsCommand";
 import { ListResolverEndpointIpAddressesCommandInput, ListResolverEndpointIpAddressesCommandOutput } from "./commands/ListResolverEndpointIpAddressesCommand";
@@ -58,6 +62,7 @@ import { UpdateFirewallConfigCommandInput, UpdateFirewallConfigCommandOutput } f
 import { UpdateFirewallDomainsCommandInput, UpdateFirewallDomainsCommandOutput } from "./commands/UpdateFirewallDomainsCommand";
 import { UpdateFirewallRuleCommandInput, UpdateFirewallRuleCommandOutput } from "./commands/UpdateFirewallRuleCommand";
 import { UpdateFirewallRuleGroupAssociationCommandInput, UpdateFirewallRuleGroupAssociationCommandOutput } from "./commands/UpdateFirewallRuleGroupAssociationCommand";
+import { UpdateOutpostResolverCommandInput, UpdateOutpostResolverCommandOutput } from "./commands/UpdateOutpostResolverCommand";
 import { UpdateResolverConfigCommandInput, UpdateResolverConfigCommandOutput } from "./commands/UpdateResolverConfigCommand";
 import { UpdateResolverDnssecConfigCommandInput, UpdateResolverDnssecConfigCommandOutput } from "./commands/UpdateResolverDnssecConfigCommand";
 import { UpdateResolverEndpointCommandInput, UpdateResolverEndpointCommandOutput } from "./commands/UpdateResolverEndpointCommand";
@@ -106,6 +111,12 @@ export interface Route53Resolver {
     createFirewallRuleGroup(args: CreateFirewallRuleGroupCommandInput, options?: __HttpHandlerOptions): Promise<CreateFirewallRuleGroupCommandOutput>;
     createFirewallRuleGroup(args: CreateFirewallRuleGroupCommandInput, cb: (err: any, data?: CreateFirewallRuleGroupCommandOutput) => void): void;
     createFirewallRuleGroup(args: CreateFirewallRuleGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateFirewallRuleGroupCommandOutput) => void): void;
+    /**
+     * @see {@link CreateOutpostResolverCommand}
+     */
+    createOutpostResolver(args: CreateOutpostResolverCommandInput, options?: __HttpHandlerOptions): Promise<CreateOutpostResolverCommandOutput>;
+    createOutpostResolver(args: CreateOutpostResolverCommandInput, cb: (err: any, data?: CreateOutpostResolverCommandOutput) => void): void;
+    createOutpostResolver(args: CreateOutpostResolverCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateOutpostResolverCommandOutput) => void): void;
     /**
      * @see {@link CreateResolverEndpointCommand}
      */
@@ -142,6 +153,12 @@ export interface Route53Resolver {
     deleteFirewallRuleGroup(args: DeleteFirewallRuleGroupCommandInput, options?: __HttpHandlerOptions): Promise<DeleteFirewallRuleGroupCommandOutput>;
     deleteFirewallRuleGroup(args: DeleteFirewallRuleGroupCommandInput, cb: (err: any, data?: DeleteFirewallRuleGroupCommandOutput) => void): void;
     deleteFirewallRuleGroup(args: DeleteFirewallRuleGroupCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteFirewallRuleGroupCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteOutpostResolverCommand}
+     */
+    deleteOutpostResolver(args: DeleteOutpostResolverCommandInput, options?: __HttpHandlerOptions): Promise<DeleteOutpostResolverCommandOutput>;
+    deleteOutpostResolver(args: DeleteOutpostResolverCommandInput, cb: (err: any, data?: DeleteOutpostResolverCommandOutput) => void): void;
+    deleteOutpostResolver(args: DeleteOutpostResolverCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteOutpostResolverCommandOutput) => void): void;
     /**
      * @see {@link DeleteResolverEndpointCommand}
      */
@@ -214,6 +231,12 @@ export interface Route53Resolver {
     getFirewallRuleGroupPolicy(args: GetFirewallRuleGroupPolicyCommandInput, options?: __HttpHandlerOptions): Promise<GetFirewallRuleGroupPolicyCommandOutput>;
     getFirewallRuleGroupPolicy(args: GetFirewallRuleGroupPolicyCommandInput, cb: (err: any, data?: GetFirewallRuleGroupPolicyCommandOutput) => void): void;
     getFirewallRuleGroupPolicy(args: GetFirewallRuleGroupPolicyCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetFirewallRuleGroupPolicyCommandOutput) => void): void;
+    /**
+     * @see {@link GetOutpostResolverCommand}
+     */
+    getOutpostResolver(args: GetOutpostResolverCommandInput, options?: __HttpHandlerOptions): Promise<GetOutpostResolverCommandOutput>;
+    getOutpostResolver(args: GetOutpostResolverCommandInput, cb: (err: any, data?: GetOutpostResolverCommandOutput) => void): void;
+    getOutpostResolver(args: GetOutpostResolverCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetOutpostResolverCommandOutput) => void): void;
     /**
      * @see {@link GetResolverConfigCommand}
      */
@@ -310,6 +333,12 @@ export interface Route53Resolver {
     listFirewallRules(args: ListFirewallRulesCommandInput, options?: __HttpHandlerOptions): Promise<ListFirewallRulesCommandOutput>;
     listFirewallRules(args: ListFirewallRulesCommandInput, cb: (err: any, data?: ListFirewallRulesCommandOutput) => void): void;
     listFirewallRules(args: ListFirewallRulesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListFirewallRulesCommandOutput) => void): void;
+    /**
+     * @see {@link ListOutpostResolversCommand}
+     */
+    listOutpostResolvers(args: ListOutpostResolversCommandInput, options?: __HttpHandlerOptions): Promise<ListOutpostResolversCommandOutput>;
+    listOutpostResolvers(args: ListOutpostResolversCommandInput, cb: (err: any, data?: ListOutpostResolversCommandOutput) => void): void;
+    listOutpostResolvers(args: ListOutpostResolversCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListOutpostResolversCommandOutput) => void): void;
     /**
      * @see {@link ListResolverConfigsCommand}
      */
@@ -418,6 +447,12 @@ export interface Route53Resolver {
     updateFirewallRuleGroupAssociation(args: UpdateFirewallRuleGroupAssociationCommandInput, options?: __HttpHandlerOptions): Promise<UpdateFirewallRuleGroupAssociationCommandOutput>;
     updateFirewallRuleGroupAssociation(args: UpdateFirewallRuleGroupAssociationCommandInput, cb: (err: any, data?: UpdateFirewallRuleGroupAssociationCommandOutput) => void): void;
     updateFirewallRuleGroupAssociation(args: UpdateFirewallRuleGroupAssociationCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateFirewallRuleGroupAssociationCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateOutpostResolverCommand}
+     */
+    updateOutpostResolver(args: UpdateOutpostResolverCommandInput, options?: __HttpHandlerOptions): Promise<UpdateOutpostResolverCommandOutput>;
+    updateOutpostResolver(args: UpdateOutpostResolverCommandInput, cb: (err: any, data?: UpdateOutpostResolverCommandOutput) => void): void;
+    updateOutpostResolver(args: UpdateOutpostResolverCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateOutpostResolverCommandOutput) => void): void;
     /**
      * @see {@link UpdateResolverConfigCommand}
      */