@aws-sdk/client-ec2 3.257.0 → 3.258.0

package/dist-es/protocols/Aws_ec2.js

@@ -243,6 +243,18 @@ export const serializeAws_ec2AssociateInstanceEventWindowCommand = async (input,
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2AssociateIpamResourceDiscoveryCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2AssociateIpamResourceDiscoveryRequest(input, context),
+        Action: "AssociateIpamResourceDiscovery",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2AssociateRouteTableCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -867,6 +879,18 @@ export const serializeAws_ec2CreateIpamPoolCommand = async (input, context) => {
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2CreateIpamResourceDiscoveryCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2CreateIpamResourceDiscoveryRequest(input, context),
+        Action: "CreateIpamResourceDiscovery",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2CreateIpamScopeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -1755,6 +1779,18 @@ export const serializeAws_ec2DeleteIpamPoolCommand = async (input, context) => {
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DeleteIpamResourceDiscoveryCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DeleteIpamResourceDiscoveryRequest(input, context),
+        Action: "DeleteIpamResourceDiscovery",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DeleteIpamScopeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -3171,6 +3207,30 @@ export const serializeAws_ec2DescribeIpamPoolsCommand = async (input, context) =
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DescribeIpamResourceDiscoveriesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeIpamResourceDiscoveriesRequest(input, context),
+        Action: "DescribeIpamResourceDiscoveries",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DescribeIpamResourceDiscoveryAssociationsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeIpamResourceDiscoveryAssociationsRequest(input, context),
+        Action: "DescribeIpamResourceDiscoveryAssociations",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DescribeIpamsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4503,6 +4563,18 @@ export const serializeAws_ec2DisassociateInstanceEventWindowCommand = async (inp
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DisassociateIpamResourceDiscoveryCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DisassociateIpamResourceDiscoveryRequest(input, context),
+        Action: "DisassociateIpamResourceDiscovery",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DisassociateRouteTableCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4995,6 +5067,30 @@ export const serializeAws_ec2GetIpamAddressHistoryCommand = async (input, contex
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2GetIpamDiscoveredAccountsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2GetIpamDiscoveredAccountsRequest(input, context),
+        Action: "GetIpamDiscoveredAccounts",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2GetIpamDiscoveredResourceCidrsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2GetIpamDiscoveredResourceCidrsRequest(input, context),
+        Action: "GetIpamDiscoveredResourceCidrs",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2GetIpamPoolAllocationsCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -5667,6 +5763,18 @@ export const serializeAws_ec2ModifyIpamResourceCidrCommand = async (input, conte
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2ModifyIpamResourceDiscoveryCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyIpamResourceDiscoveryRequest(input, context),
+        Action: "ModifyIpamResourceDiscovery",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2ModifyIpamScopeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -7452,6 +7560,33 @@ const deserializeAws_ec2AssociateInstanceEventWindowCommandError = async (output
         errorCode,
     });
 };
+export const deserializeAws_ec2AssociateIpamResourceDiscoveryCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2AssociateIpamResourceDiscoveryCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2AssociateIpamResourceDiscoveryResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2AssociateIpamResourceDiscoveryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2AssociateRouteTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2AssociateRouteTableCommandError(output, context);
@@ -8847,6 +8982,33 @@ const deserializeAws_ec2CreateIpamPoolCommandError = async (output, context) =>
         errorCode,
     });
 };
+export const deserializeAws_ec2CreateIpamResourceDiscoveryCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2CreateIpamResourceDiscoveryCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2CreateIpamResourceDiscoveryResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2CreateIpamResourceDiscoveryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2CreateIpamScopeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2CreateIpamScopeCommandError(output, context);
@@ -10827,6 +10989,33 @@ const deserializeAws_ec2DeleteIpamPoolCommandError = async (output, context) =>
         errorCode,
     });
 };
+export const deserializeAws_ec2DeleteIpamResourceDiscoveryCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DeleteIpamResourceDiscoveryCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DeleteIpamResourceDiscoveryResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DeleteIpamResourceDiscoveryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2DeleteIpamScopeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DeleteIpamScopeCommandError(output, context);
@@ -13959,6 +14148,60 @@ const deserializeAws_ec2DescribeIpamPoolsCommandError = async (output, context)
         errorCode,
     });
 };
