@aws-sdk/client-ec2 3.294.0 → 3.296.0

package/dist-cjs/protocols/Aws_ec2.js

@@ -27151,6 +27151,20 @@ const serializeAws_ec2CreateNetworkInsightsPathRequest = (input, context) => {
     if (input.ClientToken != null) {
         entries["ClientToken"] = input.ClientToken;
     }
+    if (input.FilterAtSource != null) {
+        const memberEntries = serializeAws_ec2PathRequestFilter(input.FilterAtSource, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `FilterAtSource.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.FilterAtDestination != null) {
+        const memberEntries = serializeAws_ec2PathRequestFilter(input.FilterAtDestination, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `FilterAtDestination.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_ec2CreateNetworkInterfacePermissionRequest = (input, context) => {
@@ -41447,6 +41461,30 @@ const serializeAws_ec2PacketHeaderStatementRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2PathRequestFilter = (input, context) => {
+    const entries = {};
+    if (input.SourceAddress != null) {
+        entries["SourceAddress"] = input.SourceAddress;
+    }
+    if (input.SourcePortRange != null) {
+        const memberEntries = serializeAws_ec2RequestFilterPortRange(input.SourcePortRange, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `SourcePortRange.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.DestinationAddress != null) {
+        entries["DestinationAddress"] = input.DestinationAddress;
+    }
+    if (input.DestinationPortRange != null) {
+        const memberEntries = serializeAws_ec2RequestFilterPortRange(input.DestinationPortRange, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `DestinationPortRange.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_ec2PathStatementRequest = (input, context) => {
     const entries = {};
     if (input.PacketHeaderStatement != null) {
@@ -42622,6 +42660,16 @@ const serializeAws_ec2ReportInstanceStatusRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2RequestFilterPortRange = (input, context) => {
+    const entries = {};
+    if (input.FromPort != null) {
+        entries["FromPort"] = input.FromPort;
+    }
+    if (input.ToPort != null) {
+        entries["ToPort"] = input.ToPort;
+    }
+    return entries;
+};
 const serializeAws_ec2RequestHostIdList = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -46472,6 +46520,12 @@ const deserializeAws_ec2AdditionalDetail = (output, context) => {
     const contents = {
         AdditionalDetailType: undefined,
         Component: undefined,
+        VpcEndpointService: undefined,
+        RuleOptions: undefined,
+        RuleGroupTypePairs: undefined,
+        RuleGroupRuleOptionsPairs: undefined,
+        ServiceName: undefined,
+        LoadBalancers: undefined,
     };
     if (output["additionalDetailType"] !== undefined) {
         contents.AdditionalDetailType = (0, smithy_client_1.expectString)(output["additionalDetailType"]);
@@ -46479,6 +46533,37 @@ const deserializeAws_ec2AdditionalDetail = (output, context) => {
     if (output["component"] !== undefined) {
         contents.Component = deserializeAws_ec2AnalysisComponent(output["component"], context);
     }
+    if (output["vpcEndpointService"] !== undefined) {
+        contents.VpcEndpointService = deserializeAws_ec2AnalysisComponent(output["vpcEndpointService"], context);
+    }
+    if (output.ruleOptionSet === "") {
+        contents.RuleOptions = [];
+    }
+    else if (output["ruleOptionSet"] !== undefined && output["ruleOptionSet"]["item"] !== undefined) {
+        contents.RuleOptions = deserializeAws_ec2RuleOptionList((0, smithy_client_1.getArrayIfSingleItem)(output["ruleOptionSet"]["item"]), context);
+    }
+    if (output.ruleGroupTypePairSet === "") {
+        contents.RuleGroupTypePairs = [];
+    }
+    else if (output["ruleGroupTypePairSet"] !== undefined && output["ruleGroupTypePairSet"]["item"] !== undefined) {
+        contents.RuleGroupTypePairs = deserializeAws_ec2RuleGroupTypePairList((0, smithy_client_1.getArrayIfSingleItem)(output["ruleGroupTypePairSet"]["item"]), context);
+    }
+    if (output.ruleGroupRuleOptionsPairSet === "") {
+        contents.RuleGroupRuleOptionsPairs = [];
+    }
+    else if (output["ruleGroupRuleOptionsPairSet"] !== undefined &&
+        output["ruleGroupRuleOptionsPairSet"]["item"] !== undefined) {
+        contents.RuleGroupRuleOptionsPairs = deserializeAws_ec2RuleGroupRuleOptionsPairList((0, smithy_client_1.getArrayIfSingleItem)(output["ruleGroupRuleOptionsPairSet"]["item"]), context);
+    }
+    if (output["serviceName"] !== undefined) {
+        contents.ServiceName = (0, smithy_client_1.expectString)(output["serviceName"]);
+    }
+    if (output.loadBalancerSet === "") {
+        contents.LoadBalancers = [];
+    }
+    else if (output["loadBalancerSet"] !== undefined && output["loadBalancerSet"]["item"] !== undefined) {
+        contents.LoadBalancers = deserializeAws_ec2AnalysisComponentList((0, smithy_client_1.getArrayIfSingleItem)(output["loadBalancerSet"]["item"]), context);
+    }
     return contents;
 };
 const deserializeAws_ec2AdditionalDetailList = (output, context) => {
@@ -46890,6 +46975,9 @@ const deserializeAws_ec2AnalysisRouteTableRoute = (output, context) => {
         TransitGatewayId: undefined,
         VpcPeeringConnectionId: undefined,
         State: undefined,
+        CarrierGatewayId: undefined,
+        CoreNetworkArn: undefined,
+        LocalGatewayId: undefined,
     };
     if (output["destinationCidr"] !== undefined) {
         contents.DestinationCidr = (0, smithy_client_1.expectString)(output["destinationCidr"]);
@@ -46924,6 +47012,15 @@ const deserializeAws_ec2AnalysisRouteTableRoute = (output, context) => {
     if (output["state"] !== undefined) {
         contents.State = (0, smithy_client_1.expectString)(output["state"]);
     }
+    if (output["carrierGatewayId"] !== undefined) {
+        contents.CarrierGatewayId = (0, smithy_client_1.expectString)(output["carrierGatewayId"]);
+    }
+    if (output["coreNetworkArn"] !== undefined) {
+        contents.CoreNetworkArn = (0, smithy_client_1.expectString)(output["coreNetworkArn"]);
+    }
+    if (output["localGatewayId"] !== undefined) {
+        contents.LocalGatewayId = (0, smithy_client_1.expectString)(output["localGatewayId"]);
+    }
     return contents;
 };
 const deserializeAws_ec2AnalysisSecurityGroupRule = (output, context) => {
@@ -54391,6 +54488,8 @@ const deserializeAws_ec2Explanation = (output, context) => {
         TransitGatewayAttachment: undefined,
         ComponentAccount: undefined,
         ComponentRegion: undefined,
+        FirewallStatelessRule: undefined,
+        FirewallStatefulRule: undefined,
     };
     if (output["acl"] !== undefined) {
         contents.Acl = deserializeAws_ec2AnalysisComponent(output["acl"], context);
@@ -54567,6 +54666,12 @@ const deserializeAws_ec2Explanation = (output, context) => {
     if (output["componentRegion"] !== undefined) {
         contents.ComponentRegion = (0, smithy_client_1.expectString)(output["componentRegion"]);
     }
+    if (output["firewallStatelessRule"] !== undefined) {
+        contents.FirewallStatelessRule = deserializeAws_ec2FirewallStatelessRule(output["firewallStatelessRule"], context);
+    }
+    if (output["firewallStatefulRule"] !== undefined) {
+        contents.FirewallStatefulRule = deserializeAws_ec2FirewallStatefulRule(output["firewallStatefulRule"], context);
+    }
     return contents;
 };
 const deserializeAws_ec2ExplanationList = (output, context) => {
@@ -54858,6 +54963,120 @@ const deserializeAws_ec2FederatedAuthentication = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2FilterPortRange = (output, context) => {
+    const contents = {
+        FromPort: undefined,
+        ToPort: undefined,
+    };
+    if (output["fromPort"] !== undefined) {
+        contents.FromPort = (0, smithy_client_1.strictParseInt32)(output["fromPort"]);
+    }
+    if (output["toPort"] !== undefined) {
+        contents.ToPort = (0, smithy_client_1.strictParseInt32)(output["toPort"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2FirewallStatefulRule = (output, context) => {
+    const contents = {
+        RuleGroupArn: undefined,
+        Sources: undefined,
+        Destinations: undefined,
+        SourcePorts: undefined,
+        DestinationPorts: undefined,
+        Protocol: undefined,
+        RuleAction: undefined,
+        Direction: undefined,
+    };
+    if (output["ruleGroupArn"] !== undefined) {
+        contents.RuleGroupArn = (0, smithy_client_1.expectString)(output["ruleGroupArn"]);
+    }
+    if (output.sourceSet === "") {
+        contents.Sources = [];
+    }
+    else if (output["sourceSet"] !== undefined && output["sourceSet"]["item"] !== undefined) {
+        contents.Sources = deserializeAws_ec2ValueStringList((0, smithy_client_1.getArrayIfSingleItem)(output["sourceSet"]["item"]), context);
+    }
+    if (output.destinationSet === "") {
+        contents.Destinations = [];
+    }
+    else if (output["destinationSet"] !== undefined && output["destinationSet"]["item"] !== undefined) {
+        contents.Destinations = deserializeAws_ec2ValueStringList((0, smithy_client_1.getArrayIfSingleItem)(output["destinationSet"]["item"]), context);
+    }
+    if (output.sourcePortSet === "") {
+        contents.SourcePorts = [];
+    }
+    else if (output["sourcePortSet"] !== undefined && output["sourcePortSet"]["item"] !== undefined) {
+        contents.SourcePorts = deserializeAws_ec2PortRangeList((0, smithy_client_1.getArrayIfSingleItem)(output["sourcePortSet"]["item"]), context);
+    }
+    if (output.destinationPortSet === "") {
+        contents.DestinationPorts = [];
+    }
+    else if (output["destinationPortSet"] !== undefined && output["destinationPortSet"]["item"] !== undefined) {
+        contents.DestinationPorts = deserializeAws_ec2PortRangeList((0, smithy_client_1.getArrayIfSingleItem)(output["destinationPortSet"]["item"]), context);
+    }
+    if (output["protocol"] !== undefined) {
+        contents.Protocol = (0, smithy_client_1.expectString)(output["protocol"]);
+    }
+    if (output["ruleAction"] !== undefined) {
+        contents.RuleAction = (0, smithy_client_1.expectString)(output["ruleAction"]);
+    }
+    if (output["direction"] !== undefined) {
+        contents.Direction = (0, smithy_client_1.expectString)(output["direction"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2FirewallStatelessRule = (output, context) => {
+    const contents = {
+        RuleGroupArn: undefined,
+        Sources: undefined,
+        Destinations: undefined,
+        SourcePorts: undefined,
+        DestinationPorts: undefined,
+        Protocols: undefined,
+        RuleAction: undefined,
+        Priority: undefined,
+    };
+    if (output["ruleGroupArn"] !== undefined) {
+        contents.RuleGroupArn = (0, smithy_client_1.expectString)(output["ruleGroupArn"]);
+    }
+    if (output.sourceSet === "") {
+        contents.Sources = [];
+    }
+    else if (output["sourceSet"] !== undefined && output["sourceSet"]["item"] !== undefined) {
+        contents.Sources = deserializeAws_ec2ValueStringList((0, smithy_client_1.getArrayIfSingleItem)(output["sourceSet"]["item"]), context);
+    }
+    if (output.destinationSet === "") {
+        contents.Destinations = [];
+    }
+    else if (output["destinationSet"] !== undefined && output["destinationSet"]["item"] !== undefined) {
+        contents.Destinations = deserializeAws_ec2ValueStringList((0, smithy_client_1.getArrayIfSingleItem)(output["destinationSet"]["item"]), context);
+    }
+    if (output.sourcePortSet === "") {
+        contents.SourcePorts = [];
+    }
+    else if (output["sourcePortSet"] !== undefined && output["sourcePortSet"]["item"] !== undefined) {
+        contents.SourcePorts = deserializeAws_ec2PortRangeList((0, smithy_client_1.getArrayIfSingleItem)(output["sourcePortSet"]["item"]), context);
+    }
+    if (output.destinationPortSet === "") {
+        contents.DestinationPorts = [];
+    }
+    else if (output["destinationPortSet"] !== undefined && output["destinationPortSet"]["item"] !== undefined) {
+        contents.DestinationPorts = deserializeAws_ec2PortRangeList((0, smithy_client_1.getArrayIfSingleItem)(output["destinationPortSet"]["item"]), context);
+    }
+    if (output.protocolSet === "") {
+        contents.Protocols = [];
+    }
+    else if (output["protocolSet"] !== undefined && output["protocolSet"]["item"] !== undefined) {
+        contents.Protocols = deserializeAws_ec2ProtocolIntList((0, smithy_client_1.getArrayIfSingleItem)(output["protocolSet"]["item"]), context);
+    }
+    if (output["ruleAction"] !== undefined) {
+        contents.RuleAction = (0, smithy_client_1.expectString)(output["ruleAction"]);
+    }
+    if (output["priority"] !== undefined) {
+        contents.Priority = (0, smithy_client_1.strictParseInt32)(output["priority"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2FleetCapacityReservation = (output, context) => {
     const contents = {
         CapacityReservationId: undefined,
@@ -62290,6 +62509,8 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
         Protocol: undefined,
         DestinationPort: undefined,
         Tags: undefined,
+        FilterAtSource: undefined,
+        FilterAtDestination: undefined,
     };
     if (output["networkInsightsPathId"] !== undefined) {
         contents.NetworkInsightsPathId = (0, smithy_client_1.expectString)(output["networkInsightsPathId"]);
@@ -62330,6 +62551,12 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
     else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
         contents.Tags = deserializeAws_ec2TagList((0, smithy_client_1.getArrayIfSingleItem)(output["tagSet"]["item"]), context);
     }
+    if (output["filterAtSource"] !== undefined) {
+        contents.FilterAtSource = deserializeAws_ec2PathFilter(output["filterAtSource"], context);
+    }
+    if (output["filterAtDestination"] !== undefined) {
+        contents.FilterAtDestination = deserializeAws_ec2PathFilter(output["filterAtDestination"], context);
+    }
     return contents;
 };
 const deserializeAws_ec2NetworkInsightsPathList = (output, context) => {
@@ -62796,6 +63023,9 @@ const deserializeAws_ec2PathComponent = (output, context) => {
         TransitGatewayRouteTableRoute: undefined,
         Explanations: undefined,
         ElasticLoadBalancerListener: undefined,
+        FirewallStatelessRule: undefined,
+        FirewallStatefulRule: undefined,
+        ServiceName: undefined,
     };
     if (output["sequenceNumber"] !== undefined) {
         contents.SequenceNumber = (0, smithy_client_1.strictParseInt32)(output["sequenceNumber"]);
@@ -62854,6 +63084,15 @@ const deserializeAws_ec2PathComponent = (output, context) => {
     if (output["elasticLoadBalancerListener"] !== undefined) {
         contents.ElasticLoadBalancerListener = deserializeAws_ec2AnalysisComponent(output["elasticLoadBalancerListener"], context);
     }
+    if (output["firewallStatelessRule"] !== undefined) {
+        contents.FirewallStatelessRule = deserializeAws_ec2FirewallStatelessRule(output["firewallStatelessRule"], context);
+    }
+    if (output["firewallStatefulRule"] !== undefined) {
+        contents.FirewallStatefulRule = deserializeAws_ec2FirewallStatefulRule(output["firewallStatefulRule"], context);
+    }
+    if (output["serviceName"] !== undefined) {
+        contents.ServiceName = (0, smithy_client_1.expectString)(output["serviceName"]);
+    }
     return contents;
 };
 const deserializeAws_ec2PathComponentList = (output, context) => {
@@ -62863,6 +63102,27 @@ const deserializeAws_ec2PathComponentList = (output, context) => {
         return deserializeAws_ec2PathComponent(entry, context);
     });
 };
+const deserializeAws_ec2PathFilter = (output, context) => {
+    const contents = {
+        SourceAddress: undefined,
+        SourcePortRange: undefined,
+        DestinationAddress: undefined,
+        DestinationPortRange: undefined,
+    };
+    if (output["sourceAddress"] !== undefined) {
+        contents.SourceAddress = (0, smithy_client_1.expectString)(output["sourceAddress"]);
+    }
+    if (output["sourcePortRange"] !== undefined) {
+        contents.SourcePortRange = deserializeAws_ec2FilterPortRange(output["sourcePortRange"], context);
+    }
+    if (output["destinationAddress"] !== undefined) {
+        contents.DestinationAddress = (0, smithy_client_1.expectString)(output["destinationAddress"]);
+    }
+    if (output["destinationPortRange"] !== undefined) {
+        contents.DestinationPortRange = deserializeAws_ec2FilterPortRange(output["destinationPortRange"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2PathStatement = (output, context) => {
     const contents = {
         PacketHeaderStatement: undefined,
@@ -63504,6 +63764,13 @@ const deserializeAws_ec2PropagatingVgwList = (output, context) => {
         return deserializeAws_ec2PropagatingVgw(entry, context);
     });
 };
+const deserializeAws_ec2ProtocolIntList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return (0, smithy_client_1.strictParseInt32)(entry);
+    });
+};
 const deserializeAws_ec2ProtocolList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -65024,6 +65291,72 @@ const deserializeAws_ec2RouteTableList = (output, context) => {
         return deserializeAws_ec2RouteTable(entry, context);
     });
 };
+const deserializeAws_ec2RuleGroupRuleOptionsPair = (output, context) => {
+    const contents = {
+        RuleGroupArn: undefined,
+        RuleOptions: undefined,
+    };
+    if (output["ruleGroupArn"] !== undefined) {
+        contents.RuleGroupArn = (0, smithy_client_1.expectString)(output["ruleGroupArn"]);
+    }
+    if (output.ruleOptionSet === "") {
+        contents.RuleOptions = [];
+    }
+    else if (output["ruleOptionSet"] !== undefined && output["ruleOptionSet"]["item"] !== undefined) {
+        contents.RuleOptions = deserializeAws_ec2RuleOptionList((0, smithy_client_1.getArrayIfSingleItem)(output["ruleOptionSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2RuleGroupRuleOptionsPairList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2RuleGroupRuleOptionsPair(entry, context);
+    });
+};
+const deserializeAws_ec2RuleGroupTypePair = (output, context) => {
+    const contents = {
+        RuleGroupArn: undefined,
+        RuleGroupType: undefined,
+    };
+    if (output["ruleGroupArn"] !== undefined) {
+        contents.RuleGroupArn = (0, smithy_client_1.expectString)(output["ruleGroupArn"]);
+    }
+    if (output["ruleGroupType"] !== undefined) {
+        contents.RuleGroupType = (0, smithy_client_1.expectString)(output["ruleGroupType"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2RuleGroupTypePairList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2RuleGroupTypePair(entry, context);
+    });
+};
+const deserializeAws_ec2RuleOption = (output, context) => {
+    const contents = {
+        Keyword: undefined,
+        Settings: undefined,
+    };
+    if (output["keyword"] !== undefined) {
+        contents.Keyword = (0, smithy_client_1.expectString)(output["keyword"]);
+    }
+    if (output.settingSet === "") {
+        contents.Settings = [];
+    }
+    else if (output["settingSet"] !== undefined && output["settingSet"]["item"] !== undefined) {
+        contents.Settings = deserializeAws_ec2StringList((0, smithy_client_1.getArrayIfSingleItem)(output["settingSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2RuleOptionList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2RuleOption(entry, context);
+    });
+};
 const deserializeAws_ec2RunInstancesMonitoringEnabled = (output, context) => {
     const contents = {
         Enabled: undefined,

package/dist-es/commands/AcceptAddressTransferCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptAddressTransferRequestFilterSensitiveLog, AcceptAddressTransferResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptAddressTransferCommand, serializeAws_ec2AcceptAddressTransferCommand, } from "../protocols/Aws_ec2";
 export class AcceptAddressTransferCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptAddressTransferCommand extends $Command {
             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, AcceptAddressTransferCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptReservedInstancesExchangeQuoteCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptReservedInstancesExchangeQuoteRequestFilterSensitiveLog, AcceptReservedInstancesExchangeQuoteResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptReservedInstancesExchangeQuoteCommand, serializeAws_ec2AcceptReservedInstancesExchangeQuoteCommand, } from "../protocols/Aws_ec2";
 export class AcceptReservedInstancesExchangeQuoteCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptReservedInstancesExchangeQuoteCommand extends $Command {
             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, AcceptReservedInstancesExchangeQuoteCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptTransitGatewayMulticastDomainAssociationsCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptTransitGatewayMulticastDomainAssociationsRequestFilterSensitiveLog, AcceptTransitGatewayMulticastDomainAssociationsResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptTransitGatewayMulticastDomainAssociationsCommand, serializeAws_ec2AcceptTransitGatewayMulticastDomainAssociationsCommand, } from "../protocols/Aws_ec2";
 export class AcceptTransitGatewayMulticastDomainAssociationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptTransitGatewayMulticastDomainAssociationsCommand extends $Com
             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, AcceptTransitGatewayMulticastDomainAssociationsCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptTransitGatewayPeeringAttachmentCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptTransitGatewayPeeringAttachmentRequestFilterSensitiveLog, AcceptTransitGatewayPeeringAttachmentResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptTransitGatewayPeeringAttachmentCommand, serializeAws_ec2AcceptTransitGatewayPeeringAttachmentCommand, } from "../protocols/Aws_ec2";
 export class AcceptTransitGatewayPeeringAttachmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptTransitGatewayPeeringAttachmentCommand extends $Command {
             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, AcceptTransitGatewayPeeringAttachmentCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptTransitGatewayVpcAttachmentCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptTransitGatewayVpcAttachmentRequestFilterSensitiveLog, AcceptTransitGatewayVpcAttachmentResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptTransitGatewayVpcAttachmentCommand, serializeAws_ec2AcceptTransitGatewayVpcAttachmentCommand, } from "../protocols/Aws_ec2";
 export class AcceptTransitGatewayVpcAttachmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptTransitGatewayVpcAttachmentCommand extends $Command {
             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, AcceptTransitGatewayVpcAttachmentCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptVpcEndpointConnectionsCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptVpcEndpointConnectionsRequestFilterSensitiveLog, AcceptVpcEndpointConnectionsResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptVpcEndpointConnectionsCommand, serializeAws_ec2AcceptVpcEndpointConnectionsCommand, } from "../protocols/Aws_ec2";
 export class AcceptVpcEndpointConnectionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptVpcEndpointConnectionsCommand extends $Command {
             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, AcceptVpcEndpointConnectionsCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AcceptVpcPeeringConnectionCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AcceptVpcPeeringConnectionRequestFilterSensitiveLog, AcceptVpcPeeringConnectionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AcceptVpcPeeringConnectionCommand, serializeAws_ec2AcceptVpcPeeringConnectionCommand, } from "../protocols/Aws_ec2";
 export class AcceptVpcPeeringConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AcceptVpcPeeringConnectionCommand extends $Command {
             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, AcceptVpcPeeringConnectionCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AdvertiseByoipCidrCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AdvertiseByoipCidrRequestFilterSensitiveLog, AdvertiseByoipCidrResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AdvertiseByoipCidrCommand, serializeAws_ec2AdvertiseByoipCidrCommand, } from "../protocols/Aws_ec2";
 export class AdvertiseByoipCidrCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AdvertiseByoipCidrCommand extends $Command {
             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, AdvertiseByoipCidrCommand.getEndpointParameterInstructions()));

package/dist-es/commands/AllocateAddressCommand.js

@@ -4,10 +4,6 @@ import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AllocateAddressRequestFilterSensitiveLog, AllocateAddressResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_ec2AllocateAddressCommand, serializeAws_ec2AllocateAddressCommand } from "../protocols/Aws_ec2";
 export class AllocateAddressCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
-    }
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -16,6 +12,10 @@ export class AllocateAddressCommand extends $Command {
             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, AllocateAddressCommand.getEndpointParameterInstructions()));