@aws-sdk/client-ec2 3.87.0 → 3.90.0

package/dist-es/protocols/Aws_ec2.js

@@ -3735,6 +3735,16 @@ export var serializeAws_ec2GetInstanceTypesFromInstanceRequirementsCommand = fun
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_ec2GetInstanceUefiDataCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_ec2GetInstanceUefiDataRequest(input, context)), { Action: "GetInstanceUefiData", Version: "2016-11-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_ec2GetIpamAddressHistoryCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -22010,6 +22020,51 @@ var deserializeAws_ec2GetInstanceTypesFromInstanceRequirementsCommandError = fun
         }
     });
 }); };
+export var deserializeAws_ec2GetInstanceUefiDataCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_ec2GetInstanceUefiDataCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_ec2GetInstanceUefiDataResult(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_ec2GetInstanceUefiDataCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, parsedBody;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _b = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_b.body = _c.sent(), _b)]));
+                errorCode = "UnknownError";
+                errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+                switch (errorCode) {
+                    default:
+                        parsedBody = parsedOutput.body;
+                        response = new __BaseException({
+                            name: parsedBody.Errors.Error.code || parsedBody.Errors.Error.Code || errorCode,
+                            $fault: "client",
+                            $metadata: deserializeMetadata(output),
+                        });
+                        throw __decorateServiceException(response, parsedBody.Errors.Error);
+                }
+                return [2];
+        }
+    });
+}); };
 export var deserializeAws_ec2GetIpamAddressHistoryCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -32143,14 +32198,6 @@ var serializeAws_ec2CreateStoreImageTaskRequest = function (input, context) {
 };
 var serializeAws_ec2CreateSubnetCidrReservationRequest = function (input, context) {
     var entries = {};
-    if (input.TagSpecifications !== undefined && input.TagSpecifications !== null) {
-        var memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
-        Object.entries(memberEntries).forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], value = _b[1];
-            var loc = "TagSpecification.".concat(key.substring(key.indexOf(".") + 1));
-            entries[loc] = value;
-        });
-    }
     if (input.SubnetId !== undefined && input.SubnetId !== null) {
         entries["SubnetId"] = input.SubnetId;
     }
@@ -32166,6 +32213,14 @@ var serializeAws_ec2CreateSubnetCidrReservationRequest = function (input, contex
     if (input.DryRun !== undefined && input.DryRun !== null) {
         entries["DryRun"] = input.DryRun;
     }
+    if (input.TagSpecifications !== undefined && input.TagSpecifications !== null) {
+        var memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "TagSpecification.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 var serializeAws_ec2CreateSubnetRequest = function (input, context) {
@@ -32374,6 +32429,9 @@ var serializeAws_ec2CreateTrafficMirrorTargetRequest = function (input, context)
     if (input.ClientToken !== undefined && input.ClientToken !== null) {
         entries["ClientToken"] = input.ClientToken;
     }
+    if (input.GatewayLoadBalancerEndpointId !== undefined && input.GatewayLoadBalancerEndpointId !== null) {
+        entries["GatewayLoadBalancerEndpointId"] = input.GatewayLoadBalancerEndpointId;
+    }
     return entries;
 };
 var serializeAws_ec2CreateTransitGatewayConnectPeerRequest = function (input, context) {
@@ -32823,6 +32881,17 @@ var serializeAws_ec2CreateVpcEndpointRequest = function (input, context) {
             entries[loc] = value;
         });
     }
+    if (input.IpAddressType !== undefined && input.IpAddressType !== null) {
+        entries["IpAddressType"] = input.IpAddressType;
+    }
+    if (input.DnsOptions !== undefined && input.DnsOptions !== null) {
+        var memberEntries = serializeAws_ec2DnsOptionsSpecification(input.DnsOptions, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "DnsOptions.".concat(key);
+            entries[loc] = value;
+        });
+    }
     if (input.ClientToken !== undefined && input.ClientToken !== null) {
         entries["ClientToken"] = input.ClientToken;
     }