+export const deserializeAws_ec2DescribeIpamResourceDiscoveriesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeIpamResourceDiscoveriesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeIpamResourceDiscoveriesResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeIpamResourceDiscoveriesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
+export const deserializeAws_ec2DescribeIpamResourceDiscoveryAssociationsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeIpamResourceDiscoveryAssociationsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeIpamResourceDiscoveryAssociationsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeIpamResourceDiscoveryAssociationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2DescribeIpamsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DescribeIpamsCommandError(output, context);
@@ -16941,6 +17184,33 @@ const deserializeAws_ec2DisassociateInstanceEventWindowCommandError = async (out
         errorCode,
     });
 };
+export const deserializeAws_ec2DisassociateIpamResourceDiscoveryCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DisassociateIpamResourceDiscoveryCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DisassociateIpamResourceDiscoveryResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DisassociateIpamResourceDiscoveryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2DisassociateRouteTableCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DisassociateRouteTableCommandError(output, context);
@@ -18039,6 +18309,60 @@ const deserializeAws_ec2GetIpamAddressHistoryCommandError = async (output, conte
         errorCode,
     });
 };
+export const deserializeAws_ec2GetIpamDiscoveredAccountsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2GetIpamDiscoveredAccountsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2GetIpamDiscoveredAccountsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2GetIpamDiscoveredAccountsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
+export const deserializeAws_ec2GetIpamDiscoveredResourceCidrsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2GetIpamDiscoveredResourceCidrsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2GetIpamDiscoveredResourceCidrsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2GetIpamDiscoveredResourceCidrsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2GetIpamPoolAllocationsCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2GetIpamPoolAllocationsCommandError(output, context);
@@ -19539,6 +19863,33 @@ const deserializeAws_ec2ModifyIpamResourceCidrCommandError = async (output, cont
         errorCode,
     });
 };
+export const deserializeAws_ec2ModifyIpamResourceDiscoveryCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyIpamResourceDiscoveryCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyIpamResourceDiscoveryResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyIpamResourceDiscoveryCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2ModifyIpamScopeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2ModifyIpamScopeCommandError(output, context);
@@ -22968,6 +23319,35 @@ const serializeAws_ec2AssociateInstanceEventWindowRequest = (input, context) =>
     }
     return entries;
 };
