@aws-sdk/client-global-accelerator 3.192.0 → 3.193.0

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,309 @@
+export const ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: false,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseDualStack: {
+            builtIn: "AWS::UseDualStack",
+            required: true,
+            default: false,
+            documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
+            type: "Boolean",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "parseURL",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                            assign: "url",
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseDualStack",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                                    type: "error",
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: {
+                                            ref: "Endpoint",
+                                        },
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://globalaccelerator-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://globalaccelerator-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS is enabled but this partition does not support FIPS",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://globalaccelerator.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "DualStack is enabled but this partition does not support DualStack",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    endpoint: {
+                        url: "https://globalaccelerator.{Region}.{PartitionResult#dnsSuffix}",
+                        properties: {},
+                        headers: {},
+                    },
+                    type: "endpoint",
+                },
+            ],
+        },
+    ],
+};

package/dist-es/models/models_0.js

@@ -9,6 +9,11 @@ export var IpAddressFamily;
     IpAddressFamily["IPv4"] = "IPv4";
     IpAddressFamily["IPv6"] = "IPv6";
 })(IpAddressFamily || (IpAddressFamily = {}));
+export var AcceleratorStatus;
+(function (AcceleratorStatus) {
+    AcceleratorStatus["DEPLOYED"] = "DEPLOYED";
+    AcceleratorStatus["IN_PROGRESS"] = "IN_PROGRESS";
+})(AcceleratorStatus || (AcceleratorStatus = {}));
 export class AcceleratorNotDisabledException extends __BaseException {
     constructor(opts) {
         super({
@@ -126,6 +131,25 @@ export class LimitExceededException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export var HealthState;
+(function (HealthState) {
+    HealthState["HEALTHY"] = "HEALTHY";
+    HealthState["INITIAL"] = "INITIAL";
+    HealthState["UNHEALTHY"] = "UNHEALTHY";
+})(HealthState || (HealthState = {}));
+export class TransactionInProgressException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "TransactionInProgressException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TransactionInProgressException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TransactionInProgressException.prototype);
+        this.Message = opts.Message;
+    }
+}
 export var ByoipCidrState;
 (function (ByoipCidrState) {
     ByoipCidrState["ADVERTISING"] = "ADVERTISING";
@@ -192,6 +216,16 @@ export class AssociatedListenerFoundException extends __BaseException {
         this.Message = opts.Message;
     }
 }
+export var ClientAffinity;
+(function (ClientAffinity) {
+    ClientAffinity["NONE"] = "NONE";
+    ClientAffinity["SOURCE_IP"] = "SOURCE_IP";
+})(ClientAffinity || (ClientAffinity = {}));
+export var CustomRoutingAcceleratorStatus;
+(function (CustomRoutingAcceleratorStatus) {
+    CustomRoutingAcceleratorStatus["DEPLOYED"] = "DEPLOYED";
+    CustomRoutingAcceleratorStatus["IN_PROGRESS"] = "IN_PROGRESS";
+})(CustomRoutingAcceleratorStatus || (CustomRoutingAcceleratorStatus = {}));
 export var CustomRoutingProtocol;
 (function (CustomRoutingProtocol) {
     CustomRoutingProtocol["TCP"] = "TCP";
@@ -302,6 +336,18 @@ export const CustomRoutingEndpointDescriptionFilterSensitiveLog = (obj) => ({
 export const AddCustomRoutingEndpointsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const EndpointConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AddEndpointsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EndpointDescriptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AddEndpointsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const AdvertiseByoipCidrRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -365,18 +411,12 @@ export const CustomRoutingListenerFilterSensitiveLog = (obj) => ({
 export const CreateCustomRoutingListenerResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
-export const EndpointConfigurationFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
 export const PortOverrideFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const CreateEndpointGroupRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
-export const EndpointDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
 export const EndpointGroupFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -476,6 +516,9 @@ export const SocketAddressFilterSensitiveLog = (obj) => ({
 export const DestinationPortMappingFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const EndpointIdentifierFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const ListAcceleratorsRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -548,6 +591,9 @@ export const ProvisionByoipCidrResponseFilterSensitiveLog = (obj) => ({
 export const RemoveCustomRoutingEndpointsRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const RemoveEndpointsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const TagResourceRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/protocols/Aws_json1_1.js

@@ -2,7 +2,7 @@ import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { v4 as generateIdempotencyToken } from "uuid";
 import { GlobalAcceleratorServiceException as __BaseException } from "../models/GlobalAcceleratorServiceException";
-import { AcceleratorNotDisabledException, AcceleratorNotFoundException, AccessDeniedException, AssociatedEndpointGroupFoundException, AssociatedListenerFoundException, ByoipCidrNotFoundException, ConflictException, EndpointAlreadyExistsException, EndpointGroupAlreadyExistsException, EndpointGroupNotFoundException, EndpointNotFoundException, IncorrectCidrStateException, InternalServiceErrorException, InvalidArgumentException, InvalidNextTokenException, InvalidPortRangeException, LimitExceededException, ListenerNotFoundException, } from "../models/models_0";
+import { AcceleratorNotDisabledException, AcceleratorNotFoundException, AccessDeniedException, AssociatedEndpointGroupFoundException, AssociatedListenerFoundException, ByoipCidrNotFoundException, ConflictException, EndpointAlreadyExistsException, EndpointGroupAlreadyExistsException, EndpointGroupNotFoundException, EndpointNotFoundException, IncorrectCidrStateException, InternalServiceErrorException, InvalidArgumentException, InvalidNextTokenException, InvalidPortRangeException, LimitExceededException, ListenerNotFoundException, TransactionInProgressException, } from "../models/models_0";
 export const serializeAws_json1_1AddCustomRoutingEndpointsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
@@ -12,6 +12,15 @@ export const serializeAws_json1_1AddCustomRoutingEndpointsCommand = async (input
     body = JSON.stringify(serializeAws_json1_1AddCustomRoutingEndpointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_json1_1AddEndpointsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "GlobalAccelerator_V20180706.AddEndpoints",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1AddEndpointsRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_json1_1AdvertiseByoipCidrCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
@@ -336,6 +345,15 @@ export const serializeAws_json1_1RemoveCustomRoutingEndpointsCommand = async (in
     body = JSON.stringify(serializeAws_json1_1RemoveCustomRoutingEndpointsRequest(input, context));
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_json1_1RemoveEndpointsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "GlobalAccelerator_V20180706.RemoveEndpoints",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1RemoveEndpointsRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-amz-json-1.1",
@@ -477,6 +495,54 @@ const deserializeAws_json1_1AddCustomRoutingEndpointsCommandError = async (outpu
             });
     }
 };
+export const deserializeAws_json1_1AddEndpointsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1AddEndpointsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1AddEndpointsResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1AddEndpointsCommandError = 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.globalaccelerator#AccessDeniedException":
+            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "EndpointGroupNotFoundException":
+        case "com.amazonaws.globalaccelerator#EndpointGroupNotFoundException":
+            throw await deserializeAws_json1_1EndpointGroupNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.globalaccelerator#InternalServiceErrorException":
+            throw await deserializeAws_json1_1InternalServiceErrorExceptionResponse(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.globalaccelerator#InvalidArgumentException":
+            throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.globalaccelerator#LimitExceededException":
+            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+        case "TransactionInProgressException":
+        case "com.amazonaws.globalaccelerator#TransactionInProgressException":
+            throw await deserializeAws_json1_1TransactionInProgressExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_json1_1AdvertiseByoipCidrCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_json1_1AdvertiseByoipCidrCommandError(output, context);
@@ -1965,6 +2031,48 @@ const deserializeAws_json1_1RemoveCustomRoutingEndpointsCommandError = async (ou
             });
     }
 };
+export const deserializeAws_json1_1RemoveEndpointsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1RemoveEndpointsCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1RemoveEndpointsCommandError = 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.globalaccelerator#AccessDeniedException":
+            throw await deserializeAws_json1_1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "EndpointGroupNotFoundException":
+        case "com.amazonaws.globalaccelerator#EndpointGroupNotFoundException":
+            throw await deserializeAws_json1_1EndpointGroupNotFoundExceptionResponse(parsedOutput, context);
+        case "InternalServiceErrorException":
+        case "com.amazonaws.globalaccelerator#InternalServiceErrorException":
+            throw await deserializeAws_json1_1InternalServiceErrorExceptionResponse(parsedOutput, context);
+        case "InvalidArgumentException":
+        case "com.amazonaws.globalaccelerator#InvalidArgumentException":
+            throw await deserializeAws_json1_1InvalidArgumentExceptionResponse(parsedOutput, context);
+        case "TransactionInProgressException":
+        case "com.amazonaws.globalaccelerator#TransactionInProgressException":
+            throw await deserializeAws_json1_1TransactionInProgressExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_json1_1TagResourceCommandError(output, context);
@@ -2550,6 +2658,15 @@ const deserializeAws_json1_1ListenerNotFoundExceptionResponse = async (parsedOut
     });
     return __decorateServiceException(exception, body);
 };
+const deserializeAws_json1_1TransactionInProgressExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1TransactionInProgressException(body, context);
+    const exception = new TransactionInProgressException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
 const serializeAws_json1_1AddCustomRoutingEndpointsRequest = (input, context) => {
     return {
         ...(input.EndpointConfigurations != null && {
@@ -2558,6 +2675,14 @@ const serializeAws_json1_1AddCustomRoutingEndpointsRequest = (input, context) =>
         ...(input.EndpointGroupArn != null && { EndpointGroupArn: input.EndpointGroupArn }),
     };
 };
+const serializeAws_json1_1AddEndpointsRequest = (input, context) => {
+    return {
+        ...(input.EndpointConfigurations != null && {
+            EndpointConfigurations: serializeAws_json1_1EndpointConfigurations(input.EndpointConfigurations, context),
+        }),
+        ...(input.EndpointGroupArn != null && { EndpointGroupArn: input.EndpointGroupArn }),
+    };
+};
 const serializeAws_json1_1AdvertiseByoipCidrRequest = (input, context) => {
     return {
         ...(input.Cidr != null && { Cidr: input.Cidr }),
@@ -2800,6 +2925,21 @@ const serializeAws_json1_1EndpointConfigurations = (input, context) => {
         return serializeAws_json1_1EndpointConfiguration(entry, context);
     });
 };
+const serializeAws_json1_1EndpointIdentifier = (input, context) => {
+    return {
+        ...(input.ClientIPPreservationEnabled != null && {
+            ClientIPPreservationEnabled: input.ClientIPPreservationEnabled,
+        }),
+        ...(input.EndpointId != null && { EndpointId: input.EndpointId }),
+    };
+};
+const serializeAws_json1_1EndpointIdentifiers = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1EndpointIdentifier(entry, context);
+    });
+};
 const serializeAws_json1_1EndpointIds = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2921,6 +3061,14 @@ const serializeAws_json1_1RemoveCustomRoutingEndpointsRequest = (input, context)
         ...(input.EndpointIds != null && { EndpointIds: serializeAws_json1_1EndpointIds(input.EndpointIds, context) }),
     };
 };
+const serializeAws_json1_1RemoveEndpointsRequest = (input, context) => {
+    return {
+        ...(input.EndpointGroupArn != null && { EndpointGroupArn: input.EndpointGroupArn }),
+        ...(input.EndpointIdentifiers != null && {
+            EndpointIdentifiers: serializeAws_json1_1EndpointIdentifiers(input.EndpointIdentifiers, context),
+        }),
+    };
+};
 const serializeAws_json1_1Tag = (input, context) => {
     return {
         ...(input.Key != null && { Key: input.Key }),
@@ -3100,6 +3248,14 @@ const deserializeAws_json1_1AddCustomRoutingEndpointsResponse = (output, context
         EndpointGroupArn: __expectString(output.EndpointGroupArn),
     };
 };
+const deserializeAws_json1_1AddEndpointsResponse = (output, context) => {
+    return {
+        EndpointDescriptions: output.EndpointDescriptions != null
+            ? deserializeAws_json1_1EndpointDescriptions(output.EndpointDescriptions, context)
+            : undefined,
+        EndpointGroupArn: __expectString(output.EndpointGroupArn),
+    };
+};
 const deserializeAws_json1_1AdvertiseByoipCidrResponse = (output, context) => {
     return {
         ByoipCidr: output.ByoipCidr != null ? deserializeAws_json1_1ByoipCidr(output.ByoipCidr, context) : undefined,
@@ -3719,6 +3875,11 @@ const deserializeAws_json1_1Tags = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_json1_1TransactionInProgressException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
 const deserializeAws_json1_1UntagResourceResponse = (output, context) => {
     return {};
 };

package/dist-es/runtimeConfig.shared.js

@@ -1,10 +1,10 @@
 import { parseUrl } from "@aws-sdk/url-parser";
-import { defaultRegionInfoProvider } from "./endpoints";
+import { defaultEndpointResolver } from "./endpoint/endpointResolver";
 export const getRuntimeConfig = (config) => ({
     apiVersion: "2018-08-08",
     disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
     logger: config?.logger ?? {},
-    regionInfoProvider: config?.regionInfoProvider ?? defaultRegionInfoProvider,
     serviceId: config?.serviceId ?? "Global Accelerator",
     urlParser: config?.urlParser ?? parseUrl,
 });