@@ -32866,6 +32935,14 @@ var serializeAws_ec2CreateVpcEndpointServiceConfigurationRequest = function (inp
             entries[loc] = value;
         });
     }
+    if (input.SupportedIpAddressTypes !== undefined && input.SupportedIpAddressTypes !== null) {
+        var memberEntries = serializeAws_ec2ValueStringList(input.SupportedIpAddressTypes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "SupportedIpAddressType.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
     if (input.ClientToken !== undefined && input.ClientToken !== null) {
         entries["ClientToken"] = input.ClientToken;
     }
@@ -37905,6 +37982,13 @@ var serializeAws_ec2DiskImageList = function (input, context) {
     }
     return entries;
 };
+var serializeAws_ec2DnsOptionsSpecification = function (input, context) {
+    var entries = {};
+    if (input.DnsRecordIpType !== undefined && input.DnsRecordIpType !== null) {
+        entries["DnsRecordIpType"] = input.DnsRecordIpType;
+    }
+    return entries;
+};
 var serializeAws_ec2DnsServersOptionsModifyStructure = function (input, context) {
     var entries = {};
     if (input.CustomDnsServers !== undefined && input.CustomDnsServers !== null) {
@@ -39009,6 +39093,16 @@ var serializeAws_ec2GetInstanceTypesFromInstanceRequirementsRequest = function (
     }
     return entries;
 };
+var serializeAws_ec2GetInstanceUefiDataRequest = function (input, context) {
+    var entries = {};
+    if (input.InstanceId !== undefined && input.InstanceId !== null) {
+        entries["InstanceId"] = input.InstanceId;
+    }
+    if (input.DryRun !== undefined && input.DryRun !== null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 var serializeAws_ec2GetIpamAddressHistoryRequest = function (input, context) {
     var entries = {};
     if (input.DryRun !== undefined && input.DryRun !== null) {
@@ -43915,6 +44009,17 @@ var serializeAws_ec2ModifyVpcEndpointRequest = function (input, context) {
             entries[loc] = value;
         });
     }
+    if (input.IpAddressType !== undefined && input.IpAddressType !== null) {
+        entries["IpAddressType"] = input.IpAddressType;
+    }
+    if (input.DnsOptions !== undefined && input.DnsOptions !== null) {
+        var memberEntries = serializeAws_ec2DnsOptionsSpecification(input.DnsOptions, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "DnsOptions.".concat(key);
+            entries[loc] = value;
+        });
+    }
     if (input.PrivateDnsEnabled !== undefined && input.PrivateDnsEnabled !== null) {
         entries["PrivateDnsEnabled"] = input.PrivateDnsEnabled;
     }
@@ -43969,6 +44074,22 @@ var serializeAws_ec2ModifyVpcEndpointServiceConfigurationRequest = function (inp
             entries[loc] = value;
         });
     }
+    if (input.AddSupportedIpAddressTypes !== undefined && input.AddSupportedIpAddressTypes !== null) {
+        var memberEntries = serializeAws_ec2ValueStringList(input.AddSupportedIpAddressTypes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "AddSupportedIpAddressType.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
+    if (input.RemoveSupportedIpAddressTypes !== undefined && input.RemoveSupportedIpAddressTypes !== null) {
+        var memberEntries = serializeAws_ec2ValueStringList(input.RemoveSupportedIpAddressTypes, context);
+        Object.entries(memberEntries).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], value = _b[1];
+            var loc = "RemoveSupportedIpAddressType.".concat(key.substring(key.indexOf(".") + 1));
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 var serializeAws_ec2ModifyVpcEndpointServicePayerResponsibilityRequest = function (input, context) {
@@ -45655,6 +45776,12 @@ var serializeAws_ec2RegisterImageRequest = function (input, context) {
     if (input.BootMode !== undefined && input.BootMode !== null) {
         entries["BootMode"] = input.BootMode;
     }
+    if (input.TpmSupport !== undefined && input.TpmSupport !== null) {
+        entries["TpmSupport"] = input.TpmSupport;
+    }
+    if (input.UefiData !== undefined && input.UefiData !== null) {
+        entries["UefiData"] = input.UefiData;
+    }
     return entries;
 };
 var serializeAws_ec2RegisterInstanceEventNotificationAttributesRequest = function (input, context) {
@@ -57178,6 +57305,15 @@ var deserializeAws_ec2DnsEntrySet = function (output, context) {
         return deserializeAws_ec2DnsEntry(entry, context);
     });
 };
+var deserializeAws_ec2DnsOptions = function (output, context) {
+    var contents = {
+        DnsRecordIpType: undefined,
+    };
+    if (output["dnsRecordIpType"] !== undefined) {
+        contents.DnsRecordIpType = __expectString(output["dnsRecordIpType"]);
+    }
+    return contents;
+};
 var deserializeAws_ec2EbsBlockDevice = function (output, context) {
     var contents = {
         DeleteOnTermination: undefined,
@@ -59044,6 +59180,19 @@ var deserializeAws_ec2GetInstanceTypesFromInstanceRequirementsResult = function
     }
     return contents;
 };
+var deserializeAws_ec2GetInstanceUefiDataResult = function (output, context) {
+    var contents = {
+        InstanceId: undefined,
+        UefiData: undefined,
+    };
+    if (output["instanceId"] !== undefined) {
+        contents.InstanceId = __expectString(output["instanceId"]);
+    }
+    if (output["uefiData"] !== undefined) {
+        contents.UefiData = __expectString(output["uefiData"]);
+    }
+    return contents;
+};
 var deserializeAws_ec2GetIpamAddressHistoryResult = function (output, context) {
     var contents = {
         HistoryRecords: undefined,
@@ -59983,6 +60132,7 @@ var deserializeAws_ec2Image = function (output, context) {
         Tags: undefined,
         VirtualizationType: undefined,
         BootMode: undefined,
+        TpmSupport: undefined,
         DeprecationTime: undefined,
     };
     if (output["architecture"] !== undefined) {
@@ -60075,6 +60225,9 @@ var deserializeAws_ec2Image = function (output, context) {
     if (output["bootMode"] !== undefined) {
         contents.BootMode = __expectString(output["bootMode"]);
     }
+    if (output["tpmSupport"] !== undefined) {
+        contents.TpmSupport = __expectString(output["tpmSupport"]);
+    }
     if (output["deprecationTime"] !== undefined) {
         contents.DeprecationTime = __expectString(output["deprecationTime"]);
     }
@@ -60091,6 +60244,8 @@ var deserializeAws_ec2ImageAttribute = function (output, context) {
         RamdiskId: undefined,
         SriovNetSupport: undefined,
         BootMode: undefined,
+        TpmSupport: undefined,
+        UefiData: undefined,
         LastLaunchedTime: undefined,
     };
     if (output.blockDeviceMapping === "") {
@@ -60129,6 +60284,12 @@ var deserializeAws_ec2ImageAttribute = function (output, context) {
     if (output["bootMode"] !== undefined) {
         contents.BootMode = deserializeAws_ec2AttributeValue(output["bootMode"], context);
     }
+    if (output["tpmSupport"] !== undefined) {
+        contents.TpmSupport = deserializeAws_ec2AttributeValue(output["tpmSupport"], context);
+    }
+    if (output["uefiData"] !== undefined) {
+        contents.UefiData = deserializeAws_ec2AttributeValue(output["uefiData"], context);
+    }
     if (output["lastLaunchedTime"] !== undefined) {
         contents.LastLaunchedTime = deserializeAws_ec2AttributeValue(output["lastLaunchedTime"], context);
     }
@@ -60674,6 +60835,7 @@ var deserializeAws_ec2Instance = function (output, context) {
         UsageOperationUpdateTime: undefined,
         PrivateDnsNameOptions: undefined,
         Ipv6Address: undefined,
+        TpmSupport: undefined,
         MaintenanceOptions: undefined,
     };
     if (output["amiLaunchIndex"] !== undefined) {
@@ -60863,6 +61025,9 @@ var deserializeAws_ec2Instance = function (output, context) {
     if (output["ipv6Address"] !== undefined) {
         contents.Ipv6Address = __expectString(output["ipv6Address"]);
     }
+    if (output["tpmSupport"] !== undefined) {
+        contents.TpmSupport = __expectString(output["tpmSupport"]);
+    }
     if (output["maintenanceOptions"] !== undefined) {
         contents.MaintenanceOptions = deserializeAws_ec2InstanceMaintenanceOptions(output["maintenanceOptions"], context);
     }
@@ -68696,6 +68861,7 @@ var deserializeAws_ec2ServiceConfiguration = function (output, context) {
         ManagesVpcEndpoints: undefined,
         NetworkLoadBalancerArns: undefined,
         GatewayLoadBalancerArns: undefined,
+        SupportedIpAddressTypes: undefined,
         BaseEndpointDnsNames: undefined,
         PrivateDnsName: undefined,
         PrivateDnsNameConfiguration: undefined,
@@ -68741,6 +68907,12 @@ var deserializeAws_ec2ServiceConfiguration = function (output, context) {
     if (output["gatewayLoadBalancerArnSet"] !== undefined && output["gatewayLoadBalancerArnSet"]["item"] !== undefined) {
         contents.GatewayLoadBalancerArns = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["gatewayLoadBalancerArnSet"]["item"]), context);
     }
+    if (output.supportedIpAddressTypeSet === "") {
+        contents.SupportedIpAddressTypes = [];
+    }
+    if (output["supportedIpAddressTypeSet"] !== undefined && output["supportedIpAddressTypeSet"]["item"] !== undefined) {
+        contents.SupportedIpAddressTypes = deserializeAws_ec2SupportedIpAddressTypes(__getArrayIfSingleItem(output["supportedIpAddressTypeSet"]["item"]), context);
+    }
     if (output.baseEndpointDnsNameSet === "") {
         contents.BaseEndpointDnsNames = [];
     }
@@ -68790,6 +68962,7 @@ var deserializeAws_ec2ServiceDetail = function (output, context) {
         PayerResponsibility: undefined,
         Tags: undefined,
         PrivateDnsNameVerificationState: undefined,
+        SupportedIpAddressTypes: undefined,
     };
     if (output["serviceName"] !== undefined) {
         contents.ServiceName = __expectString(output["serviceName"]);
@@ -68848,6 +69021,12 @@ var deserializeAws_ec2ServiceDetail = function (output, context) {
     if (output["privateDnsNameVerificationState"] !== undefined) {
         contents.PrivateDnsNameVerificationState = __expectString(output["privateDnsNameVerificationState"]);
     }
+    if (output.supportedIpAddressTypeSet === "") {
+        contents.SupportedIpAddressTypes = [];
+    }
+    if (output["supportedIpAddressTypeSet"] !== undefined && output["supportedIpAddressTypeSet"]["item"] !== undefined) {
+        contents.SupportedIpAddressTypes = deserializeAws_ec2SupportedIpAddressTypes(__getArrayIfSingleItem(output["supportedIpAddressTypeSet"]["item"]), context);
+    }
     return contents;
 };
 var deserializeAws_ec2ServiceDetailSet = function (output, context) {
@@ -70279,6 +70458,16 @@ var deserializeAws_ec2SuccessfulQueuedPurchaseDeletionSet = function (output, co
         return deserializeAws_ec2SuccessfulQueuedPurchaseDeletion(entry, context);
     });
 };
+var deserializeAws_ec2SupportedIpAddressTypes = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+};
 var deserializeAws_ec2Tag = function (output, context) {
     var contents = {
         Key: undefined,
@@ -70794,6 +70983,7 @@ var deserializeAws_ec2TrafficMirrorTarget = function (output, context) {
         Description: undefined,
         OwnerId: undefined,
         Tags: undefined,
+        GatewayLoadBalancerEndpointId: undefined,
     };
     if (output["trafficMirrorTargetId"] !== undefined) {
         contents.TrafficMirrorTargetId = __expectString(output["trafficMirrorTargetId"]);
@@ -70819,6 +71009,9 @@ var deserializeAws_ec2TrafficMirrorTarget = function (output, context) {
     if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
         contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
     }
+    if (output["gatewayLoadBalancerEndpointId"] !== undefined) {
+        contents.GatewayLoadBalancerEndpointId = __expectString(output["gatewayLoadBalancerEndpointId"]);
+    }
     return contents;
 };
 var deserializeAws_ec2TrafficMirrorTargetSet = function (output, context) {
@@ -72942,6 +73135,8 @@ var deserializeAws_ec2VpcEndpoint = function (output, context) {
         RouteTableIds: undefined,
         SubnetIds: undefined,
         Groups: undefined,
+        IpAddressType: undefined,
+        DnsOptions: undefined,
         PrivateDnsEnabled: undefined,
         RequesterManaged: undefined,
         NetworkInterfaceIds: undefined,
@@ -72987,6 +73182,12 @@ var deserializeAws_ec2VpcEndpoint = function (output, context) {
     if (output["groupSet"] !== undefined && output["groupSet"]["item"] !== undefined) {
         contents.Groups = deserializeAws_ec2GroupIdentifierSet(__getArrayIfSingleItem(output["groupSet"]["item"]), context);
     }
+    if (output["ipAddressType"] !== undefined) {
+        contents.IpAddressType = __expectString(output["ipAddressType"]);
+    }
+    if (output["dnsOptions"] !== undefined) {
+        contents.DnsOptions = deserializeAws_ec2DnsOptions(output["dnsOptions"], context);
+    }
     if (output["privateDnsEnabled"] !== undefined) {
         contents.PrivateDnsEnabled = __parseBoolean(output["privateDnsEnabled"]);
     }
@@ -73032,6 +73233,7 @@ var deserializeAws_ec2VpcEndpointConnection = function (output, context) {
         DnsEntries: undefined,
         NetworkLoadBalancerArns: undefined,
         GatewayLoadBalancerArns: undefined,
+        IpAddressType: undefined,
     };
     if (output["serviceId"] !== undefined) {
         contents.ServiceId = __expectString(output["serviceId"]);
@@ -73066,6 +73268,9 @@ var deserializeAws_ec2VpcEndpointConnection = function (output, context) {
     if (output["gatewayLoadBalancerArnSet"] !== undefined && output["gatewayLoadBalancerArnSet"]["item"] !== undefined) {
         contents.GatewayLoadBalancerArns = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["gatewayLoadBalancerArnSet"]["item"]), context);
     }
+    if (output["ipAddressType"] !== undefined) {
+        contents.IpAddressType = __expectString(output["ipAddressType"]);
+    }
     return contents;
 };
 var deserializeAws_ec2VpcEndpointConnectionSet = function (output, context) {

package/dist-types/EC2.d.ts

@@ -372,6 +372,7 @@ import { GetFlowLogsIntegrationTemplateCommandInput, GetFlowLogsIntegrationTempl
 import { GetGroupsForCapacityReservationCommandInput, GetGroupsForCapacityReservationCommandOutput } from "./commands/GetGroupsForCapacityReservationCommand";
 import { GetHostReservationPurchasePreviewCommandInput, GetHostReservationPurchasePreviewCommandOutput } from "./commands/GetHostReservationPurchasePreviewCommand";
 import { GetInstanceTypesFromInstanceRequirementsCommandInput, GetInstanceTypesFromInstanceRequirementsCommandOutput } from "./commands/GetInstanceTypesFromInstanceRequirementsCommand";
+import { GetInstanceUefiDataCommandInput, GetInstanceUefiDataCommandOutput } from "./commands/GetInstanceUefiDataCommand";
 import { GetIpamAddressHistoryCommandInput, GetIpamAddressHistoryCommandOutput } from "./commands/GetIpamAddressHistoryCommand";
 import { GetIpamPoolAllocationsCommandInput, GetIpamPoolAllocationsCommandOutput } from "./commands/GetIpamPoolAllocationsCommand";
 import { GetIpamPoolCidrsCommandInput, GetIpamPoolCidrsCommandOutput } from "./commands/GetIpamPoolCidrsCommand";
@@ -1799,7 +1800,7 @@ export declare class EC2 extends EC2Client {
      *          <p>A Traffic Mirror target is the destination for mirrored traffic. The Traffic Mirror source and
      *          the Traffic Mirror target (monitoring appliances) can be in the same VPC, or in
      *          different VPCs connected via VPC peering or a transit gateway.</p>
-     *          <p>A Traffic Mirror target can be a network interface, or a Network Load Balancer.</p>
+     *          <p>A Traffic Mirror target can be a network interface, a Network Load Balancer, or a Gateway Load Balancer endpoint.</p>
      *          <p>To use the target in a Traffic Mirror session, use  <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorSession.htm">CreateTrafficMirrorSession</a>.</p>
      */
     createTrafficMirrorTarget(args: CreateTrafficMirrorTargetCommandInput, options?: __HttpHandlerOptions): Promise<CreateTrafficMirrorTargetCommandOutput>;
@@ -4343,6 +4344,21 @@ export declare class EC2 extends EC2Client {
     getInstanceTypesFromInstanceRequirements(args: GetInstanceTypesFromInstanceRequirementsCommandInput, options?: __HttpHandlerOptions): Promise<GetInstanceTypesFromInstanceRequirementsCommandOutput>;
     getInstanceTypesFromInstanceRequirements(args: GetInstanceTypesFromInstanceRequirementsCommandInput, cb: (err: any, data?: GetInstanceTypesFromInstanceRequirementsCommandOutput) => void): void;
     getInstanceTypesFromInstanceRequirements(args: GetInstanceTypesFromInstanceRequirementsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetInstanceTypesFromInstanceRequirementsCommandOutput) => void): void;
+    /**
+     * <p>A binary representation of the UEFI variable store. Only non-volatile variables are
+     *             stored. This is a base64 encoded and zlib compressed binary value that must be properly
+     *             encoded.</p>
+     *         <p>When you use <a href="https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html">register-image</a>
+     *             to create an AMI, you can create an exact copy of your variable store by passing the UEFI data in the <code>UefiData</code>
+     *             parameter. You can modify the UEFI data by using the <a href="https://github.com/awslabs/python-uefivars">python-uefivars tool</a>
+     *             on GitHub. You can use the tool to convert the UEFI data into a human-readable format (JSON), which you can
+     *             inspect and modify, and then convert back into the binary format to use with register-image.</p>
+     *         <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/uefi-secure-boot.html">UEFI Secure Boot</a> in the
+     *                 <i>Amazon EC2 User Guide</i>.</p>
+     */
+    getInstanceUefiData(args: GetInstanceUefiDataCommandInput, options?: __HttpHandlerOptions): Promise<GetInstanceUefiDataCommandOutput>;
+    getInstanceUefiData(args: GetInstanceUefiDataCommandInput, cb: (err: any, data?: GetInstanceUefiDataCommandOutput) => void): void;
+    getInstanceUefiData(args: GetInstanceUefiDataCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetInstanceUefiDataCommandOutput) => void): void;
     /**
      * <p>Retrieve historical information about a CIDR within an IPAM scope. For more information, see <a href="/vpc/latest/ipam/view-history-cidr-ipam.html">View the history of IP addresses</a> in the <i>Amazon VPC IPAM User Guide</i>.</p>
      */