in aws-cpp-sdk-securityhub/source/model/AwsSecurityFindingFilters.cpp [1127:2133]
JsonValue AwsSecurityFindingFilters::Jsonize() const
{
JsonValue payload;
if(m_productArnHasBeenSet)
{
Array<JsonValue> productArnJsonList(m_productArn.size());
for(unsigned productArnIndex = 0; productArnIndex < productArnJsonList.GetLength(); ++productArnIndex)
{
productArnJsonList[productArnIndex].AsObject(m_productArn[productArnIndex].Jsonize());
}
payload.WithArray("ProductArn", std::move(productArnJsonList));
}
if(m_awsAccountIdHasBeenSet)
{
Array<JsonValue> awsAccountIdJsonList(m_awsAccountId.size());
for(unsigned awsAccountIdIndex = 0; awsAccountIdIndex < awsAccountIdJsonList.GetLength(); ++awsAccountIdIndex)
{
awsAccountIdJsonList[awsAccountIdIndex].AsObject(m_awsAccountId[awsAccountIdIndex].Jsonize());
}
payload.WithArray("AwsAccountId", std::move(awsAccountIdJsonList));
}
if(m_idHasBeenSet)
{
Array<JsonValue> idJsonList(m_id.size());
for(unsigned idIndex = 0; idIndex < idJsonList.GetLength(); ++idIndex)
{
idJsonList[idIndex].AsObject(m_id[idIndex].Jsonize());
}
payload.WithArray("Id", std::move(idJsonList));
}
if(m_generatorIdHasBeenSet)
{
Array<JsonValue> generatorIdJsonList(m_generatorId.size());
for(unsigned generatorIdIndex = 0; generatorIdIndex < generatorIdJsonList.GetLength(); ++generatorIdIndex)
{
generatorIdJsonList[generatorIdIndex].AsObject(m_generatorId[generatorIdIndex].Jsonize());
}
payload.WithArray("GeneratorId", std::move(generatorIdJsonList));
}
if(m_regionHasBeenSet)
{
Array<JsonValue> regionJsonList(m_region.size());
for(unsigned regionIndex = 0; regionIndex < regionJsonList.GetLength(); ++regionIndex)
{
regionJsonList[regionIndex].AsObject(m_region[regionIndex].Jsonize());
}
payload.WithArray("Region", std::move(regionJsonList));
}
if(m_typeHasBeenSet)
{
Array<JsonValue> typeJsonList(m_type.size());
for(unsigned typeIndex = 0; typeIndex < typeJsonList.GetLength(); ++typeIndex)
{
typeJsonList[typeIndex].AsObject(m_type[typeIndex].Jsonize());
}
payload.WithArray("Type", std::move(typeJsonList));
}
if(m_firstObservedAtHasBeenSet)
{
Array<JsonValue> firstObservedAtJsonList(m_firstObservedAt.size());
for(unsigned firstObservedAtIndex = 0; firstObservedAtIndex < firstObservedAtJsonList.GetLength(); ++firstObservedAtIndex)
{
firstObservedAtJsonList[firstObservedAtIndex].AsObject(m_firstObservedAt[firstObservedAtIndex].Jsonize());
}
payload.WithArray("FirstObservedAt", std::move(firstObservedAtJsonList));
}
if(m_lastObservedAtHasBeenSet)
{
Array<JsonValue> lastObservedAtJsonList(m_lastObservedAt.size());
for(unsigned lastObservedAtIndex = 0; lastObservedAtIndex < lastObservedAtJsonList.GetLength(); ++lastObservedAtIndex)
{
lastObservedAtJsonList[lastObservedAtIndex].AsObject(m_lastObservedAt[lastObservedAtIndex].Jsonize());
}
payload.WithArray("LastObservedAt", std::move(lastObservedAtJsonList));
}
if(m_createdAtHasBeenSet)
{
Array<JsonValue> createdAtJsonList(m_createdAt.size());
for(unsigned createdAtIndex = 0; createdAtIndex < createdAtJsonList.GetLength(); ++createdAtIndex)
{
createdAtJsonList[createdAtIndex].AsObject(m_createdAt[createdAtIndex].Jsonize());
}
payload.WithArray("CreatedAt", std::move(createdAtJsonList));
}
if(m_updatedAtHasBeenSet)
{
Array<JsonValue> updatedAtJsonList(m_updatedAt.size());
for(unsigned updatedAtIndex = 0; updatedAtIndex < updatedAtJsonList.GetLength(); ++updatedAtIndex)
{
updatedAtJsonList[updatedAtIndex].AsObject(m_updatedAt[updatedAtIndex].Jsonize());
}
payload.WithArray("UpdatedAt", std::move(updatedAtJsonList));
}
if(m_severityLabelHasBeenSet)
{
Array<JsonValue> severityLabelJsonList(m_severityLabel.size());
for(unsigned severityLabelIndex = 0; severityLabelIndex < severityLabelJsonList.GetLength(); ++severityLabelIndex)
{
severityLabelJsonList[severityLabelIndex].AsObject(m_severityLabel[severityLabelIndex].Jsonize());
}
payload.WithArray("SeverityLabel", std::move(severityLabelJsonList));
}
if(m_confidenceHasBeenSet)
{
Array<JsonValue> confidenceJsonList(m_confidence.size());
for(unsigned confidenceIndex = 0; confidenceIndex < confidenceJsonList.GetLength(); ++confidenceIndex)
{
confidenceJsonList[confidenceIndex].AsObject(m_confidence[confidenceIndex].Jsonize());
}
payload.WithArray("Confidence", std::move(confidenceJsonList));
}
if(m_criticalityHasBeenSet)
{
Array<JsonValue> criticalityJsonList(m_criticality.size());
for(unsigned criticalityIndex = 0; criticalityIndex < criticalityJsonList.GetLength(); ++criticalityIndex)
{
criticalityJsonList[criticalityIndex].AsObject(m_criticality[criticalityIndex].Jsonize());
}
payload.WithArray("Criticality", std::move(criticalityJsonList));
}
if(m_titleHasBeenSet)
{
Array<JsonValue> titleJsonList(m_title.size());
for(unsigned titleIndex = 0; titleIndex < titleJsonList.GetLength(); ++titleIndex)
{
titleJsonList[titleIndex].AsObject(m_title[titleIndex].Jsonize());
}
payload.WithArray("Title", std::move(titleJsonList));
}
if(m_descriptionHasBeenSet)
{
Array<JsonValue> descriptionJsonList(m_description.size());
for(unsigned descriptionIndex = 0; descriptionIndex < descriptionJsonList.GetLength(); ++descriptionIndex)
{
descriptionJsonList[descriptionIndex].AsObject(m_description[descriptionIndex].Jsonize());
}
payload.WithArray("Description", std::move(descriptionJsonList));
}
if(m_recommendationTextHasBeenSet)
{
Array<JsonValue> recommendationTextJsonList(m_recommendationText.size());
for(unsigned recommendationTextIndex = 0; recommendationTextIndex < recommendationTextJsonList.GetLength(); ++recommendationTextIndex)
{
recommendationTextJsonList[recommendationTextIndex].AsObject(m_recommendationText[recommendationTextIndex].Jsonize());
}
payload.WithArray("RecommendationText", std::move(recommendationTextJsonList));
}
if(m_sourceUrlHasBeenSet)
{
Array<JsonValue> sourceUrlJsonList(m_sourceUrl.size());
for(unsigned sourceUrlIndex = 0; sourceUrlIndex < sourceUrlJsonList.GetLength(); ++sourceUrlIndex)
{
sourceUrlJsonList[sourceUrlIndex].AsObject(m_sourceUrl[sourceUrlIndex].Jsonize());
}
payload.WithArray("SourceUrl", std::move(sourceUrlJsonList));
}
if(m_productFieldsHasBeenSet)
{
Array<JsonValue> productFieldsJsonList(m_productFields.size());
for(unsigned productFieldsIndex = 0; productFieldsIndex < productFieldsJsonList.GetLength(); ++productFieldsIndex)
{
productFieldsJsonList[productFieldsIndex].AsObject(m_productFields[productFieldsIndex].Jsonize());
}
payload.WithArray("ProductFields", std::move(productFieldsJsonList));
}
if(m_productNameHasBeenSet)
{
Array<JsonValue> productNameJsonList(m_productName.size());
for(unsigned productNameIndex = 0; productNameIndex < productNameJsonList.GetLength(); ++productNameIndex)
{
productNameJsonList[productNameIndex].AsObject(m_productName[productNameIndex].Jsonize());
}
payload.WithArray("ProductName", std::move(productNameJsonList));
}
if(m_companyNameHasBeenSet)
{
Array<JsonValue> companyNameJsonList(m_companyName.size());
for(unsigned companyNameIndex = 0; companyNameIndex < companyNameJsonList.GetLength(); ++companyNameIndex)
{
companyNameJsonList[companyNameIndex].AsObject(m_companyName[companyNameIndex].Jsonize());
}
payload.WithArray("CompanyName", std::move(companyNameJsonList));
}
if(m_userDefinedFieldsHasBeenSet)
{
Array<JsonValue> userDefinedFieldsJsonList(m_userDefinedFields.size());
for(unsigned userDefinedFieldsIndex = 0; userDefinedFieldsIndex < userDefinedFieldsJsonList.GetLength(); ++userDefinedFieldsIndex)
{
userDefinedFieldsJsonList[userDefinedFieldsIndex].AsObject(m_userDefinedFields[userDefinedFieldsIndex].Jsonize());
}
payload.WithArray("UserDefinedFields", std::move(userDefinedFieldsJsonList));
}
if(m_malwareNameHasBeenSet)
{
Array<JsonValue> malwareNameJsonList(m_malwareName.size());
for(unsigned malwareNameIndex = 0; malwareNameIndex < malwareNameJsonList.GetLength(); ++malwareNameIndex)
{
malwareNameJsonList[malwareNameIndex].AsObject(m_malwareName[malwareNameIndex].Jsonize());
}
payload.WithArray("MalwareName", std::move(malwareNameJsonList));
}
if(m_malwareTypeHasBeenSet)
{
Array<JsonValue> malwareTypeJsonList(m_malwareType.size());
for(unsigned malwareTypeIndex = 0; malwareTypeIndex < malwareTypeJsonList.GetLength(); ++malwareTypeIndex)
{
malwareTypeJsonList[malwareTypeIndex].AsObject(m_malwareType[malwareTypeIndex].Jsonize());
}
payload.WithArray("MalwareType", std::move(malwareTypeJsonList));
}
if(m_malwarePathHasBeenSet)
{
Array<JsonValue> malwarePathJsonList(m_malwarePath.size());
for(unsigned malwarePathIndex = 0; malwarePathIndex < malwarePathJsonList.GetLength(); ++malwarePathIndex)
{
malwarePathJsonList[malwarePathIndex].AsObject(m_malwarePath[malwarePathIndex].Jsonize());
}
payload.WithArray("MalwarePath", std::move(malwarePathJsonList));
}
if(m_malwareStateHasBeenSet)
{
Array<JsonValue> malwareStateJsonList(m_malwareState.size());
for(unsigned malwareStateIndex = 0; malwareStateIndex < malwareStateJsonList.GetLength(); ++malwareStateIndex)
{
malwareStateJsonList[malwareStateIndex].AsObject(m_malwareState[malwareStateIndex].Jsonize());
}
payload.WithArray("MalwareState", std::move(malwareStateJsonList));
}
if(m_networkDirectionHasBeenSet)
{
Array<JsonValue> networkDirectionJsonList(m_networkDirection.size());
for(unsigned networkDirectionIndex = 0; networkDirectionIndex < networkDirectionJsonList.GetLength(); ++networkDirectionIndex)
{
networkDirectionJsonList[networkDirectionIndex].AsObject(m_networkDirection[networkDirectionIndex].Jsonize());
}
payload.WithArray("NetworkDirection", std::move(networkDirectionJsonList));
}
if(m_networkProtocolHasBeenSet)
{
Array<JsonValue> networkProtocolJsonList(m_networkProtocol.size());
for(unsigned networkProtocolIndex = 0; networkProtocolIndex < networkProtocolJsonList.GetLength(); ++networkProtocolIndex)
{
networkProtocolJsonList[networkProtocolIndex].AsObject(m_networkProtocol[networkProtocolIndex].Jsonize());
}
payload.WithArray("NetworkProtocol", std::move(networkProtocolJsonList));
}
if(m_networkSourceIpV4HasBeenSet)
{
Array<JsonValue> networkSourceIpV4JsonList(m_networkSourceIpV4.size());
for(unsigned networkSourceIpV4Index = 0; networkSourceIpV4Index < networkSourceIpV4JsonList.GetLength(); ++networkSourceIpV4Index)
{
networkSourceIpV4JsonList[networkSourceIpV4Index].AsObject(m_networkSourceIpV4[networkSourceIpV4Index].Jsonize());
}
payload.WithArray("NetworkSourceIpV4", std::move(networkSourceIpV4JsonList));
}
if(m_networkSourceIpV6HasBeenSet)
{
Array<JsonValue> networkSourceIpV6JsonList(m_networkSourceIpV6.size());
for(unsigned networkSourceIpV6Index = 0; networkSourceIpV6Index < networkSourceIpV6JsonList.GetLength(); ++networkSourceIpV6Index)
{
networkSourceIpV6JsonList[networkSourceIpV6Index].AsObject(m_networkSourceIpV6[networkSourceIpV6Index].Jsonize());
}
payload.WithArray("NetworkSourceIpV6", std::move(networkSourceIpV6JsonList));
}
if(m_networkSourcePortHasBeenSet)
{
Array<JsonValue> networkSourcePortJsonList(m_networkSourcePort.size());
for(unsigned networkSourcePortIndex = 0; networkSourcePortIndex < networkSourcePortJsonList.GetLength(); ++networkSourcePortIndex)
{
networkSourcePortJsonList[networkSourcePortIndex].AsObject(m_networkSourcePort[networkSourcePortIndex].Jsonize());
}
payload.WithArray("NetworkSourcePort", std::move(networkSourcePortJsonList));
}
if(m_networkSourceDomainHasBeenSet)
{
Array<JsonValue> networkSourceDomainJsonList(m_networkSourceDomain.size());
for(unsigned networkSourceDomainIndex = 0; networkSourceDomainIndex < networkSourceDomainJsonList.GetLength(); ++networkSourceDomainIndex)
{
networkSourceDomainJsonList[networkSourceDomainIndex].AsObject(m_networkSourceDomain[networkSourceDomainIndex].Jsonize());
}
payload.WithArray("NetworkSourceDomain", std::move(networkSourceDomainJsonList));
}
if(m_networkSourceMacHasBeenSet)
{
Array<JsonValue> networkSourceMacJsonList(m_networkSourceMac.size());
for(unsigned networkSourceMacIndex = 0; networkSourceMacIndex < networkSourceMacJsonList.GetLength(); ++networkSourceMacIndex)
{
networkSourceMacJsonList[networkSourceMacIndex].AsObject(m_networkSourceMac[networkSourceMacIndex].Jsonize());
}
payload.WithArray("NetworkSourceMac", std::move(networkSourceMacJsonList));
}
if(m_networkDestinationIpV4HasBeenSet)
{
Array<JsonValue> networkDestinationIpV4JsonList(m_networkDestinationIpV4.size());
for(unsigned networkDestinationIpV4Index = 0; networkDestinationIpV4Index < networkDestinationIpV4JsonList.GetLength(); ++networkDestinationIpV4Index)
{
networkDestinationIpV4JsonList[networkDestinationIpV4Index].AsObject(m_networkDestinationIpV4[networkDestinationIpV4Index].Jsonize());
}
payload.WithArray("NetworkDestinationIpV4", std::move(networkDestinationIpV4JsonList));
}
if(m_networkDestinationIpV6HasBeenSet)
{
Array<JsonValue> networkDestinationIpV6JsonList(m_networkDestinationIpV6.size());
for(unsigned networkDestinationIpV6Index = 0; networkDestinationIpV6Index < networkDestinationIpV6JsonList.GetLength(); ++networkDestinationIpV6Index)
{
networkDestinationIpV6JsonList[networkDestinationIpV6Index].AsObject(m_networkDestinationIpV6[networkDestinationIpV6Index].Jsonize());
}
payload.WithArray("NetworkDestinationIpV6", std::move(networkDestinationIpV6JsonList));
}
if(m_networkDestinationPortHasBeenSet)
{
Array<JsonValue> networkDestinationPortJsonList(m_networkDestinationPort.size());
for(unsigned networkDestinationPortIndex = 0; networkDestinationPortIndex < networkDestinationPortJsonList.GetLength(); ++networkDestinationPortIndex)
{
networkDestinationPortJsonList[networkDestinationPortIndex].AsObject(m_networkDestinationPort[networkDestinationPortIndex].Jsonize());
}
payload.WithArray("NetworkDestinationPort", std::move(networkDestinationPortJsonList));
}
if(m_networkDestinationDomainHasBeenSet)
{
Array<JsonValue> networkDestinationDomainJsonList(m_networkDestinationDomain.size());
for(unsigned networkDestinationDomainIndex = 0; networkDestinationDomainIndex < networkDestinationDomainJsonList.GetLength(); ++networkDestinationDomainIndex)
{
networkDestinationDomainJsonList[networkDestinationDomainIndex].AsObject(m_networkDestinationDomain[networkDestinationDomainIndex].Jsonize());
}
payload.WithArray("NetworkDestinationDomain", std::move(networkDestinationDomainJsonList));
}
if(m_processNameHasBeenSet)
{
Array<JsonValue> processNameJsonList(m_processName.size());
for(unsigned processNameIndex = 0; processNameIndex < processNameJsonList.GetLength(); ++processNameIndex)
{
processNameJsonList[processNameIndex].AsObject(m_processName[processNameIndex].Jsonize());
}
payload.WithArray("ProcessName", std::move(processNameJsonList));
}
if(m_processPathHasBeenSet)
{
Array<JsonValue> processPathJsonList(m_processPath.size());
for(unsigned processPathIndex = 0; processPathIndex < processPathJsonList.GetLength(); ++processPathIndex)
{
processPathJsonList[processPathIndex].AsObject(m_processPath[processPathIndex].Jsonize());
}
payload.WithArray("ProcessPath", std::move(processPathJsonList));
}
if(m_processPidHasBeenSet)
{
Array<JsonValue> processPidJsonList(m_processPid.size());
for(unsigned processPidIndex = 0; processPidIndex < processPidJsonList.GetLength(); ++processPidIndex)
{
processPidJsonList[processPidIndex].AsObject(m_processPid[processPidIndex].Jsonize());
}
payload.WithArray("ProcessPid", std::move(processPidJsonList));
}
if(m_processParentPidHasBeenSet)
{
Array<JsonValue> processParentPidJsonList(m_processParentPid.size());
for(unsigned processParentPidIndex = 0; processParentPidIndex < processParentPidJsonList.GetLength(); ++processParentPidIndex)
{
processParentPidJsonList[processParentPidIndex].AsObject(m_processParentPid[processParentPidIndex].Jsonize());
}
payload.WithArray("ProcessParentPid", std::move(processParentPidJsonList));
}
if(m_processLaunchedAtHasBeenSet)
{
Array<JsonValue> processLaunchedAtJsonList(m_processLaunchedAt.size());
for(unsigned processLaunchedAtIndex = 0; processLaunchedAtIndex < processLaunchedAtJsonList.GetLength(); ++processLaunchedAtIndex)
{
processLaunchedAtJsonList[processLaunchedAtIndex].AsObject(m_processLaunchedAt[processLaunchedAtIndex].Jsonize());
}
payload.WithArray("ProcessLaunchedAt", std::move(processLaunchedAtJsonList));
}
if(m_processTerminatedAtHasBeenSet)
{
Array<JsonValue> processTerminatedAtJsonList(m_processTerminatedAt.size());
for(unsigned processTerminatedAtIndex = 0; processTerminatedAtIndex < processTerminatedAtJsonList.GetLength(); ++processTerminatedAtIndex)
{
processTerminatedAtJsonList[processTerminatedAtIndex].AsObject(m_processTerminatedAt[processTerminatedAtIndex].Jsonize());
}
payload.WithArray("ProcessTerminatedAt", std::move(processTerminatedAtJsonList));
}
if(m_threatIntelIndicatorTypeHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorTypeJsonList(m_threatIntelIndicatorType.size());
for(unsigned threatIntelIndicatorTypeIndex = 0; threatIntelIndicatorTypeIndex < threatIntelIndicatorTypeJsonList.GetLength(); ++threatIntelIndicatorTypeIndex)
{
threatIntelIndicatorTypeJsonList[threatIntelIndicatorTypeIndex].AsObject(m_threatIntelIndicatorType[threatIntelIndicatorTypeIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorType", std::move(threatIntelIndicatorTypeJsonList));
}
if(m_threatIntelIndicatorValueHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorValueJsonList(m_threatIntelIndicatorValue.size());
for(unsigned threatIntelIndicatorValueIndex = 0; threatIntelIndicatorValueIndex < threatIntelIndicatorValueJsonList.GetLength(); ++threatIntelIndicatorValueIndex)
{
threatIntelIndicatorValueJsonList[threatIntelIndicatorValueIndex].AsObject(m_threatIntelIndicatorValue[threatIntelIndicatorValueIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorValue", std::move(threatIntelIndicatorValueJsonList));
}
if(m_threatIntelIndicatorCategoryHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorCategoryJsonList(m_threatIntelIndicatorCategory.size());
for(unsigned threatIntelIndicatorCategoryIndex = 0; threatIntelIndicatorCategoryIndex < threatIntelIndicatorCategoryJsonList.GetLength(); ++threatIntelIndicatorCategoryIndex)
{
threatIntelIndicatorCategoryJsonList[threatIntelIndicatorCategoryIndex].AsObject(m_threatIntelIndicatorCategory[threatIntelIndicatorCategoryIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorCategory", std::move(threatIntelIndicatorCategoryJsonList));
}
if(m_threatIntelIndicatorLastObservedAtHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorLastObservedAtJsonList(m_threatIntelIndicatorLastObservedAt.size());
for(unsigned threatIntelIndicatorLastObservedAtIndex = 0; threatIntelIndicatorLastObservedAtIndex < threatIntelIndicatorLastObservedAtJsonList.GetLength(); ++threatIntelIndicatorLastObservedAtIndex)
{
threatIntelIndicatorLastObservedAtJsonList[threatIntelIndicatorLastObservedAtIndex].AsObject(m_threatIntelIndicatorLastObservedAt[threatIntelIndicatorLastObservedAtIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorLastObservedAt", std::move(threatIntelIndicatorLastObservedAtJsonList));
}
if(m_threatIntelIndicatorSourceHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorSourceJsonList(m_threatIntelIndicatorSource.size());
for(unsigned threatIntelIndicatorSourceIndex = 0; threatIntelIndicatorSourceIndex < threatIntelIndicatorSourceJsonList.GetLength(); ++threatIntelIndicatorSourceIndex)
{
threatIntelIndicatorSourceJsonList[threatIntelIndicatorSourceIndex].AsObject(m_threatIntelIndicatorSource[threatIntelIndicatorSourceIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorSource", std::move(threatIntelIndicatorSourceJsonList));
}
if(m_threatIntelIndicatorSourceUrlHasBeenSet)
{
Array<JsonValue> threatIntelIndicatorSourceUrlJsonList(m_threatIntelIndicatorSourceUrl.size());
for(unsigned threatIntelIndicatorSourceUrlIndex = 0; threatIntelIndicatorSourceUrlIndex < threatIntelIndicatorSourceUrlJsonList.GetLength(); ++threatIntelIndicatorSourceUrlIndex)
{
threatIntelIndicatorSourceUrlJsonList[threatIntelIndicatorSourceUrlIndex].AsObject(m_threatIntelIndicatorSourceUrl[threatIntelIndicatorSourceUrlIndex].Jsonize());
}
payload.WithArray("ThreatIntelIndicatorSourceUrl", std::move(threatIntelIndicatorSourceUrlJsonList));
}
if(m_resourceTypeHasBeenSet)
{
Array<JsonValue> resourceTypeJsonList(m_resourceType.size());
for(unsigned resourceTypeIndex = 0; resourceTypeIndex < resourceTypeJsonList.GetLength(); ++resourceTypeIndex)
{
resourceTypeJsonList[resourceTypeIndex].AsObject(m_resourceType[resourceTypeIndex].Jsonize());
}
payload.WithArray("ResourceType", std::move(resourceTypeJsonList));
}
if(m_resourceIdHasBeenSet)
{
Array<JsonValue> resourceIdJsonList(m_resourceId.size());
for(unsigned resourceIdIndex = 0; resourceIdIndex < resourceIdJsonList.GetLength(); ++resourceIdIndex)
{
resourceIdJsonList[resourceIdIndex].AsObject(m_resourceId[resourceIdIndex].Jsonize());
}
payload.WithArray("ResourceId", std::move(resourceIdJsonList));
}
if(m_resourcePartitionHasBeenSet)
{
Array<JsonValue> resourcePartitionJsonList(m_resourcePartition.size());
for(unsigned resourcePartitionIndex = 0; resourcePartitionIndex < resourcePartitionJsonList.GetLength(); ++resourcePartitionIndex)
{
resourcePartitionJsonList[resourcePartitionIndex].AsObject(m_resourcePartition[resourcePartitionIndex].Jsonize());
}
payload.WithArray("ResourcePartition", std::move(resourcePartitionJsonList));
}
if(m_resourceRegionHasBeenSet)
{
Array<JsonValue> resourceRegionJsonList(m_resourceRegion.size());
for(unsigned resourceRegionIndex = 0; resourceRegionIndex < resourceRegionJsonList.GetLength(); ++resourceRegionIndex)
{
resourceRegionJsonList[resourceRegionIndex].AsObject(m_resourceRegion[resourceRegionIndex].Jsonize());
}
payload.WithArray("ResourceRegion", std::move(resourceRegionJsonList));
}
if(m_resourceTagsHasBeenSet)
{
Array<JsonValue> resourceTagsJsonList(m_resourceTags.size());
for(unsigned resourceTagsIndex = 0; resourceTagsIndex < resourceTagsJsonList.GetLength(); ++resourceTagsIndex)
{
resourceTagsJsonList[resourceTagsIndex].AsObject(m_resourceTags[resourceTagsIndex].Jsonize());
}
payload.WithArray("ResourceTags", std::move(resourceTagsJsonList));
}
if(m_resourceAwsEc2InstanceTypeHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceTypeJsonList(m_resourceAwsEc2InstanceType.size());
for(unsigned resourceAwsEc2InstanceTypeIndex = 0; resourceAwsEc2InstanceTypeIndex < resourceAwsEc2InstanceTypeJsonList.GetLength(); ++resourceAwsEc2InstanceTypeIndex)
{
resourceAwsEc2InstanceTypeJsonList[resourceAwsEc2InstanceTypeIndex].AsObject(m_resourceAwsEc2InstanceType[resourceAwsEc2InstanceTypeIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceType", std::move(resourceAwsEc2InstanceTypeJsonList));
}
if(m_resourceAwsEc2InstanceImageIdHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceImageIdJsonList(m_resourceAwsEc2InstanceImageId.size());
for(unsigned resourceAwsEc2InstanceImageIdIndex = 0; resourceAwsEc2InstanceImageIdIndex < resourceAwsEc2InstanceImageIdJsonList.GetLength(); ++resourceAwsEc2InstanceImageIdIndex)
{
resourceAwsEc2InstanceImageIdJsonList[resourceAwsEc2InstanceImageIdIndex].AsObject(m_resourceAwsEc2InstanceImageId[resourceAwsEc2InstanceImageIdIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceImageId", std::move(resourceAwsEc2InstanceImageIdJsonList));
}
if(m_resourceAwsEc2InstanceIpV4AddressesHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceIpV4AddressesJsonList(m_resourceAwsEc2InstanceIpV4Addresses.size());
for(unsigned resourceAwsEc2InstanceIpV4AddressesIndex = 0; resourceAwsEc2InstanceIpV4AddressesIndex < resourceAwsEc2InstanceIpV4AddressesJsonList.GetLength(); ++resourceAwsEc2InstanceIpV4AddressesIndex)
{
resourceAwsEc2InstanceIpV4AddressesJsonList[resourceAwsEc2InstanceIpV4AddressesIndex].AsObject(m_resourceAwsEc2InstanceIpV4Addresses[resourceAwsEc2InstanceIpV4AddressesIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceIpV4Addresses", std::move(resourceAwsEc2InstanceIpV4AddressesJsonList));
}
if(m_resourceAwsEc2InstanceIpV6AddressesHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceIpV6AddressesJsonList(m_resourceAwsEc2InstanceIpV6Addresses.size());
for(unsigned resourceAwsEc2InstanceIpV6AddressesIndex = 0; resourceAwsEc2InstanceIpV6AddressesIndex < resourceAwsEc2InstanceIpV6AddressesJsonList.GetLength(); ++resourceAwsEc2InstanceIpV6AddressesIndex)
{
resourceAwsEc2InstanceIpV6AddressesJsonList[resourceAwsEc2InstanceIpV6AddressesIndex].AsObject(m_resourceAwsEc2InstanceIpV6Addresses[resourceAwsEc2InstanceIpV6AddressesIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceIpV6Addresses", std::move(resourceAwsEc2InstanceIpV6AddressesJsonList));
}
if(m_resourceAwsEc2InstanceKeyNameHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceKeyNameJsonList(m_resourceAwsEc2InstanceKeyName.size());
for(unsigned resourceAwsEc2InstanceKeyNameIndex = 0; resourceAwsEc2InstanceKeyNameIndex < resourceAwsEc2InstanceKeyNameJsonList.GetLength(); ++resourceAwsEc2InstanceKeyNameIndex)
{
resourceAwsEc2InstanceKeyNameJsonList[resourceAwsEc2InstanceKeyNameIndex].AsObject(m_resourceAwsEc2InstanceKeyName[resourceAwsEc2InstanceKeyNameIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceKeyName", std::move(resourceAwsEc2InstanceKeyNameJsonList));
}
if(m_resourceAwsEc2InstanceIamInstanceProfileArnHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceIamInstanceProfileArnJsonList(m_resourceAwsEc2InstanceIamInstanceProfileArn.size());
for(unsigned resourceAwsEc2InstanceIamInstanceProfileArnIndex = 0; resourceAwsEc2InstanceIamInstanceProfileArnIndex < resourceAwsEc2InstanceIamInstanceProfileArnJsonList.GetLength(); ++resourceAwsEc2InstanceIamInstanceProfileArnIndex)
{
resourceAwsEc2InstanceIamInstanceProfileArnJsonList[resourceAwsEc2InstanceIamInstanceProfileArnIndex].AsObject(m_resourceAwsEc2InstanceIamInstanceProfileArn[resourceAwsEc2InstanceIamInstanceProfileArnIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceIamInstanceProfileArn", std::move(resourceAwsEc2InstanceIamInstanceProfileArnJsonList));
}
if(m_resourceAwsEc2InstanceVpcIdHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceVpcIdJsonList(m_resourceAwsEc2InstanceVpcId.size());
for(unsigned resourceAwsEc2InstanceVpcIdIndex = 0; resourceAwsEc2InstanceVpcIdIndex < resourceAwsEc2InstanceVpcIdJsonList.GetLength(); ++resourceAwsEc2InstanceVpcIdIndex)
{
resourceAwsEc2InstanceVpcIdJsonList[resourceAwsEc2InstanceVpcIdIndex].AsObject(m_resourceAwsEc2InstanceVpcId[resourceAwsEc2InstanceVpcIdIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceVpcId", std::move(resourceAwsEc2InstanceVpcIdJsonList));
}
if(m_resourceAwsEc2InstanceSubnetIdHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceSubnetIdJsonList(m_resourceAwsEc2InstanceSubnetId.size());
for(unsigned resourceAwsEc2InstanceSubnetIdIndex = 0; resourceAwsEc2InstanceSubnetIdIndex < resourceAwsEc2InstanceSubnetIdJsonList.GetLength(); ++resourceAwsEc2InstanceSubnetIdIndex)
{
resourceAwsEc2InstanceSubnetIdJsonList[resourceAwsEc2InstanceSubnetIdIndex].AsObject(m_resourceAwsEc2InstanceSubnetId[resourceAwsEc2InstanceSubnetIdIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceSubnetId", std::move(resourceAwsEc2InstanceSubnetIdJsonList));
}
if(m_resourceAwsEc2InstanceLaunchedAtHasBeenSet)
{
Array<JsonValue> resourceAwsEc2InstanceLaunchedAtJsonList(m_resourceAwsEc2InstanceLaunchedAt.size());
for(unsigned resourceAwsEc2InstanceLaunchedAtIndex = 0; resourceAwsEc2InstanceLaunchedAtIndex < resourceAwsEc2InstanceLaunchedAtJsonList.GetLength(); ++resourceAwsEc2InstanceLaunchedAtIndex)
{
resourceAwsEc2InstanceLaunchedAtJsonList[resourceAwsEc2InstanceLaunchedAtIndex].AsObject(m_resourceAwsEc2InstanceLaunchedAt[resourceAwsEc2InstanceLaunchedAtIndex].Jsonize());
}
payload.WithArray("ResourceAwsEc2InstanceLaunchedAt", std::move(resourceAwsEc2InstanceLaunchedAtJsonList));
}
if(m_resourceAwsS3BucketOwnerIdHasBeenSet)
{
Array<JsonValue> resourceAwsS3BucketOwnerIdJsonList(m_resourceAwsS3BucketOwnerId.size());
for(unsigned resourceAwsS3BucketOwnerIdIndex = 0; resourceAwsS3BucketOwnerIdIndex < resourceAwsS3BucketOwnerIdJsonList.GetLength(); ++resourceAwsS3BucketOwnerIdIndex)
{
resourceAwsS3BucketOwnerIdJsonList[resourceAwsS3BucketOwnerIdIndex].AsObject(m_resourceAwsS3BucketOwnerId[resourceAwsS3BucketOwnerIdIndex].Jsonize());
}
payload.WithArray("ResourceAwsS3BucketOwnerId", std::move(resourceAwsS3BucketOwnerIdJsonList));
}
if(m_resourceAwsS3BucketOwnerNameHasBeenSet)
{
Array<JsonValue> resourceAwsS3BucketOwnerNameJsonList(m_resourceAwsS3BucketOwnerName.size());
for(unsigned resourceAwsS3BucketOwnerNameIndex = 0; resourceAwsS3BucketOwnerNameIndex < resourceAwsS3BucketOwnerNameJsonList.GetLength(); ++resourceAwsS3BucketOwnerNameIndex)
{
resourceAwsS3BucketOwnerNameJsonList[resourceAwsS3BucketOwnerNameIndex].AsObject(m_resourceAwsS3BucketOwnerName[resourceAwsS3BucketOwnerNameIndex].Jsonize());
}
payload.WithArray("ResourceAwsS3BucketOwnerName", std::move(resourceAwsS3BucketOwnerNameJsonList));
}
if(m_resourceAwsIamAccessKeyPrincipalNameHasBeenSet)
{
Array<JsonValue> resourceAwsIamAccessKeyPrincipalNameJsonList(m_resourceAwsIamAccessKeyPrincipalName.size());
for(unsigned resourceAwsIamAccessKeyPrincipalNameIndex = 0; resourceAwsIamAccessKeyPrincipalNameIndex < resourceAwsIamAccessKeyPrincipalNameJsonList.GetLength(); ++resourceAwsIamAccessKeyPrincipalNameIndex)
{
resourceAwsIamAccessKeyPrincipalNameJsonList[resourceAwsIamAccessKeyPrincipalNameIndex].AsObject(m_resourceAwsIamAccessKeyPrincipalName[resourceAwsIamAccessKeyPrincipalNameIndex].Jsonize());
}
payload.WithArray("ResourceAwsIamAccessKeyPrincipalName", std::move(resourceAwsIamAccessKeyPrincipalNameJsonList));
}
if(m_resourceAwsIamAccessKeyStatusHasBeenSet)
{
Array<JsonValue> resourceAwsIamAccessKeyStatusJsonList(m_resourceAwsIamAccessKeyStatus.size());
for(unsigned resourceAwsIamAccessKeyStatusIndex = 0; resourceAwsIamAccessKeyStatusIndex < resourceAwsIamAccessKeyStatusJsonList.GetLength(); ++resourceAwsIamAccessKeyStatusIndex)
{
resourceAwsIamAccessKeyStatusJsonList[resourceAwsIamAccessKeyStatusIndex].AsObject(m_resourceAwsIamAccessKeyStatus[resourceAwsIamAccessKeyStatusIndex].Jsonize());
}
payload.WithArray("ResourceAwsIamAccessKeyStatus", std::move(resourceAwsIamAccessKeyStatusJsonList));
}
if(m_resourceAwsIamAccessKeyCreatedAtHasBeenSet)
{
Array<JsonValue> resourceAwsIamAccessKeyCreatedAtJsonList(m_resourceAwsIamAccessKeyCreatedAt.size());
for(unsigned resourceAwsIamAccessKeyCreatedAtIndex = 0; resourceAwsIamAccessKeyCreatedAtIndex < resourceAwsIamAccessKeyCreatedAtJsonList.GetLength(); ++resourceAwsIamAccessKeyCreatedAtIndex)
{
resourceAwsIamAccessKeyCreatedAtJsonList[resourceAwsIamAccessKeyCreatedAtIndex].AsObject(m_resourceAwsIamAccessKeyCreatedAt[resourceAwsIamAccessKeyCreatedAtIndex].Jsonize());
}
payload.WithArray("ResourceAwsIamAccessKeyCreatedAt", std::move(resourceAwsIamAccessKeyCreatedAtJsonList));
}
if(m_resourceAwsIamUserUserNameHasBeenSet)
{
Array<JsonValue> resourceAwsIamUserUserNameJsonList(m_resourceAwsIamUserUserName.size());
for(unsigned resourceAwsIamUserUserNameIndex = 0; resourceAwsIamUserUserNameIndex < resourceAwsIamUserUserNameJsonList.GetLength(); ++resourceAwsIamUserUserNameIndex)
{
resourceAwsIamUserUserNameJsonList[resourceAwsIamUserUserNameIndex].AsObject(m_resourceAwsIamUserUserName[resourceAwsIamUserUserNameIndex].Jsonize());
}
payload.WithArray("ResourceAwsIamUserUserName", std::move(resourceAwsIamUserUserNameJsonList));
}
if(m_resourceContainerNameHasBeenSet)
{
Array<JsonValue> resourceContainerNameJsonList(m_resourceContainerName.size());
for(unsigned resourceContainerNameIndex = 0; resourceContainerNameIndex < resourceContainerNameJsonList.GetLength(); ++resourceContainerNameIndex)
{
resourceContainerNameJsonList[resourceContainerNameIndex].AsObject(m_resourceContainerName[resourceContainerNameIndex].Jsonize());
}
payload.WithArray("ResourceContainerName", std::move(resourceContainerNameJsonList));
}
if(m_resourceContainerImageIdHasBeenSet)
{
Array<JsonValue> resourceContainerImageIdJsonList(m_resourceContainerImageId.size());
for(unsigned resourceContainerImageIdIndex = 0; resourceContainerImageIdIndex < resourceContainerImageIdJsonList.GetLength(); ++resourceContainerImageIdIndex)
{
resourceContainerImageIdJsonList[resourceContainerImageIdIndex].AsObject(m_resourceContainerImageId[resourceContainerImageIdIndex].Jsonize());
}
payload.WithArray("ResourceContainerImageId", std::move(resourceContainerImageIdJsonList));
}
if(m_resourceContainerImageNameHasBeenSet)
{
Array<JsonValue> resourceContainerImageNameJsonList(m_resourceContainerImageName.size());
for(unsigned resourceContainerImageNameIndex = 0; resourceContainerImageNameIndex < resourceContainerImageNameJsonList.GetLength(); ++resourceContainerImageNameIndex)
{
resourceContainerImageNameJsonList[resourceContainerImageNameIndex].AsObject(m_resourceContainerImageName[resourceContainerImageNameIndex].Jsonize());
}
payload.WithArray("ResourceContainerImageName", std::move(resourceContainerImageNameJsonList));
}
if(m_resourceContainerLaunchedAtHasBeenSet)
{
Array<JsonValue> resourceContainerLaunchedAtJsonList(m_resourceContainerLaunchedAt.size());
for(unsigned resourceContainerLaunchedAtIndex = 0; resourceContainerLaunchedAtIndex < resourceContainerLaunchedAtJsonList.GetLength(); ++resourceContainerLaunchedAtIndex)
{
resourceContainerLaunchedAtJsonList[resourceContainerLaunchedAtIndex].AsObject(m_resourceContainerLaunchedAt[resourceContainerLaunchedAtIndex].Jsonize());
}
payload.WithArray("ResourceContainerLaunchedAt", std::move(resourceContainerLaunchedAtJsonList));
}
if(m_resourceDetailsOtherHasBeenSet)
{
Array<JsonValue> resourceDetailsOtherJsonList(m_resourceDetailsOther.size());
for(unsigned resourceDetailsOtherIndex = 0; resourceDetailsOtherIndex < resourceDetailsOtherJsonList.GetLength(); ++resourceDetailsOtherIndex)
{
resourceDetailsOtherJsonList[resourceDetailsOtherIndex].AsObject(m_resourceDetailsOther[resourceDetailsOtherIndex].Jsonize());
}
payload.WithArray("ResourceDetailsOther", std::move(resourceDetailsOtherJsonList));
}
if(m_complianceStatusHasBeenSet)
{
Array<JsonValue> complianceStatusJsonList(m_complianceStatus.size());
for(unsigned complianceStatusIndex = 0; complianceStatusIndex < complianceStatusJsonList.GetLength(); ++complianceStatusIndex)
{
complianceStatusJsonList[complianceStatusIndex].AsObject(m_complianceStatus[complianceStatusIndex].Jsonize());
}
payload.WithArray("ComplianceStatus", std::move(complianceStatusJsonList));
}
if(m_verificationStateHasBeenSet)
{
Array<JsonValue> verificationStateJsonList(m_verificationState.size());
for(unsigned verificationStateIndex = 0; verificationStateIndex < verificationStateJsonList.GetLength(); ++verificationStateIndex)
{
verificationStateJsonList[verificationStateIndex].AsObject(m_verificationState[verificationStateIndex].Jsonize());
}
payload.WithArray("VerificationState", std::move(verificationStateJsonList));
}
if(m_workflowStateHasBeenSet)
{
Array<JsonValue> workflowStateJsonList(m_workflowState.size());
for(unsigned workflowStateIndex = 0; workflowStateIndex < workflowStateJsonList.GetLength(); ++workflowStateIndex)
{
workflowStateJsonList[workflowStateIndex].AsObject(m_workflowState[workflowStateIndex].Jsonize());
}
payload.WithArray("WorkflowState", std::move(workflowStateJsonList));
}
if(m_workflowStatusHasBeenSet)
{
Array<JsonValue> workflowStatusJsonList(m_workflowStatus.size());
for(unsigned workflowStatusIndex = 0; workflowStatusIndex < workflowStatusJsonList.GetLength(); ++workflowStatusIndex)
{
workflowStatusJsonList[workflowStatusIndex].AsObject(m_workflowStatus[workflowStatusIndex].Jsonize());
}
payload.WithArray("WorkflowStatus", std::move(workflowStatusJsonList));
}
if(m_recordStateHasBeenSet)
{
Array<JsonValue> recordStateJsonList(m_recordState.size());
for(unsigned recordStateIndex = 0; recordStateIndex < recordStateJsonList.GetLength(); ++recordStateIndex)
{
recordStateJsonList[recordStateIndex].AsObject(m_recordState[recordStateIndex].Jsonize());
}
payload.WithArray("RecordState", std::move(recordStateJsonList));
}
if(m_relatedFindingsProductArnHasBeenSet)
{
Array<JsonValue> relatedFindingsProductArnJsonList(m_relatedFindingsProductArn.size());
for(unsigned relatedFindingsProductArnIndex = 0; relatedFindingsProductArnIndex < relatedFindingsProductArnJsonList.GetLength(); ++relatedFindingsProductArnIndex)
{
relatedFindingsProductArnJsonList[relatedFindingsProductArnIndex].AsObject(m_relatedFindingsProductArn[relatedFindingsProductArnIndex].Jsonize());
}
payload.WithArray("RelatedFindingsProductArn", std::move(relatedFindingsProductArnJsonList));
}
if(m_relatedFindingsIdHasBeenSet)
{
Array<JsonValue> relatedFindingsIdJsonList(m_relatedFindingsId.size());
for(unsigned relatedFindingsIdIndex = 0; relatedFindingsIdIndex < relatedFindingsIdJsonList.GetLength(); ++relatedFindingsIdIndex)
{
relatedFindingsIdJsonList[relatedFindingsIdIndex].AsObject(m_relatedFindingsId[relatedFindingsIdIndex].Jsonize());
}
payload.WithArray("RelatedFindingsId", std::move(relatedFindingsIdJsonList));
}
if(m_noteTextHasBeenSet)
{
Array<JsonValue> noteTextJsonList(m_noteText.size());
for(unsigned noteTextIndex = 0; noteTextIndex < noteTextJsonList.GetLength(); ++noteTextIndex)
{
noteTextJsonList[noteTextIndex].AsObject(m_noteText[noteTextIndex].Jsonize());
}
payload.WithArray("NoteText", std::move(noteTextJsonList));
}
if(m_noteUpdatedAtHasBeenSet)
{
Array<JsonValue> noteUpdatedAtJsonList(m_noteUpdatedAt.size());
for(unsigned noteUpdatedAtIndex = 0; noteUpdatedAtIndex < noteUpdatedAtJsonList.GetLength(); ++noteUpdatedAtIndex)
{
noteUpdatedAtJsonList[noteUpdatedAtIndex].AsObject(m_noteUpdatedAt[noteUpdatedAtIndex].Jsonize());
}
payload.WithArray("NoteUpdatedAt", std::move(noteUpdatedAtJsonList));
}
if(m_noteUpdatedByHasBeenSet)
{
Array<JsonValue> noteUpdatedByJsonList(m_noteUpdatedBy.size());
for(unsigned noteUpdatedByIndex = 0; noteUpdatedByIndex < noteUpdatedByJsonList.GetLength(); ++noteUpdatedByIndex)
{
noteUpdatedByJsonList[noteUpdatedByIndex].AsObject(m_noteUpdatedBy[noteUpdatedByIndex].Jsonize());
}
payload.WithArray("NoteUpdatedBy", std::move(noteUpdatedByJsonList));
}
if(m_findingProviderFieldsConfidenceHasBeenSet)
{
Array<JsonValue> findingProviderFieldsConfidenceJsonList(m_findingProviderFieldsConfidence.size());
for(unsigned findingProviderFieldsConfidenceIndex = 0; findingProviderFieldsConfidenceIndex < findingProviderFieldsConfidenceJsonList.GetLength(); ++findingProviderFieldsConfidenceIndex)
{
findingProviderFieldsConfidenceJsonList[findingProviderFieldsConfidenceIndex].AsObject(m_findingProviderFieldsConfidence[findingProviderFieldsConfidenceIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsConfidence", std::move(findingProviderFieldsConfidenceJsonList));
}
if(m_findingProviderFieldsCriticalityHasBeenSet)
{
Array<JsonValue> findingProviderFieldsCriticalityJsonList(m_findingProviderFieldsCriticality.size());
for(unsigned findingProviderFieldsCriticalityIndex = 0; findingProviderFieldsCriticalityIndex < findingProviderFieldsCriticalityJsonList.GetLength(); ++findingProviderFieldsCriticalityIndex)
{
findingProviderFieldsCriticalityJsonList[findingProviderFieldsCriticalityIndex].AsObject(m_findingProviderFieldsCriticality[findingProviderFieldsCriticalityIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsCriticality", std::move(findingProviderFieldsCriticalityJsonList));
}
if(m_findingProviderFieldsRelatedFindingsIdHasBeenSet)
{
Array<JsonValue> findingProviderFieldsRelatedFindingsIdJsonList(m_findingProviderFieldsRelatedFindingsId.size());
for(unsigned findingProviderFieldsRelatedFindingsIdIndex = 0; findingProviderFieldsRelatedFindingsIdIndex < findingProviderFieldsRelatedFindingsIdJsonList.GetLength(); ++findingProviderFieldsRelatedFindingsIdIndex)
{
findingProviderFieldsRelatedFindingsIdJsonList[findingProviderFieldsRelatedFindingsIdIndex].AsObject(m_findingProviderFieldsRelatedFindingsId[findingProviderFieldsRelatedFindingsIdIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsRelatedFindingsId", std::move(findingProviderFieldsRelatedFindingsIdJsonList));
}
if(m_findingProviderFieldsRelatedFindingsProductArnHasBeenSet)
{
Array<JsonValue> findingProviderFieldsRelatedFindingsProductArnJsonList(m_findingProviderFieldsRelatedFindingsProductArn.size());
for(unsigned findingProviderFieldsRelatedFindingsProductArnIndex = 0; findingProviderFieldsRelatedFindingsProductArnIndex < findingProviderFieldsRelatedFindingsProductArnJsonList.GetLength(); ++findingProviderFieldsRelatedFindingsProductArnIndex)
{
findingProviderFieldsRelatedFindingsProductArnJsonList[findingProviderFieldsRelatedFindingsProductArnIndex].AsObject(m_findingProviderFieldsRelatedFindingsProductArn[findingProviderFieldsRelatedFindingsProductArnIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsRelatedFindingsProductArn", std::move(findingProviderFieldsRelatedFindingsProductArnJsonList));
}
if(m_findingProviderFieldsSeverityLabelHasBeenSet)
{
Array<JsonValue> findingProviderFieldsSeverityLabelJsonList(m_findingProviderFieldsSeverityLabel.size());
for(unsigned findingProviderFieldsSeverityLabelIndex = 0; findingProviderFieldsSeverityLabelIndex < findingProviderFieldsSeverityLabelJsonList.GetLength(); ++findingProviderFieldsSeverityLabelIndex)
{
findingProviderFieldsSeverityLabelJsonList[findingProviderFieldsSeverityLabelIndex].AsObject(m_findingProviderFieldsSeverityLabel[findingProviderFieldsSeverityLabelIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsSeverityLabel", std::move(findingProviderFieldsSeverityLabelJsonList));
}
if(m_findingProviderFieldsSeverityOriginalHasBeenSet)
{
Array<JsonValue> findingProviderFieldsSeverityOriginalJsonList(m_findingProviderFieldsSeverityOriginal.size());
for(unsigned findingProviderFieldsSeverityOriginalIndex = 0; findingProviderFieldsSeverityOriginalIndex < findingProviderFieldsSeverityOriginalJsonList.GetLength(); ++findingProviderFieldsSeverityOriginalIndex)
{
findingProviderFieldsSeverityOriginalJsonList[findingProviderFieldsSeverityOriginalIndex].AsObject(m_findingProviderFieldsSeverityOriginal[findingProviderFieldsSeverityOriginalIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsSeverityOriginal", std::move(findingProviderFieldsSeverityOriginalJsonList));
}
if(m_findingProviderFieldsTypesHasBeenSet)
{
Array<JsonValue> findingProviderFieldsTypesJsonList(m_findingProviderFieldsTypes.size());
for(unsigned findingProviderFieldsTypesIndex = 0; findingProviderFieldsTypesIndex < findingProviderFieldsTypesJsonList.GetLength(); ++findingProviderFieldsTypesIndex)
{
findingProviderFieldsTypesJsonList[findingProviderFieldsTypesIndex].AsObject(m_findingProviderFieldsTypes[findingProviderFieldsTypesIndex].Jsonize());
}
payload.WithArray("FindingProviderFieldsTypes", std::move(findingProviderFieldsTypesJsonList));
}
if(m_sampleHasBeenSet)
{
Array<JsonValue> sampleJsonList(m_sample.size());
for(unsigned sampleIndex = 0; sampleIndex < sampleJsonList.GetLength(); ++sampleIndex)
{
sampleJsonList[sampleIndex].AsObject(m_sample[sampleIndex].Jsonize());
}
payload.WithArray("Sample", std::move(sampleJsonList));
}
return payload;
}