@aws-sdk/client-ec2 3.294.0 → 3.296.0

package/dist-es/protocols/Aws_ec2.js

@@ -25947,6 +25947,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) => {
@@ -40243,6 +40257,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) {
@@ -41418,6 +41456,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;
@@ -45268,6 +45316,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 = __expectString(output["additionalDetailType"]);
@@ -45275,6 +45329,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(__getArrayIfSingleItem(output["ruleOptionSet"]["item"]), context);
+    }
+    if (output.ruleGroupTypePairSet === "") {
+        contents.RuleGroupTypePairs = [];
+    }
+    else if (output["ruleGroupTypePairSet"] !== undefined && output["ruleGroupTypePairSet"]["item"] !== undefined) {
+        contents.RuleGroupTypePairs = deserializeAws_ec2RuleGroupTypePairList(__getArrayIfSingleItem(output["ruleGroupTypePairSet"]["item"]), context);
+    }
+    if (output.ruleGroupRuleOptionsPairSet === "") {
+        contents.RuleGroupRuleOptionsPairs = [];
+    }
+    else if (output["ruleGroupRuleOptionsPairSet"] !== undefined &&
+        output["ruleGroupRuleOptionsPairSet"]["item"] !== undefined) {
+        contents.RuleGroupRuleOptionsPairs = deserializeAws_ec2RuleGroupRuleOptionsPairList(__getArrayIfSingleItem(output["ruleGroupRuleOptionsPairSet"]["item"]), context);
+    }
+    if (output["serviceName"] !== undefined) {
+        contents.ServiceName = __expectString(output["serviceName"]);
+    }
+    if (output.loadBalancerSet === "") {
+        contents.LoadBalancers = [];
+    }
+    else if (output["loadBalancerSet"] !== undefined && output["loadBalancerSet"]["item"] !== undefined) {
+        contents.LoadBalancers = deserializeAws_ec2AnalysisComponentList(__getArrayIfSingleItem(output["loadBalancerSet"]["item"]), context);
+    }
     return contents;
 };
 const deserializeAws_ec2AdditionalDetailList = (output, context) => {
@@ -45686,6 +45771,9 @@ const deserializeAws_ec2AnalysisRouteTableRoute = (output, context) => {
         TransitGatewayId: undefined,
         VpcPeeringConnectionId: undefined,
         State: undefined,
+        CarrierGatewayId: undefined,
+        CoreNetworkArn: undefined,
+        LocalGatewayId: undefined,
     };
     if (output["destinationCidr"] !== undefined) {
         contents.DestinationCidr = __expectString(output["destinationCidr"]);
@@ -45720,6 +45808,15 @@ const deserializeAws_ec2AnalysisRouteTableRoute = (output, context) => {
     if (output["state"] !== undefined) {
         contents.State = __expectString(output["state"]);
     }
+    if (output["carrierGatewayId"] !== undefined) {
+        contents.CarrierGatewayId = __expectString(output["carrierGatewayId"]);
+    }
+    if (output["coreNetworkArn"] !== undefined) {
+        contents.CoreNetworkArn = __expectString(output["coreNetworkArn"]);
+    }
+    if (output["localGatewayId"] !== undefined) {
+        contents.LocalGatewayId = __expectString(output["localGatewayId"]);
+    }
     return contents;
 };
 const deserializeAws_ec2AnalysisSecurityGroupRule = (output, context) => {
@@ -53187,6 +53284,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);
@@ -53363,6 +53462,12 @@ const deserializeAws_ec2Explanation = (output, context) => {
     if (output["componentRegion"] !== undefined) {
         contents.ComponentRegion = __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) => {
@@ -53654,6 +53759,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 = __strictParseInt32(output["fromPort"]);
+    }
+    if (output["toPort"] !== undefined) {
+        contents.ToPort = __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 = __expectString(output["ruleGroupArn"]);
+    }
+    if (output.sourceSet === "") {
+        contents.Sources = [];
+    }
+    else if (output["sourceSet"] !== undefined && output["sourceSet"]["item"] !== undefined) {
+        contents.Sources = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["sourceSet"]["item"]), context);
+    }
+    if (output.destinationSet === "") {
+        contents.Destinations = [];
+    }
+    else if (output["destinationSet"] !== undefined && output["destinationSet"]["item"] !== undefined) {
+        contents.Destinations = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["destinationSet"]["item"]), context);
+    }
+    if (output.sourcePortSet === "") {
+        contents.SourcePorts = [];
+    }
+    else if (output["sourcePortSet"] !== undefined && output["sourcePortSet"]["item"] !== undefined) {
+        contents.SourcePorts = deserializeAws_ec2PortRangeList(__getArrayIfSingleItem(output["sourcePortSet"]["item"]), context);
+    }
+    if (output.destinationPortSet === "") {
+        contents.DestinationPorts = [];
+    }
+    else if (output["destinationPortSet"] !== undefined && output["destinationPortSet"]["item"] !== undefined) {
+        contents.DestinationPorts = deserializeAws_ec2PortRangeList(__getArrayIfSingleItem(output["destinationPortSet"]["item"]), context);
+    }
+    if (output["protocol"] !== undefined) {
+        contents.Protocol = __expectString(output["protocol"]);
+    }
+    if (output["ruleAction"] !== undefined) {
+        contents.RuleAction = __expectString(output["ruleAction"]);
+    }
+    if (output["direction"] !== undefined) {
+        contents.Direction = __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 = __expectString(output["ruleGroupArn"]);
+    }
+    if (output.sourceSet === "") {
+        contents.Sources = [];
+    }
+    else if (output["sourceSet"] !== undefined && output["sourceSet"]["item"] !== undefined) {
+        contents.Sources = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["sourceSet"]["item"]), context);
+    }
+    if (output.destinationSet === "") {
+        contents.Destinations = [];
+    }
+    else if (output["destinationSet"] !== undefined && output["destinationSet"]["item"] !== undefined) {
+        contents.Destinations = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["destinationSet"]["item"]), context);
+    }
+    if (output.sourcePortSet === "") {
+        contents.SourcePorts = [];
+    }
+    else if (output["sourcePortSet"] !== undefined && output["sourcePortSet"]["item"] !== undefined) {
+        contents.SourcePorts = deserializeAws_ec2PortRangeList(__getArrayIfSingleItem(output["sourcePortSet"]["item"]), context);
+    }
+    if (output.destinationPortSet === "") {
+        contents.DestinationPorts = [];
+    }
+    else if (output["destinationPortSet"] !== undefined && output["destinationPortSet"]["item"] !== undefined) {
+        contents.DestinationPorts = deserializeAws_ec2PortRangeList(__getArrayIfSingleItem(output["destinationPortSet"]["item"]), context);
+    }
+    if (output.protocolSet === "") {
+        contents.Protocols = [];
+    }
+    else if (output["protocolSet"] !== undefined && output["protocolSet"]["item"] !== undefined) {
+        contents.Protocols = deserializeAws_ec2ProtocolIntList(__getArrayIfSingleItem(output["protocolSet"]["item"]), context);
+    }
+    if (output["ruleAction"] !== undefined) {
+        contents.RuleAction = __expectString(output["ruleAction"]);
+    }
+    if (output["priority"] !== undefined) {
+        contents.Priority = __strictParseInt32(output["priority"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2FleetCapacityReservation = (output, context) => {
     const contents = {
         CapacityReservationId: undefined,
@@ -61086,6 +61305,8 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
         Protocol: undefined,
         DestinationPort: undefined,
         Tags: undefined,
+        FilterAtSource: undefined,
+        FilterAtDestination: undefined,
     };
     if (output["networkInsightsPathId"] !== undefined) {
         contents.NetworkInsightsPathId = __expectString(output["networkInsightsPathId"]);
@@ -61126,6 +61347,12 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
     else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
         contents.Tags = deserializeAws_ec2TagList(__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) => {
@@ -61592,6 +61819,9 @@ const deserializeAws_ec2PathComponent = (output, context) => {
         TransitGatewayRouteTableRoute: undefined,
         Explanations: undefined,
         ElasticLoadBalancerListener: undefined,
+        FirewallStatelessRule: undefined,
+        FirewallStatefulRule: undefined,
+        ServiceName: undefined,
     };
     if (output["sequenceNumber"] !== undefined) {
         contents.SequenceNumber = __strictParseInt32(output["sequenceNumber"]);
@@ -61650,6 +61880,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 = __expectString(output["serviceName"]);
+    }
     return contents;
 };
 const deserializeAws_ec2PathComponentList = (output, context) => {
@@ -61659,6 +61898,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 = __expectString(output["sourceAddress"]);
+    }
+    if (output["sourcePortRange"] !== undefined) {
+        contents.SourcePortRange = deserializeAws_ec2FilterPortRange(output["sourcePortRange"], context);
+    }
+    if (output["destinationAddress"] !== undefined) {
+        contents.DestinationAddress = __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,
@@ -62300,6 +62560,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 __strictParseInt32(entry);
+    });
+};
 const deserializeAws_ec2ProtocolList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -63820,6 +64087,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 = __expectString(output["ruleGroupArn"]);
+    }
+    if (output.ruleOptionSet === "") {
+        contents.RuleOptions = [];
+    }
+    else if (output["ruleOptionSet"] !== undefined && output["ruleOptionSet"]["item"] !== undefined) {
+        contents.RuleOptions = deserializeAws_ec2RuleOptionList(__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 = __expectString(output["ruleGroupArn"]);
+    }
+    if (output["ruleGroupType"] !== undefined) {
+        contents.RuleGroupType = __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 = __expectString(output["keyword"]);
+    }
+    if (output.settingSet === "") {
+        contents.Settings = [];
+    }
+    else if (output["settingSet"] !== undefined && output["settingSet"]["item"] !== undefined) {
+        contents.Settings = deserializeAws_ec2StringList(__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-types/EC2.d.ts

@@ -715,8 +715,10 @@ export declare class EC2 extends EC2Client {
     allocateHosts(args: AllocateHostsCommandInput, cb: (err: any, data?: AllocateHostsCommandOutput) => void): void;
     allocateHosts(args: AllocateHostsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AllocateHostsCommandOutput) => void): void;
     /**
-     * <p>Allocate a CIDR from an IPAM pool. In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool or to a resource. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.
-     *       </p>
+     * <p>Allocate a CIDR from an IPAM pool. In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool or to a resource. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
+     *          <note>
+     *             <p>This action creates an allocation with strong consistency. The returned CIDR will not overlap with any other allocations from the same pool.</p>
+     *          </note>
      */
     allocateIpamPoolCidr(args: AllocateIpamPoolCidrCommandInput, options?: __HttpHandlerOptions): Promise<AllocateIpamPoolCidrCommandOutput>;
     allocateIpamPoolCidr(args: AllocateIpamPoolCidrCommandInput, cb: (err: any, data?: AllocateIpamPoolCidrCommandOutput) => void): void;
@@ -1678,8 +1680,8 @@ export declare class EC2 extends EC2Client {
     /**
      * <p>Creates a path to analyze for reachability.</p>
      *          <p>Reachability Analyzer enables you to analyze and debug network reachability between
-     *           two resources in your virtual private cloud (VPC). For more information, see
-     *           <a href="https://docs.aws.amazon.com/vpc/latest/reachability/">What is Reachability Analyzer</a>.</p>
+     *           two resources in your virtual private cloud (VPC). For more information, see the
+     *           <a href="https://docs.aws.amazon.com/vpc/latest/reachability/">Reachability Analyzer Guide</a>.</p>
      */
     createNetworkInsightsPath(args: CreateNetworkInsightsPathCommandInput, options?: __HttpHandlerOptions): Promise<CreateNetworkInsightsPathCommandOutput>;
     createNetworkInsightsPath(args: CreateNetworkInsightsPathCommandInput, cb: (err: any, data?: CreateNetworkInsightsPathCommandOutput) => void): void;
@@ -1841,8 +1843,8 @@ export declare class EC2 extends EC2Client {
      *       should unmount the volume from within the instance, issue the snapshot command, and then
      *       remount the volume to ensure a consistent and complete snapshot. You may remount and use your
      *       volume while the snapshot status is <code>pending</code>.</p>
-     *          <p>To create a snapshot for Amazon EBS volumes that serve as root devices, you should stop the
-     *       instance before taking the snapshot.</p>
+     *          <p>When you create a snapshot for an EBS volume that serves as a root device, we recommend
+     *       that you stop the instance before taking the snapshot.</p>
      *          <p>Snapshots that are taken from encrypted volumes are automatically encrypted. Volumes that
      *       are created from encrypted snapshots are also automatically encrypted. Your encrypted volumes
      *       and any associated snapshots always remain protected.</p>
@@ -4797,6 +4799,9 @@ export declare class EC2 extends EC2Client {
     getIpamDiscoveredResourceCidrs(args: GetIpamDiscoveredResourceCidrsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetIpamDiscoveredResourceCidrsCommandOutput) => void): void;
     /**
      * <p>Get a list of all the CIDR allocations in an IPAM pool.</p>
+     *          <note>
+     *             <p>If you use this action after <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateIpamPoolCidr.html">AllocateIpamPoolCidr</a> or <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseIpamPoolAllocation.html">ReleaseIpamPoolAllocation</a>, note that all EC2 API actions follow an <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html#eventual-consistency">eventual consistency</a> model.</p>
+     *          </note>
      */
     getIpamPoolAllocations(args: GetIpamPoolAllocationsCommandInput, options?: __HttpHandlerOptions): Promise<GetIpamPoolAllocationsCommandOutput>;
     getIpamPoolAllocations(args: GetIpamPoolAllocationsCommandInput, cb: (err: any, data?: GetIpamPoolAllocationsCommandOutput) => void): void;
@@ -6082,6 +6087,9 @@ export declare class EC2 extends EC2Client {
     /**
      * <p>Release an allocation within an IPAM pool. You can only use this action to release manual allocations. To remove an allocation for a resource without deleting the resource, set its monitored state to false using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyIpamResourceCidr.html">ModifyIpamResourceCidr</a>. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/release-pool-alloc-ipam.html">Release an allocation</a> in the <i>Amazon VPC IPAM User Guide</i>.
      *       </p>
+     *          <note>
+     *             <p>All EC2 API actions follow an <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html#eventual-consistency">eventual consistency</a> model.</p>
+     *          </note>
      */
     releaseIpamPoolAllocation(args: ReleaseIpamPoolAllocationCommandInput, options?: __HttpHandlerOptions): Promise<ReleaseIpamPoolAllocationCommandOutput>;
     releaseIpamPoolAllocation(args: ReleaseIpamPoolAllocationCommandInput, cb: (err: any, data?: ReleaseIpamPoolAllocationCommandOutput) => void): void;