+const serializeAws_ec2AssociateIpamResourceDiscoveryRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamId != null) {
+        entries["IpamId"] = input.IpamId;
+    }
+    if (input.IpamResourceDiscoveryId != null) {
+        entries["IpamResourceDiscoveryId"] = input.IpamResourceDiscoveryId;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
 const serializeAws_ec2AssociateRouteTableRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -24823,6 +25203,9 @@ const serializeAws_ec2CreateIpamPoolRequest = (input, context) => {
     if (input.AwsService != null) {
         entries["AwsService"] = input.AwsService;
     }
+    if (input.PublicIpSource != null) {
+        entries["PublicIpSource"] = input.PublicIpSource;
+    }
     return entries;
 };
 const serializeAws_ec2CreateIpamRequest = (input, context) => {
@@ -24861,6 +25244,42 @@ const serializeAws_ec2CreateIpamRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2CreateIpamResourceDiscoveryRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.OperatingRegions != null) {
+        const memberEntries = serializeAws_ec2AddIpamOperatingRegionSet(input.OperatingRegions, context);
+        if (input.OperatingRegions?.length === 0) {
+            entries.OperatingRegion = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `OperatingRegion.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
 const serializeAws_ec2CreateIpamScopeRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -27243,6 +27662,16 @@ const serializeAws_ec2DeleteIpamRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DeleteIpamResourceDiscoveryRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryId != null) {
+        entries["IpamResourceDiscoveryId"] = input.IpamResourceDiscoveryId;
+    }
+    return entries;
+};
 const serializeAws_ec2DeleteIpamScopeRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -29566,6 +29995,72 @@ const serializeAws_ec2DescribeIpamPoolsRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DescribeIpamResourceDiscoveriesRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryIds != null) {
+        const memberEntries = serializeAws_ec2ValueStringList(input.IpamResourceDiscoveryIds, context);
+        if (input.IpamResourceDiscoveryIds?.length === 0) {
+            entries.IpamResourceDiscoveryId = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `IpamResourceDiscoveryId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.Filters != null) {
+        const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        if (input.Filters?.length === 0) {
+            entries.Filter = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filter.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
+const serializeAws_ec2DescribeIpamResourceDiscoveryAssociationsRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryAssociationIds != null) {
+        const memberEntries = serializeAws_ec2ValueStringList(input.IpamResourceDiscoveryAssociationIds, context);
+        if (input.IpamResourceDiscoveryAssociationIds?.length === 0) {
+            entries.IpamResourceDiscoveryAssociationId = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `IpamResourceDiscoveryAssociationId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.Filters != null) {
+        const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        if (input.Filters?.length === 0) {
+            entries.Filter = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filter.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_ec2DescribeIpamScopesRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -32673,6 +33168,16 @@ const serializeAws_ec2DisassociateInstanceEventWindowRequest = (input, context)
     }
     return entries;
 };
+const serializeAws_ec2DisassociateIpamResourceDiscoveryRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryAssociationId != null) {
+        entries["IpamResourceDiscoveryAssociationId"] = input.IpamResourceDiscoveryAssociationId;
+    }
+    return entries;
+};
 const serializeAws_ec2DisassociateRouteTableRequest = (input, context) => {
     const entries = {};
     if (input.AssociationId != null) {
@@ -33875,6 +34380,64 @@ const serializeAws_ec2GetIpamAddressHistoryRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2GetIpamDiscoveredAccountsRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryId != null) {
+        entries["IpamResourceDiscoveryId"] = input.IpamResourceDiscoveryId;
+    }
+    if (input.DiscoveryRegion != null) {
+        entries["DiscoveryRegion"] = input.DiscoveryRegion;
+    }
+    if (input.Filters != null) {
+        const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        if (input.Filters?.length === 0) {
+            entries.Filter = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filter.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    return entries;
+};
+const serializeAws_ec2GetIpamDiscoveredResourceCidrsRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryId != null) {
+        entries["IpamResourceDiscoveryId"] = input.IpamResourceDiscoveryId;
+    }
+    if (input.ResourceRegion != null) {
+        entries["ResourceRegion"] = input.ResourceRegion;
+    }
+    if (input.Filters != null) {
+        const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        if (input.Filters?.length === 0) {
+            entries.Filter = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filter.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    return entries;
+};
 const serializeAws_ec2GetIpamPoolAllocationsRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -37612,6 +38175,39 @@ const serializeAws_ec2ModifyIpamResourceCidrRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2ModifyIpamResourceDiscoveryRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.IpamResourceDiscoveryId != null) {
+        entries["IpamResourceDiscoveryId"] = input.IpamResourceDiscoveryId;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.AddOperatingRegions != null) {
+        const memberEntries = serializeAws_ec2AddIpamOperatingRegionSet(input.AddOperatingRegions, context);
+        if (input.AddOperatingRegions?.length === 0) {
+            entries.AddOperatingRegion = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AddOperatingRegion.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.RemoveOperatingRegions != null) {
+        const memberEntries = serializeAws_ec2RemoveIpamOperatingRegionSet(input.RemoveOperatingRegions, context);
+        if (input.RemoveOperatingRegions?.length === 0) {
+            entries.RemoveOperatingRegion = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `RemoveOperatingRegion.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_ec2ModifyIpamScopeRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -39791,6 +40387,15 @@ const serializeAws_ec2ProvisionIpamPoolCidrRequest = (input, context) => {
             entries[loc] = value;
         });
     }
+    if (input.NetmaskLength != null) {
+        entries["NetmaskLength"] = input.NetmaskLength;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
     return entries;
 };
 const serializeAws_ec2ProvisionPublicIpv4PoolCidrRequest = (input, context) => {
@@ -45013,6 +45618,15 @@ const deserializeAws_ec2AssociateInstanceEventWindowResult = (output, context) =
     }
     return contents;
 };
+const deserializeAws_ec2AssociateIpamResourceDiscoveryResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscoveryAssociation: undefined,
+    };
+    if (output["ipamResourceDiscoveryAssociation"] !== undefined) {
+        contents.IpamResourceDiscoveryAssociation = deserializeAws_ec2IpamResourceDiscoveryAssociation(output["ipamResourceDiscoveryAssociation"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2AssociateRouteTableResult = (output, context) => {
     const contents = {
         AssociationId: undefined,
@@ -47102,6 +47716,15 @@ const deserializeAws_ec2CreateIpamPoolResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2CreateIpamResourceDiscoveryResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscovery: undefined,
+    };
+    if (output["ipamResourceDiscovery"] !== undefined) {
+        contents.IpamResourceDiscovery = deserializeAws_ec2IpamResourceDiscovery(output["ipamResourceDiscovery"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2CreateIpamResult = (output, context) => {
     const contents = {
         Ipam: undefined,
@@ -47948,6 +48571,15 @@ const deserializeAws_ec2DeleteIpamPoolResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2DeleteIpamResourceDiscoveryResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscovery: undefined,
+    };
+    if (output["ipamResourceDiscovery"] !== undefined) {
+        contents.IpamResourceDiscovery = deserializeAws_ec2IpamResourceDiscovery(output["ipamResourceDiscovery"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2DeleteIpamResult = (output, context) => {
     const contents = {
         Ipam: undefined,
@@ -49469,6 +50101,40 @@ const deserializeAws_ec2DescribeIpamPoolsResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2DescribeIpamResourceDiscoveriesResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscoveries: undefined,
+        NextToken: undefined,
+    };
+    if (output.ipamResourceDiscoverySet === "") {
+        contents.IpamResourceDiscoveries = [];
+    }
+    else if (output["ipamResourceDiscoverySet"] !== undefined &&
+        output["ipamResourceDiscoverySet"]["item"] !== undefined) {
+        contents.IpamResourceDiscoveries = deserializeAws_ec2IpamResourceDiscoverySet(__getArrayIfSingleItem(output["ipamResourceDiscoverySet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2DescribeIpamResourceDiscoveryAssociationsResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscoveryAssociations: undefined,
+        NextToken: undefined,
+    };
+    if (output.ipamResourceDiscoveryAssociationSet === "") {
+        contents.IpamResourceDiscoveryAssociations = [];
+    }
+    else if (output["ipamResourceDiscoveryAssociationSet"] !== undefined &&
+        output["ipamResourceDiscoveryAssociationSet"]["item"] !== undefined) {
+        contents.IpamResourceDiscoveryAssociations = deserializeAws_ec2IpamResourceDiscoveryAssociationSet(__getArrayIfSingleItem(output["ipamResourceDiscoveryAssociationSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2DescribeIpamScopesResult = (output, context) => {
     const contents = {
         NextToken: undefined,
@@ -51338,6 +52004,15 @@ const deserializeAws_ec2DisassociateInstanceEventWindowResult = (output, context
     }
     return contents;
 };
+const deserializeAws_ec2DisassociateIpamResourceDiscoveryResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscoveryAssociation: undefined,
+    };
+    if (output["ipamResourceDiscoveryAssociation"] !== undefined) {
+        contents.IpamResourceDiscoveryAssociation = deserializeAws_ec2IpamResourceDiscoveryAssociation(output["ipamResourceDiscoveryAssociation"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2DisassociateSubnetCidrBlockResult = (output, context) => {
     const contents = {
         Ipv6CidrBlockAssociation: undefined,
@@ -53387,6 +54062,40 @@ const deserializeAws_ec2GetIpamAddressHistoryResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2GetIpamDiscoveredAccountsResult = (output, context) => {
+    const contents = {
+        IpamDiscoveredAccounts: undefined,
+        NextToken: undefined,
+    };
+    if (output.ipamDiscoveredAccountSet === "") {
+        contents.IpamDiscoveredAccounts = [];
+    }
+    else if (output["ipamDiscoveredAccountSet"] !== undefined &&
+        output["ipamDiscoveredAccountSet"]["item"] !== undefined) {
+        contents.IpamDiscoveredAccounts = deserializeAws_ec2IpamDiscoveredAccountSet(__getArrayIfSingleItem(output["ipamDiscoveredAccountSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2GetIpamDiscoveredResourceCidrsResult = (output, context) => {
+    const contents = {
+        IpamDiscoveredResourceCidrs: undefined,
+        NextToken: undefined,
+    };
+    if (output.ipamDiscoveredResourceCidrSet === "") {
+        contents.IpamDiscoveredResourceCidrs = [];
+    }
+    else if (output["ipamDiscoveredResourceCidrSet"] !== undefined &&
+        output["ipamDiscoveredResourceCidrSet"]["item"] !== undefined) {
+        contents.IpamDiscoveredResourceCidrs = deserializeAws_ec2IpamDiscoveredResourceCidrSet(__getArrayIfSingleItem(output["ipamDiscoveredResourceCidrSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2GetIpamPoolAllocationsResult = (output, context) => {
     const contents = {
         IpamPoolAllocations: undefined,
@@ -56526,6 +57235,9 @@ const deserializeAws_ec2Ipam = (output, context) => {
         OperatingRegions: undefined,
         State: undefined,
         Tags: undefined,
+        DefaultResourceDiscoveryId: undefined,
+        DefaultResourceDiscoveryAssociationId: undefined,
+        ResourceDiscoveryAssociationCount: undefined,
     };
     if (output["ownerId"] !== undefined) {
         contents.OwnerId = __expectString(output["ownerId"]);
@@ -56566,6 +57278,15 @@ const deserializeAws_ec2Ipam = (output, context) => {
     else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
         contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
     }
+    if (output["defaultResourceDiscoveryId"] !== undefined) {
+        contents.DefaultResourceDiscoveryId = __expectString(output["defaultResourceDiscoveryId"]);
+    }
+    if (output["defaultResourceDiscoveryAssociationId"] !== undefined) {
+        contents.DefaultResourceDiscoveryAssociationId = __expectString(output["defaultResourceDiscoveryAssociationId"]);
+    }
+    if (output["resourceDiscoveryAssociationCount"] !== undefined) {
+        contents.ResourceDiscoveryAssociationCount = __strictParseInt32(output["resourceDiscoveryAssociationCount"]);
+    }
     return contents;
 };
 const deserializeAws_ec2IpamAddressHistoryRecord = (output, context) => {
@@ -56624,6 +57345,106 @@ const deserializeAws_ec2IpamAddressHistoryRecordSet = (output, context) => {
         return deserializeAws_ec2IpamAddressHistoryRecord(entry, context);
     });
 };
+const deserializeAws_ec2IpamDiscoveredAccount = (output, context) => {
+    const contents = {
+        AccountId: undefined,
+        DiscoveryRegion: undefined,
+        FailureReason: undefined,
+        LastAttemptedDiscoveryTime: undefined,
+        LastSuccessfulDiscoveryTime: undefined,
+    };
+    if (output["accountId"] !== undefined) {
+        contents.AccountId = __expectString(output["accountId"]);
+    }
+    if (output["discoveryRegion"] !== undefined) {
+        contents.DiscoveryRegion = __expectString(output["discoveryRegion"]);
+    }
+    if (output["failureReason"] !== undefined) {
+        contents.FailureReason = deserializeAws_ec2IpamDiscoveryFailureReason(output["failureReason"], context);
+    }
+    if (output["lastAttemptedDiscoveryTime"] !== undefined) {
+        contents.LastAttemptedDiscoveryTime = __expectNonNull(__parseRfc3339DateTime(output["lastAttemptedDiscoveryTime"]));
+    }
+    if (output["lastSuccessfulDiscoveryTime"] !== undefined) {
+        contents.LastSuccessfulDiscoveryTime = __expectNonNull(__parseRfc3339DateTime(output["lastSuccessfulDiscoveryTime"]));
+    }
+    return contents;
+};
+const deserializeAws_ec2IpamDiscoveredAccountSet = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2IpamDiscoveredAccount(entry, context);
+    });
+};
+const deserializeAws_ec2IpamDiscoveredResourceCidr = (output, context) => {
+    const contents = {
+        IpamResourceDiscoveryId: undefined,
+        ResourceRegion: undefined,
+        ResourceId: undefined,
+        ResourceOwnerId: undefined,
+        ResourceCidr: undefined,
+        ResourceType: undefined,
+        ResourceTags: undefined,
+        IpUsage: undefined,
+        VpcId: undefined,
+        SampleTime: undefined,
+    };
+    if (output["ipamResourceDiscoveryId"] !== undefined) {
+        contents.IpamResourceDiscoveryId = __expectString(output["ipamResourceDiscoveryId"]);
+    }
+    if (output["resourceRegion"] !== undefined) {
+        contents.ResourceRegion = __expectString(output["resourceRegion"]);
+    }
+    if (output["resourceId"] !== undefined) {
+        contents.ResourceId = __expectString(output["resourceId"]);
+    }
+    if (output["resourceOwnerId"] !== undefined) {
+        contents.ResourceOwnerId = __expectString(output["resourceOwnerId"]);
+    }
+    if (output["resourceCidr"] !== undefined) {
+        contents.ResourceCidr = __expectString(output["resourceCidr"]);
+    }
+    if (output["resourceType"] !== undefined) {
+        contents.ResourceType = __expectString(output["resourceType"]);
+    }
+    if (output.resourceTagSet === "") {
+        contents.ResourceTags = [];
+    }
+    else if (output["resourceTagSet"] !== undefined && output["resourceTagSet"]["item"] !== undefined) {
+        contents.ResourceTags = deserializeAws_ec2IpamResourceTagList(__getArrayIfSingleItem(output["resourceTagSet"]["item"]), context);
+    }
+    if (output["ipUsage"] !== undefined) {
+        contents.IpUsage = __strictParseFloat(output["ipUsage"]);
+    }
+    if (output["vpcId"] !== undefined) {
+        contents.VpcId = __expectString(output["vpcId"]);
+    }
+    if (output["sampleTime"] !== undefined) {
+        contents.SampleTime = __expectNonNull(__parseRfc3339DateTime(output["sampleTime"]));
+    }
+    return contents;
+};
+const deserializeAws_ec2IpamDiscoveredResourceCidrSet = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2IpamDiscoveredResourceCidr(entry, context);
+    });
+};
+const deserializeAws_ec2IpamDiscoveryFailureReason = (output, context) => {
+    const contents = {
+        Code: undefined,
+        Message: undefined,
+    };
+    if (output["code"] !== undefined) {
+        contents.Code = __expectString(output["code"]);
+    }
+    if (output["message"] !== undefined) {
+        contents.Message = __expectString(output["message"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2IpamOperatingRegion = (output, context) => {
     const contents = {
         RegionName: undefined,
@@ -56664,6 +57485,7 @@ const deserializeAws_ec2IpamPool = (output, context) => {
         AllocationResourceTags: undefined,
         Tags: undefined,
         AwsService: undefined,
+        PublicIpSource: undefined,
     };
     if (output["ownerId"] !== undefined) {
         contents.OwnerId = __expectString(output["ownerId"]);
@@ -56738,6 +57560,9 @@ const deserializeAws_ec2IpamPool = (output, context) => {
     if (output["awsService"] !== undefined) {
         contents.AwsService = __expectString(output["awsService"]);
     }
+    if (output["publicIpSource"] !== undefined) {
+        contents.PublicIpSource = __expectString(output["publicIpSource"]);
+    }
     return contents;
 };
 const deserializeAws_ec2IpamPoolAllocation = (output, context) => {
@@ -56785,6 +57610,8 @@ const deserializeAws_ec2IpamPoolCidr = (output, context) => {
         Cidr: undefined,
         State: undefined,
         FailureReason: undefined,
+        IpamPoolCidrId: undefined,
+        NetmaskLength: undefined,
     };
     if (output["cidr"] !== undefined) {
         contents.Cidr = __expectString(output["cidr"]);
@@ -56795,6 +57622,12 @@ const deserializeAws_ec2IpamPoolCidr = (output, context) => {
     if (output["failureReason"] !== undefined) {
         contents.FailureReason = deserializeAws_ec2IpamPoolCidrFailureReason(output["failureReason"], context);
     }
+    if (output["ipamPoolCidrId"] !== undefined) {
+        contents.IpamPoolCidrId = __expectString(output["ipamPoolCidrId"]);
+    }
+    if (output["netmaskLength"] !== undefined) {
+        contents.NetmaskLength = __strictParseInt32(output["netmaskLength"]);
+    }
     return contents;
 };
 const deserializeAws_ec2IpamPoolCidrFailureReason = (output, context) => {
@@ -56899,6 +57732,119 @@ const deserializeAws_ec2IpamResourceCidrSet = (output, context) => {
         return deserializeAws_ec2IpamResourceCidr(entry, context);
     });
 };
+const deserializeAws_ec2IpamResourceDiscovery = (output, context) => {
+    const contents = {
+        OwnerId: undefined,
+        IpamResourceDiscoveryId: undefined,
+        IpamResourceDiscoveryArn: undefined,
+        IpamResourceDiscoveryRegion: undefined,
+        Description: undefined,
+        OperatingRegions: undefined,
+        IsDefault: undefined,
+        State: undefined,
+        Tags: undefined,
+    };
+    if (output["ownerId"] !== undefined) {
+        contents.OwnerId = __expectString(output["ownerId"]);
+    }
+    if (output["ipamResourceDiscoveryId"] !== undefined) {
+        contents.IpamResourceDiscoveryId = __expectString(output["ipamResourceDiscoveryId"]);
+    }
+    if (output["ipamResourceDiscoveryArn"] !== undefined) {
+        contents.IpamResourceDiscoveryArn = __expectString(output["ipamResourceDiscoveryArn"]);
+    }
+    if (output["ipamResourceDiscoveryRegion"] !== undefined) {
+        contents.IpamResourceDiscoveryRegion = __expectString(output["ipamResourceDiscoveryRegion"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output.operatingRegionSet === "") {
+        contents.OperatingRegions = [];
+    }
+    else if (output["operatingRegionSet"] !== undefined && output["operatingRegionSet"]["item"] !== undefined) {
+        contents.OperatingRegions = deserializeAws_ec2IpamOperatingRegionSet(__getArrayIfSingleItem(output["operatingRegionSet"]["item"]), context);
+    }
+    if (output["isDefault"] !== undefined) {
+        contents.IsDefault = __parseBoolean(output["isDefault"]);
+    }
+    if (output["state"] !== undefined) {
+        contents.State = __expectString(output["state"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2IpamResourceDiscoveryAssociation = (output, context) => {
+    const contents = {
+        OwnerId: undefined,
+        IpamResourceDiscoveryAssociationId: undefined,
+        IpamResourceDiscoveryAssociationArn: undefined,
+        IpamResourceDiscoveryId: undefined,
+        IpamId: undefined,
+        IpamArn: undefined,
+        IpamRegion: undefined,
+        IsDefault: undefined,
+        ResourceDiscoveryStatus: undefined,
+        State: undefined,
+        Tags: undefined,
+    };
+    if (output["ownerId"] !== undefined) {
+        contents.OwnerId = __expectString(output["ownerId"]);
+    }
+    if (output["ipamResourceDiscoveryAssociationId"] !== undefined) {
+        contents.IpamResourceDiscoveryAssociationId = __expectString(output["ipamResourceDiscoveryAssociationId"]);
+    }
+    if (output["ipamResourceDiscoveryAssociationArn"] !== undefined) {
+        contents.IpamResourceDiscoveryAssociationArn = __expectString(output["ipamResourceDiscoveryAssociationArn"]);
+    }
+    if (output["ipamResourceDiscoveryId"] !== undefined) {
+        contents.IpamResourceDiscoveryId = __expectString(output["ipamResourceDiscoveryId"]);
+    }
+    if (output["ipamId"] !== undefined) {
+        contents.IpamId = __expectString(output["ipamId"]);
+    }
+    if (output["ipamArn"] !== undefined) {
+        contents.IpamArn = __expectString(output["ipamArn"]);
+    }
+    if (output["ipamRegion"] !== undefined) {
+        contents.IpamRegion = __expectString(output["ipamRegion"]);
+    }
+    if (output["isDefault"] !== undefined) {
+        contents.IsDefault = __parseBoolean(output["isDefault"]);
+    }
+    if (output["resourceDiscoveryStatus"] !== undefined) {
+        contents.ResourceDiscoveryStatus = __expectString(output["resourceDiscoveryStatus"]);
+    }
+    if (output["state"] !== undefined) {
+        contents.State = __expectString(output["state"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2IpamResourceDiscoveryAssociationSet = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2IpamResourceDiscoveryAssociation(entry, context);
+    });
+};
+const deserializeAws_ec2IpamResourceDiscoverySet = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2IpamResourceDiscovery(entry, context);
+    });
+};
 const deserializeAws_ec2IpamResourceTag = (output, context) => {
     const contents = {
         Key: undefined,
@@ -58783,6 +59729,15 @@ const deserializeAws_ec2ModifyIpamResourceCidrResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2ModifyIpamResourceDiscoveryResult = (output, context) => {
+    const contents = {
+        IpamResourceDiscovery: undefined,
+    };
+    if (output["ipamResourceDiscovery"] !== undefined) {
+        contents.IpamResourceDiscovery = deserializeAws_ec2IpamResourceDiscovery(output["ipamResourceDiscovery"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2ModifyIpamResult = (output, context) => {
     const contents = {
         Ipam: undefined,