types.ts

export interface AsffFile {
    Findings: Finding[];
}

export interface Finding {
    Action:                FindingAction;
    AwsAccountId:          string;
    AwsAccountName:        string;
    CompanyName:           string;
    Compliance:            Compliance;
    Confidence:            string;
    CreatedAt:             string;
    Criticality:           string;
    Description:           string;
    Detection:             FindingDetection;
    FindingProviderFields: FindingProviderFields;
    FirstObservedAt:       string;
    GeneratorId:           string;
    Id:                    string;
    LastObservedAt:        string;
    Malware:               Malware[];
    Network:               Network;
    NetworkPath:           NetworkPath[];
    Note:                  Note;
    PatchSummary:          PatchSummary;
    Process:               Process;
    ProductArn:            string;
    ProductFields:         ProductFields;
    ProductName:           string;
    RecordState:           string;
    Region:                string;
    RelatedFindings:       RelatedFinding[];
    Remediation:           Remediation;
    Resources:             Resource[];
    SchemaVersion:         string;
    Severity:              Severity;
    Sample:                string;
    SourceUrl:             string;
    Threats:               Threat[];
    ThreatIntelIndicators: ThreatIntelIndicator[];
    Title:                 string;
    Types:                 string[];
    UpdatedAt:             string;
    UserDefinedFields:     ProductFields;
    VerificationState:     string;
    Vulnerabilities:       Vulnerability[];
    Workflow:              Workflow;
    WorkflowState:         string;
}

export interface FindingAction {
    ActionType:              string;
    AwsApiCallAction:        AwsAPICallAction;
    DnsRequestAction:        DNSRequestAction;
    NetworkConnectionAction: NetworkConnectionAction;
    PortProbeAction:         PortProbeAction;
}

export interface AwsAPICallAction {
    AffectedResources: ProductFields;
    Api:               string;
    CallerType:        string;
    DomainDetails:     DomainDetails;
    FirstSeen:         string;
    LastSeen:          string;
    RemoteIpDetails:   RemoteIPDetails;
    ServiceName:       string;
}

export interface ProductFields {
    string: string;
}

export interface DomainDetails {
    Domain: string;
}

export interface RemoteIPDetails {
    City:         City;
    Country:      Country;
    IpAddressV4:  string;
    Geolocation?: Geolocation;
    Organization: Organization;
    GeoLocation?: Geolocation;
}

export interface City {
    CityName: string;
}

export interface Country {
    CountryCode: string;
    CountryName: string;
}

export interface Geolocation {
    Lat: string;
    Lon: string;
}

export interface Organization {
    Asn:    string;
    AsnOrg: string;
    Isp:    string;
    Org:    string;
}

export interface DNSRequestAction {
    Blocked:  string;
    Domain:   string;
    Protocol: string;
}

export interface NetworkConnectionAction {
    Blocked:             string;
    ConnectionDirection: string;
    LocalPortDetails:    PortDetails;
    Protocol:            string;
    RemoteIpDetails:     RemoteIPDetails;
    RemotePortDetails:   PortDetails;
}

export interface PortDetails {
    Port:     string;
    PortName: string;
}

export interface PortProbeAction {
    Blocked:          string;
    PortProbeDetails: PortProbeDetail[];
}

export interface PortProbeDetail {
    LocalIpDetails:   LocalIPDetails;
    LocalPortDetails: PortDetails;
    RemoteIpDetails:  RemoteIPDetails;
}

export interface LocalIPDetails {
    IpAddressV4: string;
}

export interface Compliance {
    AssociatedStandards:       AssociatedStandard[];
    RelatedRequirements:       string[];
    SecurityControlId:         string;
    SecurityControlParameters: SecurityControlParameter[];
    Status:                    string;
    StatusReasons:             StatusReason[];
}

export interface AssociatedStandard {
    StandardsId: string;
}

export interface SecurityControlParameter {
    Name:  string;
    Value: string[];
}

export interface StatusReason {
    Description: string;
    ReasonCode:  string;
}

export interface FindingDetection {
    Sequence: Sequence;
}

export interface Sequence {
    Uid:                string;
    Actors:             Actor[];
    Endpoints:          EndpointElement[];
    Signals:            Signal[];
    SequenceIndicators: Indicator[];
}

export interface Actor {
    Id:      string;
    Session: Session;
    User:    ActorUser;
}

export interface Session {
    Uid:         string;
    MfAStatus:   string;
    CreatedTime: string;
    Issuer:      string;
}

export interface ActorUser {
    CredentialUid: string;
    Name:          string;
    Type:          string;
    Uid:           string;
    Account:       Account;
}

export interface Account {
    Uid:  string;
    Name: string;
}

export interface EndpointElement {
    Id:               string;
    Ip:               string;
    Domain:           string;
    Port:             string;
    Location:         Location;
    AutonomousSystem: AutonomousSystem;
    Connection:       Connection;
}

export interface AutonomousSystem {
    Name:   string;
    Number: string;
}

export interface Connection {
    Direction: string;
}

export interface Location {
    City:    string;
    Country: string;
    Lat:     string;
    Lon:     string;
}

export interface Indicator {
    Key:    string;
    Title:  string;
    Values: string[];
}

export interface Signal {
    Id:               string;
    Title:            string;
    ActorIds:         string[];
    Count:            string;
    FirstSeenAt:      string;
    SignalIndicators: Indicator[];
    LastSeenAt:       string;
    Name:             string;
    ResourceIds:      string[];
    Type:             string;
}

export interface FindingProviderFields {
    Confidence:      string;
    Criticality:     string;
    RelatedFindings: RelatedFinding[];
    Severity:        Severity;
    Types:           string[];
}

export interface RelatedFinding {
    ProductArn: string;
    Id:         string;
}

export interface Severity {
    Label:      string;
    Normalized: string;
    Original:   string;
}

export interface Malware {
    Name:  string;
    Path:  string;
    State: string;
    Type:  string;
}

export interface Network {
    DestinationDomain: string;
    DestinationIpV4:   string;
    DestinationIpV6:   string;
    DestinationPort:   string;
    Direction:         string;
    OpenPortRange:     PortRange;
    Protocol:          string;
    SourceDomain:      string;
    SourceIpV4:        string;
    SourceIpV6:        string;
    SourceMac:         string;
    SourcePort:        string;
}

export interface PortRange {
    Begin: string;
    End:   string;
}

export interface NetworkPath {
    ComponentId:   string;
    ComponentType: string;
    Egress:        Gress;
    Ingress:       Gress;
}

export interface Gress {
    Destination: EgressDestination;
    Protocol:    string;
    Source:      EgressDestination;
}

export interface EgressDestination {
    Address:    string[];
    PortRanges: PortRange[];
}

export interface Note {
    Text:      string;
    UpdatedAt: string;
    UpdatedBy: string;
}

export interface PatchSummary {
    FailedCount:            string;
    Id:                     string;
    InstalledCount:         string;
    InstalledOtherCount:    string;
    InstalledPendingReboot: string;
    InstalledRejectedCount: string;
    MissingCount:           string;
    Operation:              string;
    OperationEndTime:       string;
    OperationStartTime:     string;
    RebootOption:           string;
}

export interface Process {
    LaunchedAt:   string;
    Name:         string;
    ParentPid:    string;
    Path:         string;
    Pid:          string;
    TerminatedAt: string;
}

export interface Remediation {
    Recommendation: Recommendation;
}

export interface Recommendation {
    Text: string;
    Url:  string;
}


export interface Resource {
    ApplicationArn:                   string;
    ApplicationName:                  string;
    DataClassification:               DataClassification;
    Details:                          Details;
    AwsBackupBackupPlan:              AwsBackupBackupPlan;
    AwsBackupBackupVault:             AwsBackupBackupVault;
    AwsBackupRecoveryPoint:           AwsBackupRecoveryPoint;
    AwsCertificateManagerCertificate: AwsCertificateManagerCertificate;
    AwsCloudFormationStack:           AwsCloudFormationStack;
    AwsCloudFrontDistribution:        AwsCloudFrontDistribution;
    AwsCloudTrailTrail:               AwsCloudTrailTrail;
    AwsCloudWatchAlarm:               AwsCloudWatchAlarm;
    AwsCodeBuildProject:              AwsCodeBuildProject;
    AwsDmsEndpoint:                   AwsDmsEndpoint;
    AwsDmsReplicationInstance:        AwsDmsReplicationInstance;
    AwsDmsReplicationTask:            AwsDmsReplicationTask;
    AwsDynamoDbTable:                 AwsDynamoDBTable;
    AwsEc2ClientVpnEndpoint:          AwsEc2ClientVPNEndpoint;
    AwsEc2Eip:                        AwsEc2Eip;
    AwsEc2Instance:                   AwsEc2Instance;
    AwsEc2LaunchTemplate:             AwsEc2LaunchTemplate;
    AwsEc2NetworkAcl:                 AwsEc2NetworkACL;
    AwsEc2NetworkInterface:           AwsEc2NetworkInterface;
    AwsEc2RouteTable:                 AwsEc2RouteTable;
    AwsEc2SecurityGroup:              AwsEc2SecurityGroup;
    AwsEc2Subnet:                     AwsEc2Subnet;
    AwsEc2TransitGateway:             AwsEc2TransitGateway;
    AwsEc2Volume:                     AwsEc2Volume;
    AwsEc2Vpc:                        AwsEc2Vpc;
    AwsEc2VpcEndpointService:         AwsEc2VpcEndpointService;
    AwsEc2VpcPeeringConnection:       AwsEc2VpcPeeringConnection;
    AwsEcrContainerImage:             AwsEcrContainerImage;
    AwsEcrRepository:                 AwsEcrRepository;
    AwsEcsCluster:                    AwsEcsCluster;
    AwsEcsContainer:                  Container;
    AwsEcsService:                    AwsEcsService;
    AwsEcsTask:                       AwsEcsTask;
    AwsEcsTaskDefinition:             AwsEcsTaskDefinition;
    AwsEfsAccessPoint:                AwsEFSAccessPoint;
    AwsEksCluster:                    AwsEksCluster;
    AwsElasticBeanstalkEnvironment:   AwsElasticBeanstalkEnvironment;
    AwsElasticSearchDomain:           AwsElasticSearchDomain;
    AwsElbLoadBalancer:               AwsElbLoadBalancer;
    AwsElbv2LoadBalancer:             AwsElbv2LoadBalancer;
    AwsEventSchemasRegistry:          AwsEventSchemasRegistry;
    AwsEventsEndpoint:                AwsEventsEndpoint;
    AwsEventsEventBus:                AwsEventsEventBus;
    AwsGuardDutyDetector:             AwsGuardDutyDetector;
    AwsIamAccessKey:                  AwsIamAccessKey;
    AwsIamGroup:                      AwsIamGroup;
    AwsIamPolicy:                     AwsIamPolicy;
    AwsIamRole:                       AwsIamRole;
    AwsIamUser:                       AwsIamUser;
    AwsKinesisStream:                 AwsKinesisStream;
    AwsKmsKey:                        AwsKmsKey;
    AwsLambdaFunction:                AwsLambdaFunction;
    AwsLambdaLayerVersion:            AwsLambdaLayerVersion;
    AwsMskCluster:                    AwsMskCluster;
    AwsNetworkFirewallFirewall:       AwsNetworkFirewallFirewall;
    AwsNetworkFirewallFirewallPolicy: AwsNetworkFirewallFirewallPolicy;
    AwsNetworkFirewallRuleGroup:      AwsNetworkFirewallRuleGroup;
    AwsOpenSearchServiceDomain:       AwsOpenSearchServiceDomain;
    AwsRdsDbCluster:                  AwsRDSDBCluster;
    AwsRdsDbClusterSnapshot:          AwsRDSDBClusterSnapshot;
    AwsRdsDbInstance:                 AwsRDSDBInstance;
    AwsRdsDbSecurityGroup:            AwsRDSDBSecurityGroup;
    AwsRdsDbSnapshot:                 AwsRDSDBSnapshot;
    AwsRdsEventSubscription:          AwsRDSEventSubscription;
    AwsRedshiftCluster:               AwsRedshiftCluster;
    AwsRoute53HostedZone:             AwsRoute53HostedZone;
    AwsS3AccessPoint:                 AwsS3AccessPoint;
    AwsS3AccountPublicAccessBlock:    AwsS3AccountPublicAccessBlock;
    AwsS3Bucket:                      AwsS3Bucket;
    AwsS3Object:                      AwsS3Object;
    AwsSagemakerNotebookInstance:     AwsSagemakerNotebookInstance;
    AwsSecretsManagerSecret:          AwsSecretsManagerSecret;
    AwsSnsTopic:                      AwsSnsTopic;
    AwsSqsQueue:                      AwsSqsQueue;
    AwsSsmPatchCompliance:            AwsSsmPatchCompliance;
    AwsStepFunctionStateMachine:      AwsStepFunctionStateMachine;
    AwsWafRateBasedRule:              AwsWafRRateBasedRule;
    AwsWafRegionalRateBasedRule:      AwsWafRRateBasedRule;
    AwsWafRegionalRule:               AwsWafRRule;
    AwsWafRegionalRuleGroup:          AwsWafRRuleGroup;
    AwsWafRegionalWebAcl:             AwsWafRegionalWebACL;
    AwsWafRule:                       AwsWafRRule;
    AwsWafRuleGroup:                  AwsWafRRuleGroup;
    AwsWafv2RuleGroup:                AwsWafv2RuleGroup;
    AwsWafWebAcl:                     AwsWafWebACL;
    AwsWafv2WebAcl:                   AwsWafv2WebACL;
    AwsXrayEncryptionConfig:          AwsXrayEncryptionConfig;
    Container:                        PurpleContainer;
    Other:                            ProductFields;
    Id:                               string;
    Partition:                        string;
    Region:                           string;
    ResourceRole:                     string;
    Tags:                             ProductFields;
    Type:                             string;
}

export interface AwsBackupBackupPlan {
    BackupPlan:    BackupPlan;
    BackupPlanArn: string;
    BackupPlanId:  string;
    VersionId:     string;
}

export interface BackupPlan {
    AdvancedBackupSettings: AdvancedBackupSetting[];
    BackupPlanName:         string;
    BackupPlanRule:         BackupPlanRule[];
}

export interface AdvancedBackupSetting {
    BackupOptions: BackupOptions;
    ResourceType:  string;
}

export interface BackupOptions {
    WindowsVSS: string;
}

export interface BackupPlanRule {
    CompletionWindowMinutes: string;
    CopyActions:             CopyAction[];
    Lifecycle:               BackupPlanRuleLifecycle;
    RuleName:                string;
    ScheduleExpression:      string;
    StartWindowMinutes:      string;
    TargetBackupVault:       string;
}

export interface CopyAction {
    DestinationBackupVaultArn: string;
    Lifecycle:                 CopyActionLifecycle;
}

export interface CopyActionLifecycle {
    DeleteAfterDays:            string;
    MoveToColdStorageAfterDays: string;
}

export interface BackupPlanRuleLifecycle {
    DeleteAfterDays: string;
}

export interface AwsBackupBackupVault {
    AccessPolicy:     AccessPolicy;
    BackupVaultArn:   string;
    BackupVaultName:  string;
    EncryptionKeyArn: string;
    Notifications:    Notifications;
}

export interface AccessPolicy {
    Statement: Statement[];
    Version:   string;
}

export interface Statement {
    Action:    string[];
    Effect:    string;
    Principal: Principal;
    Resource:  string;
}

export interface Principal {
    AWS: string;
}

export interface Notifications {
    BackupVaultEvents: string[];
    SNSTopicArn:       string;
}

export interface AwsBackupRecoveryPoint {
    BackupSizeInBytes:    string;
    BackupVaultName:      string;
    BackupVaultArn:       string;
    CalculatedLifecycle:  CalculatedLifecycle;
    CompletionDate:       string;
    CreatedBy:            CreatedBy;
    CreationDate:         string;
    EncryptionKeyArn:     string;
    IamRoleArn:           string;
    IsEncrypted:          string;
    LastRestoreTime:      string;
    Lifecycle:            CopyActionLifecycle;
    RecoveryPointArn:     string;
    ResourceArn:          string;
    ResourceType:         string;
    SourceBackupVaultArn: string;
    Status:               string;
    StatusMessage:        string;
    StorageClass:         string;
}

export interface CalculatedLifecycle {
    DeleteAt:            string;
    MoveToColdStorageAt: string;
}

export interface CreatedBy {
    BackupPlanArn:     string;
    BackupPlanId:      string;
    BackupPlanVersion: string;
    BackupRuleId:      string;
}

export interface AwsCertificateManagerCertificate {
    CertificateAuthorityArn: string;
    CreatedAt:               string;
    DomainName:              string;
    DomainValidationOptions: DomainValidationOption[];
    ExtendedKeyUsages:       ExtendedKeyUsage[];
    FailureReason:           string;
    ImportedAt:              string;
    InUseBy:                 string[];
    IssuedAt:                string;
    Issuer:                  string;
    KeyAlgorithm:            string;
    KeyUsages:               KeyUsage[];
    NotAfter:                string;
    NotBefore:               string;
    Options:                 Options;
    RenewalEligibility:      string;
    RenewalSummary:          RenewalSummary;
    Serial:                  string;
    SignatureAlgorithm:      string;
    Status:                  string;
    Subject:                 string;
    SubjectAlternativeNames: string[];
    Type:                    string;
}

export interface DomainValidationOption {
    DomainName:       string;
    ResourceRecord:   ResourceRecord;
    ValidationDomain: string;
    ValidationEmails: string[];
    ValidationMethod: string;
    ValidationStatus: string;
}

export interface ResourceRecord {
    Name:  string;
    Type:  string;
    Value: string;
}

export interface ExtendedKeyUsage {
    Name: string;
    OId:  string;
}

export interface KeyUsage {
    Name: string;
}

export interface Options {
    CertificateTransparencyLoggingPreference: string;
}

export interface RenewalSummary {
    DomainValidationOptions: DomainValidationOption[];
    RenewalStatus:           string;
    RenewalStatusReason:     string;
    UpdatedAt:               string;
}

export interface AwsCloudFormationStack {
    Capabilities:                string[];
    CreationTime:                string;
    Description:                 string;
    DisableRollback:             string;
    DriftInformation:            DriftInformation;
    EnableTerminationProtection: string;
    LastUpdatedTime:             string;
    NotificationArns:            string[];
    Outputs:                     Output[];
    RoleArn:                     string;
    StackId:                     string;
    StackName:                   string;
    StackStatus:                 string;
    StackStatusReason:           string;
    TimeoutInMinutes:            string;
}

export interface DriftInformation {
    StackDriftStatus: string;
}

export interface Output {
    Description: string;
    OutputKey:   string;
    OutputValue: string;
}

export interface AwsCloudFrontDistribution {
    CacheBehaviors:       CacheBehaviors;
    DefaultCacheBehavior: DefaultCacheBehavior;
    DefaultRootObject:    string;
    DomainName:           string;
    Etag:                 string;
    LastModifiedTime:     string;
    Logging:              AwsCloudFrontDistributionLogging;
    OriginGroups:         OriginGroups;
    Origins:              Origins;
    Status:               string;
    ViewerCertificate:    ViewerCertificate;
    WebAclId:             string;
}

export interface CacheBehaviors {
    Items: DefaultCacheBehavior[];
}

export interface DefaultCacheBehavior {
    ViewerProtocolPolicy: string;
}

export interface AwsCloudFrontDistributionLogging {
    Bucket:         string;
    Enabled:        string;
    IncludeCookies: string;
    Prefix:         string;
}

export interface OriginGroups {
    Items: OriginGroupsItem[];
}

export interface OriginGroupsItem {
    FailoverCriteria: FailoverCriteria;
}

export interface FailoverCriteria {
    StatusCodes: StatusCodes;
}

export interface StatusCodes {
    Items:    string[];
    Quantity: string;
}

export interface Origins {
    Items: OriginsItem[];
}

export interface OriginsItem {
    CustomOriginConfig: CustomOriginConfig;
    DomainName:         string;
    Id:                 string;
    OriginPath:         string;
    S3OriginConfig:     S3OriginConfig;
}

export interface CustomOriginConfig {
    HttpPort:               string;
    HttpsPort:              string;
    OriginKeepaliveTimeout: string;
    OriginProtocolPolicy:   string;
    OriginReadTimeout:      string;
    OriginSslProtocols:     StatusCodes;
}

export interface S3OriginConfig {
    OriginAccessIdentity: string;
}

export interface ViewerCertificate {
    AcmCertificateArn:            string;
    Certificate:                  string;
    CertificateSource:            string;
    CloudFrontDefaultCertificate: string;
    IamCertificateId:             string;
    MinimumProtocolVersion:       string;
    SslSupportMethod:             string;
}

export interface AwsCloudTrailTrail {
    CloudWatchLogsLogGroupArn:  string;
    CloudWatchLogsRoleArn:      string;
    HasCustomEventSelectors:    string;
    HomeRegion:                 string;
    IncludeGlobalServiceEvents: string;
    IsMultiRegionTrail:         string;
    IsOrganizationTrail:        string;
    KmsKeyId:                   string;
    LogFileValidationEnabled:   string;
    Name:                       string;
    S3BucketName:               string;
    S3KeyPrefix:                string;
    SnsTopicArn:                string;
    SnsTopicName:               string;
    TrailArn:                   string;
}

export interface AwsCloudWatchAlarm {
    ActionsEnabled:                     string;
    AlarmActions:                       string[];
    AlarmArn:                           string;
    AlarmConfigurationUpdatedTimestamp: string;
    AlarmDescription:                   string;
    AlarmName:                          string;
    ComparisonOperator:                 string;
    DatapointsToAlarm:                  string;
    Dimensions:                         Dimension[];
    EvaluateLowSampleCountPercentile:   string;
    EvaluationPeriods:                  string;
    ExtendedStatistic:                  string;
    InsufficientDataActions:            string[];
    MetricName:                         string;
    Namespace:                          string;
    OkActions:                          string[];
    Period:                             string;
    Statistic:                          string;
    Threshold:                          string;
    ThresholdMetricId:                  string;
    TreatMissingData:                   string;
    Unit:                               string;
}

export interface Dimension {
    Name:  string;
    Value: string;
}

export interface AwsCodeBuildProject {
    Artifacts:          Artifact[];
    SecondaryArtifacts: Artifact[];
    EncryptionKey:      string;
    Certificate:        string;
    Environment:        AwsCodeBuildProjectEnvironment;
    LogsConfig:         LogsConfig;
    Name:               string;
    ServiceRole:        string;
    Source:             Source;
    VpcConfig:          VpcConfig;
}

export interface Artifact {
    ArtifactIdentifier:   string;
    EncryptionDisabled:   string;
    Location:             string;
    Name:                 string;
    NamespaceType:        string;
    OverrideArtifactName: string;
    Packaging:            string;
    Path:                 string;
    Type:                 string;
}

export interface AwsCodeBuildProjectEnvironment {
    Certificate:              string;
    EnvironmentVariables:     ResourceRecord[];
    ImagePullCredentialsType: string;
    PrivilegedMode:           string;
    RegistryCredential:       RegistryCredential;
    Type:                     string;
}

export interface RegistryCredential {
    Credential:         string;
    CredentialProvider: string;
}

export interface LogsConfig {
    CloudWatchLogs: CloudWatchLogs;
    S3Logs:         S3Logs;
}

export interface CloudWatchLogs {
    GroupName:  string;
    Status:     string;
    StreamName: string;
}

export interface S3Logs {
    EncryptionDisabled: string;
    Location:           string;
    Status:             string;
}

export interface Source {
    Type:          string;
    Location:      string;
    GitCloneDepth: string;
}

export interface VpcConfig {
    VpcId:            string;
    Subnets:          string[];
    SecurityGroupIds: string[];
}

export interface AwsDmsEndpoint {
    CertificateArn:     string;
    DatabaseName:       string;
    EndpointArn:        string;
    EndpointIdentifier: string;
    EndpointType:       string;
    EngineName:         string;
    KmsKeyId:           string;
    Port:               string;
    ServerName:         string;
    SslMode:            string;
    Username:           string;
}

export interface AwsDmsReplicationInstance {
    AllocatedStorage:              string;
    AutoMinorVersionUpgrade:       string;
    AvailabilityZone:              string;
    EngineVersion:                 string;
    KmsKeyId:                      string;
    MultiAZ:                       string;
    PreferredMaintenanceWindow:    string;
    PubliclyAccessible:            string;
    ReplicationInstanceClass:      string;
    ReplicationInstanceIdentifier: string;
    ReplicationSubnetGroup:        ReplicationSubnetGroup;
    VpcSecurityGroups:             AwsDmsReplicationInstanceVpcSecurityGroup[];
}

export interface ReplicationSubnetGroup {
    ReplicationSubnetGroupIdentifier: string;
}

export interface AwsDmsReplicationInstanceVpcSecurityGroup {
    VpcSecurityGroupId: string;
}

export interface AwsDmsReplicationTask {
    CdcStartPosition:          string;
    Id:                        string;
    MigrationType:             string;
    ReplicationInstanceArn:    string;
    ReplicationTaskIdentifier: string;
    ReplicationTaskSettings:   ProductFields;
    SourceEndpointArn:         string;
    TableMappings:             ProductFields;
    TargetEndpointArn:         string;
}

export interface AwsDynamoDBTable {
    AttributeDefinitions:      AttributeDefinition[];
    BillingModeSummary:        BillingModeSummary;
    CreationDateTime:          string;
    DeletionProtectionEnabled: string;
    GlobalSecondaryIndexes:    AwsDynamoDBTableGlobalSecondaryIndex[];
    GlobalTableVersion:        string;
    ItemCount:                 string;
    KeySchema:                 KeySchema[];
    LatestStreamArn:           string;
    LatestStreamLabel:         string;
    LocalSecondaryIndexes:     LocalSecondaryIndex[];
    ProvisionedThroughput:     ProvisionedThroughput;
    Replicas:                  Replica[];
    RestoreSummary:            RestoreSummary;
    SseDescription:            SSEDescription;
    StreamSpecification:       StreamSpecification;
    TableId:                   string;
    TableName:                 string;
    TableSizeBytes:            string;
    TableStatus:               string;
}

export interface AttributeDefinition {
    AttributeName: string;
    AttributeType: string;
}

export interface BillingModeSummary {
    BillingMode:                       string;
    LastUpdateToPayPerRequestDateTime: string;
}

export interface AwsDynamoDBTableGlobalSecondaryIndex {
    Backfilling:           string;
    IndexArn:              string;
    IndexName:             string;
    IndexSizeBytes:        string;
    IndexStatus:           string;
    ItemCount:             string;
    KeySchema:             KeySchema[];
    Projection:            Projection;
    ProvisionedThroughput: ProvisionedThroughput;
}

export interface KeySchema {
    AttributeName: string;
    KeyType:       string;
}

export interface Projection {
    NonKeyAttributes: string[];
    ProjectionType:   string;
}

export interface ProvisionedThroughput {
    LastDecreaseDateTime:   string;
    LastIncreaseDateTime:   string;
    NumberOfDecreasesToday: string;
    ReadCapacityUnits:      string;
    WriteCapacityUnits:     string;
}

export interface LocalSecondaryIndex {
    IndexArn:   string;
    IndexName:  string;
    KeySchema:  KeySchema[];
    Projection: Projection;
}

export interface Replica {
    GlobalSecondaryIndexes:        ReplicaGlobalSecondaryIndex[];
    KmsMasterKeyId:                string;
    ProvisionedThroughputOverride: ProvisionedThroughputOverride;
    RegionName:                    string;
    ReplicaStatus:                 string;
    ReplicaStatusDescription:      string;
}

export interface ReplicaGlobalSecondaryIndex {
    IndexName:                     string;
    ProvisionedThroughputOverride: ProvisionedThroughputOverride;
}

export interface ProvisionedThroughputOverride {
    ReadCapacityUnits: string;
}

export interface RestoreSummary {
    RestoreDateTime:   string;
    RestoreInProgress: string;
    SourceBackupArn:   string;
    SourceTableArn:    string;
}

export interface SSEDescription {
    InaccessibleEncryptionDateTime: string;
    KmsMasterKeyArn:                string;
    SseType:                        string;
    Status:                         string;
}

export interface StreamSpecification {
    StreamEnabled:  string;
    StreamViewType: string;
}

export interface AwsEc2ClientVPNEndpoint {
    AuthenticationOptions:    AuthenticationOption[];
    ClientCidrBlock:          string;
    ClientConnectOptions:     ClientConnectOptions;
    ClientLoginBannerOptions: ClientConnectOptions;
    ClientVpnEndpointId:      string;
    ConnectionLogOptions:     ClientConnectOptions;
    Description:              string;
    DnsServer:                string[];
    ServerCertificateArn:     string;
    SecurityGroupIdSet:       string[];
    SelfServicePortalUrl:     string;
    SessionTimeoutHours:      string;
    SplitTunnel:              string;
    TransportProtocol:        string;
    VpcId:                    string;
    VpnPort:                  string;
}

export interface AuthenticationOption {
    MutualAuthentication: MutualAuthentication;
    Type:                 string;
}

export interface MutualAuthentication {
    ClientRootCertificateChainArn: string;
}

export interface ClientConnectOptions {
    Enabled: string;
}

export interface AwsEc2Eip {
    AllocationId:            string;
    AssociationId:           string;
    Domain:                  string;
    InstanceId:              string;
    NetworkBorderGroup:      string;
    NetworkInterfaceId:      string;
    NetworkInterfaceOwnerId: string;
    PrivateIpAddress:        string;
    PublicIp:                string;
    PublicIpv4Pool:          string;
}

export interface AwsEc2Instance {
    IamInstanceProfileArn: string;
    ImageId:               string;
    IpV4Addresses:         string[];
    IpV6Addresses:         string[];
    KeyName:               string;
    LaunchedAt:            string;
    MetadataOptions:       AwsEc2InstanceMetadataOptions;
    Monitoring:            Monitoring;
    NetworkInterfaces:     AwsEc2InstanceNetworkInterface[];
    SubnetId:              string;
    Type:                  string;
    VirtualizationType:    string;
    VpcId:                 string;
}

export interface AwsEc2InstanceMetadataOptions {
    HttpEndpoint:            string;
    HttpProtocolIpv6:        string;
    HttpPutResponseHopLimit: string;
    HttpTokens:              string;
    InstanceMetadataTags:    string;
}

export interface Monitoring {
    State: string;
}

export interface AwsEc2InstanceNetworkInterface {
    NetworkInterfaceId: string;
}

export interface AwsEc2LaunchTemplate {
    DefaultVersionNumber:         string;
    ElasticGpuSpecifications:     string[];
    ElasticInferenceAccelerators: string[];
    Id:                           string;
    ImageId:                      string;
    LatestVersionNumber:          string;
    LaunchTemplateData:           LaunchTemplateData;
    LaunchTemplateName:           string;
    LicenseSpecifications:        string[];
    SecurityGroupIds:             string[];
    SecurityGroups:               string[];
    TagSpecifications:            string[];
}

export interface LaunchTemplateData {
    BlockDeviceMappings: LaunchTemplateDataBlockDeviceMapping[];
    MetadataOptions:     LaunchTemplateDataMetadataOptions;
    Monitoring:          ClientConnectOptions;
    NetworkInterfaces:   LaunchTemplateDataNetworkInterface[];
}

export interface LaunchTemplateDataBlockDeviceMapping {
    DeviceName: string;
    Ebs:        PurpleEbs;
}

export interface PurpleEbs {
    DeleteonTermination: string;
    Encrypted:           string;
    SnapshotId:          string;
    VolumeSize:          string;
    VolumeType:          string;
}

export interface LaunchTemplateDataMetadataOptions {
    HttpTokens:              string;
    HttpPutResponseHopLimit: string;
}

export interface LaunchTemplateDataNetworkInterface {
    AssociatePublicIpAddress: string;
}

export interface AwsEc2NetworkACL {
    Associations: Association[];
    Entries:      Entry[];
    IsDefault:    string;
    NetworkAclId: string;
    OwnerId:      string;
    VpcId:        string;
}

export interface Association {
    NetworkAclAssociationId: string;
    NetworkAclId:            string;
    SubnetId:                string;
}

export interface Entry {
    CidrBlock:     string;
    Egress:        string;
    IcmpTypeCode:  ICMPTypeCode;
    Ipv6CidrBlock: string;
    PortRange:     EntryPortRange;
    Protocol:      string;
    RuleAction:    string;
    RuleNumber:    string;
}

export interface ICMPTypeCode {
    Code: string;
    Type: string;
}

export interface EntryPortRange {
    From: string;
    To:   string;
}

export interface AwsEc2NetworkInterface {
    Attachment:         AwsEc2NetworkInterfaceAttachment;
    Ipv6Addresses:      Ipv6Address[];
    NetworkInterfaceId: string;
    PrivateIpAddresses: PrivateIPAddress[];
    PublicDnsName:      string;
    PublicIp:           string;
    SecurityGroups:     SecurityGroup[];
    SourceDestCheck:    string;
}

export interface AwsEc2NetworkInterfaceAttachment {
    AttachmentId:        string;
    AttachTime:          string;
    DeleteOnTermination: string;
    DeviceIndex:         string;
    InstanceId:          string;
    InstanceOwnerId:     string;
    Status:              string;
}

export interface Ipv6Address {
    Ipv6Address: string;
}

export interface PrivateIPAddress {
    PrivateDnsName:   string;
    PrivateIpAddress: string;
}

export interface SecurityGroup {
    GroupId:   string;
    GroupName: string;
}

export interface AwsEc2RouteTable {
    AssociationSet:    AssociationSet[];
    PropogatingVgwSet: any[];
    RouteTableId:      string;
    RouteSet:          RouteSet[];
    VpcId:             string;
}

export interface AssociationSet {
    AssociationState:        Monitoring;
    Main:                    string;
    RouteTableAssociationId: string;
    RouteTableId:            string;
}

export interface RouteSet {
    DestinationCidrBlock: string;
    GatewayId:            string;
    Origin:               string;
    State:                string;
}

export interface AwsEc2SecurityGroup {
    GroupId:             string;
    GroupName:           string;
    IpPermissions:       IPPermission[];
    IpPermissionsEgress: IPPermission[];
    OwnerId:             string;
    VpcId:               string;
}

export interface IPPermission {
    FromPort:         string;
    IpProtocol:       string;
    IpRanges:         IPPermissionIPRange[];
    Ipv6Ranges:       Ipv6Range[];
    PrefixListIds:    PrefixListID[];
    ToPort:           string;
    UserIdGroupPairs: UserIDGroupPair[];
}

export interface IPPermissionIPRange {
    CidrIp: string;
}

export interface Ipv6Range {
    CidrIpv6: string;
}

export interface PrefixListID {
    PrefixListId: string;
}

export interface UserIDGroupPair {
    GroupId:                string;
    GroupName:              string;
    PeeringStatus:          string;
    UserId:                 string;
    VpcId:                  string;
    VpcPeeringConnectionId: string;
}

export interface AwsEc2Subnet {
    AssignIpv6AddressOnCreation: string;
    AvailabilityZone:            string;
    AvailabilityZoneId:          string;
    AvailableIpAddressCount:     string;
    CidrBlock:                   string;
    DefaultForAz:                string;
    Ipv6CidrBlockAssociationSet: Ipv6CIDRBlockAssociationSet[];
    MapPublicIpOnLaunch:         string;
    OwnerId:                     string;
    State:                       string;
    SubnetArn:                   string;
    SubnetId:                    string;
    VpcId:                       string;
}

export interface Ipv6CIDRBlockAssociationSet {
    AssociationId:  string;
    Ipv6CidrBlock:  string;
    CidrBlockState: string;
}

export interface AwsEc2TransitGateway {
    AmazonSideAsn:                  string;
    AssociationDefaultRouteTableId: string;
    AutoAcceptSharedAttachments:    string;
    DefaultRouteTableAssociation:   string;
    DefaultRouteTablePropagation:   string;
    Description:                    string;
    DnsSupport:                     string;
    Id:                             string;
    MulticastSupport:               string;
    PropagationDefaultRouteTableId: string;
    TransitGatewayCidrBlocks:       string[];
    VpnEcmpSupport:                 string;
}

export interface AwsEc2Volume {
    Attachments:      AttachmentElement[];
    CreateTime:       string;
    DeviceName:       string;
    Encrypted:        string;
    KmsKeyId:         string;
    Size:             string;
    SnapshotId:       string;
    Status:           string;
    VolumeId:         string;
    VolumeScanStatus: string;
    VolumeType:       string;
}

export interface AttachmentElement {
    AttachTime:          string;
    DeleteOnTermination: string;
    InstanceId:          string;
    Status:              string;
}

export interface AwsEc2Vpc {
    CidrBlockAssociationSet:     CIDRBlockAssociationSet[];
    DhcpOptionsId:               string;
    Ipv6CidrBlockAssociationSet: Ipv6CIDRBlockAssociationSet[];
    State:                       string;
}

export interface CIDRBlockAssociationSet {
    AssociationId:  string;
    CidrBlock:      string;
    CidrBlockState: string;
}

export interface AwsEc2VpcEndpointService {
    AcceptanceRequired:      string;
    AvailabilityZones:       string[];
    BaseEndpointDnsNames:    string[];
    ManagesVpcEndpoints:     string;
    GatewayLoadBalancerArns: string[];
    NetworkLoadBalancerArns: string[];
    PrivateDnsName:          string;
    ServiceId:               string;
    ServiceName:             string;
    ServiceState:            string;
    ServiceType:             ServiceType[];
}

export interface ServiceType {
    ServiceType: string;
}

export interface AwsEc2VpcPeeringConnection {
    AccepterVpcInfo:        TerVpcInfo;
    ExpirationTime:         string;
    RequesterVpcInfo:       TerVpcInfo;
    Status:                 Status;
    VpcPeeringConnectionId: string;
}

export interface TerVpcInfo {
    CidrBlock:        string;
    CidrBlockSet:     CIDRBlockSet[];
    Ipv6CidrBlockSet: Ipv6CIDRBlockSet[];
    OwnerId:          string;
    PeeringOptions:   PeeringOptions;
    Region:           string;
    VpcId:            string;
}

export interface CIDRBlockSet {
    CidrBlock: string;
}

export interface Ipv6CIDRBlockSet {
    Ipv6CidrBlock: string;
}

export interface PeeringOptions {
    AllowDnsResolutionFromRemoteVpc:            string;
    AllowEgressFromLocalClassicLinkToRemoteVpc: string;
    AllowEgressFromLocalVpcToRemoteClassicLink: string;
}

export interface Status {
    Code:    string;
    Message: string;
}

export interface AwsEcrContainerImage {
    Architecture:     string;
    ImageDigest:      string;
    ImagePublishedAt: string;
    ImageTags:        string[];
    RegistryId:       string;
    RepositoryName:   string;
}

export interface AwsEcrRepository {
    Arn:                        string;
    ImageScanningConfiguration: ImageScanningConfiguration;
    ImageTagMutability:         string;
    LifecyclePolicy:            LifecyclePolicy;
    RepositoryName:             string;
    RepositoryPolicyText:       string;
}

export interface ImageScanningConfiguration {
    ScanOnPush: string;
}

export interface LifecyclePolicy {
    LifecyclePolicyText: string;
    RegistryId:          string;
}

export interface AwsEcsCluster {
    ActiveServicesCount:               string;
    CapacityProviders:                 string[];
    ClusterArn:                        string;
    ClusterName:                       string;
    ClusterSettings:                   Dimension[];
    Configuration:                     AwsEcsClusterConfiguration;
    DefaultCapacityProviderStrategy:   CapacityProviderStrategy[];
    RegisteredContainerInstancesCount: string;
    RunningTasksCount:                 string;
    Status:                            string;
}

export interface AwsEcsClusterConfiguration {
    ExecuteCommandConfiguration: ExecuteCommandConfiguration;
}

export interface ExecuteCommandConfiguration {
    KmsKeyId:         string;
    LogConfiguration: ExecuteCommandConfigurationLogConfiguration;
    Logging:          string;
}

export interface ExecuteCommandConfigurationLogConfiguration {
    CloudWatchEncryptionEnabled: string;
    CloudWatchLogGroupName:      string;
    S3BucketName:                string;
    S3EncryptionEnabled:         string;
    S3KeyPrefix:                 string;
}

export interface CapacityProviderStrategy {
    Base:             string;
    CapacityProvider: string;
    Weight:           string;
}

export interface Container {
    Image:       string;
    MountPoints: AwsEcsContainerMountPoint[];
    Name:        string;
    Privileged:  string;
}

export interface AwsEcsContainerMountPoint {
    ContainerPath: string;
    SourceVolume:  string;
}

export interface AwsEcsService {
    CapacityProviderStrategy:      CapacityProviderStrategy[];
    Cluster:                       string;
    DeploymentConfiguration:       DeploymentConfiguration;
    DeploymentController:          DeploymentController;
    DesiredCount:                  string;
    EnableEcsManagedTags:          string;
    EnableExecuteCommand:          string;
    HealthCheckGracePeriodSeconds: string;
    LaunchType:                    string;
    LoadBalancers:                 LoadBalancer[];
    Name:                          string;
    NetworkConfiguration:          NetworkConfiguration;
    PlacementConstraints:          PlacementConstraint[];
    PlacementStrategies:           PlacementStrategy[];
    PlatformVersion:               string;
    PropagateTags:                 string;
    Role:                          string;
    SchedulingStrategy:            string;
    ServiceArn:                    string;
    ServiceName:                   string;
    ServiceRegistries:             ServiceRegistry[];
    TaskDefinition:                string;
}

export interface DeploymentConfiguration {
    DeploymentCircuitBreaker: DeploymentCircuitBreaker;
    MaximumPercent:           string;
    MinimumHealthyPercent:    string;
}

export interface DeploymentCircuitBreaker {
    Enable:   string;
    Rollback: string;
}

export interface DeploymentController {
    Type: string;
}

export interface LoadBalancer {
    ContainerName:    string;
    ContainerPort:    string;
    LoadBalancerName: string;
    TargetGroupArn:   string;
}

export interface NetworkConfiguration {
    AwsVpcConfiguration: AwsVpcConfiguration;
}

export interface AwsVpcConfiguration {
    AssignPublicIp: string;
    SecurityGroups: string[];
    Subnets:        string[];
}

export interface PlacementConstraint {
    Expression: string;
    Type:       string;
}

export interface PlacementStrategy {
    Field: string;
    Type:  string;
}

export interface ServiceRegistry {
    ContainerName: string;
    ContainerPort: string;
    Port:          string;
    RegistryArn:   string;
}

export interface AwsEcsTask {
    CreatedAt:         string;
    ClusterArn:        string;
    Group:             string;
    StartedAt:         string;
    StartedBy:         string;
    TaskDefinitionArn: string;
    Version:           string;
    Volumes:           AwsEcsTaskVolume[];
    Containers:        Container[];
}

export interface AwsEcsTaskVolume {
    Name: string;
    Host: Host;
}

export interface Host {
    SourcePath: string;
}

export interface AwsEcsTaskDefinition {
    ContainerDefinitions:    ContainerDefinition[];
    Cpu:                     string;
    ExecutionRoleArn:        string;
    Family:                  string;
    InferenceAccelerators:   InferenceAccelerator[];
    IpcMode:                 string;
    Memory:                  string;
    NetworkMode:             string;
    PidMode:                 string;
    PlacementConstraints:    PlacementConstraint[];
    ProxyConfiguration:      ProxyConfiguration;
    RequiresCompatibilities: string[];
    Status:                  string;
    TaskRoleArn:             string;
    Volumes:                 AwsEcsTaskDefinitionVolume[];
}

export interface ContainerDefinition {
    Command:                string[];
    Cpu:                    string;
    DependsOn:              DependsOn[];
    DisableNetworking:      string;
    DnsSearchDomains:       string[];
    DnsServers:             string[];
    DockerLabels:           ProductFields;
    DockerSecurityOptions:  string[];
    EntryPoint:             string[];
    Environment:            Dimension[];
    EnvironmentFiles:       EnvironmentFile[];
    Essential:              string;
    ExtraHosts:             ExtraHost[];
    FirelensConfiguration:  FirelensConfiguration;
    HealthCheck:            ContainerDefinitionHealthCheck;
    Hostname:               string;
    Image:                  string;
    Interactive:            string;
    Links:                  string[];
    LinuxParameters:        LinuxParameters;
    LogConfiguration:       ContainerDefinitionLogConfiguration;
    Memory:                 string;
    MemoryReservation:      string;
    MountPoints:            ContainerDefinitionMountPoint[];
    Name:                   string;
    PortMappings:           PortMapping[];
    Privileged:             string;
    PseudoTerminal:         string;
    ReadonlyRootFilesystem: string;
    RepositoryCredentials:  RepositoryCredentials;
    ResourceRequirements:   EnvironmentFile[];
    Secrets:                Secret[];
    StartTimeout:           string;
    StopTimeout:            string;
    SystemControls:         SystemControl[];
    Ulimits:                Ulimit[];
    User:                   string;
    VolumesFrom:            VolumesFrom[];
    WorkingDirectory:       string;
}

export interface DependsOn {
    Condition:     string;
    ContainerName: string;
}

export interface EnvironmentFile {
    Type:  string;
    Value: string;
}

export interface ExtraHost {
    Hostname:  string;
    IpAddress: string;
}

export interface FirelensConfiguration {
    Options: ProductFields;
    Type:    string;
}

export interface ContainerDefinitionHealthCheck {
    Command:     string[];
    Interval:    string;
    Retries:     string;
    StartPeriod: string;
    Timeout:     string;
}

export interface LinuxParameters {
    Capabilities:       Capabilities;
    Devices:            Device[];
    InitProcessEnabled: string;
    MaxSwap:            string;
    SharedMemorySize:   string;
    Swappiness:         string;
    Tmpfs:              Tmpf[];
}

export interface Capabilities {
    Add:  string[];
    Drop: string[];
}

export interface Device {
    ContainerPath: string;
    HostPath:      string;
    Permissions:   string[];
}

export interface Tmpf {
    ContainerPath: string;
    MountOptions:  string[];
    Size:          string;
}

export interface ContainerDefinitionLogConfiguration {
    LogDriver:     string;
    Options:       ProductFields;
    SecretOptions: Secret[];
}

export interface Secret {
    Name:      string;
    ValueFrom: string;
}

export interface ContainerDefinitionMountPoint {
    ContainerPath: string;
    ReadOnly:      string;
    SourceVolume:  string;
}

export interface PortMapping {
    ContainerPort: string;
    HostPort:      string;
    Protocol:      string;
}

export interface RepositoryCredentials {
    CredentialsParameter: string;
}

export interface SystemControl {
    Namespace: string;
    Value:     string;
}

export interface Ulimit {
    HardLimit: string;
    Name:      string;
    SoftLimit: string;
}

export interface VolumesFrom {
    ReadOnly:        string;
    SourceContainer: string;
}

export interface InferenceAccelerator {
    DeviceName: string;
    DeviceType: string;
}

export interface ProxyConfiguration {
    ContainerName:                string;
    ProxyConfigurationProperties: Dimension[];
    Type:                         string;
}

export interface AwsEcsTaskDefinitionVolume {
    DockerVolumeConfiguration: DockerVolumeConfiguration;
    EfsVolumeConfiguration:    EFSVolumeConfiguration;
    Host:                      Host;
    Name:                      string;
}

export interface DockerVolumeConfiguration {
    Autoprovision: string;
    Driver:        string;
    DriverOpts:    ProductFields;
    Labels:        ProductFields;
    Scope:         string;
}

export interface EFSVolumeConfiguration {
    AuthorizationConfig:   AuthorizationConfig;
    FilesystemId:          string;
    RootDirectory:         string;
    TransitEncryption:     string;
    TransitEncryptionPort: string;
}

export interface AuthorizationConfig {
    AccessPointId: string;
    Iam:           string;
}

export interface AwsEFSAccessPoint {
    AccessPointId: string;
    Arn:           string;
    ClientToken:   string;
    FileSystemId:  string;
    PosixUser:     POSIXUser;
    RootDirectory: RootDirectory;
}

export interface POSIXUser {
    Gid:           string;
    SecondaryGids: string[];
    Uid:           string;
}

export interface RootDirectory {
    CreationInfo: CreationInfo;
    Path:         string;
}

export interface CreationInfo {
    OwnerGid:    string;
    OwnerUid:    string;
    Permissions: string;
}

export interface AwsEksCluster {
    Arn:                      string;
    CertificateAuthorityData: string;
    ClusterStatus:            string;
    Endpoint:                 string;
    Logging:                  AwsEksClusterLogging;
    Name:                     string;
    ResourcesVpcConfig:       ResourcesVpcConfig;
    RoleArn:                  string;
    Version:                  string;
}

export interface AwsEksClusterLogging {
    ClusterLogging: ClusterLogging[];
}

export interface ClusterLogging {
    Enabled: string;
    Types:   string[];
}

export interface ResourcesVpcConfig {
    EndpointPublicAccess: string;
    SecurityGroupIds:     string[];
    SubnetIds:            string[];
}

export interface AwsElasticBeanstalkEnvironment {
    ApplicationName:   string;
    Cname:             string;
    DateCreated:       string;
    DateUpdated:       string;
    Description:       string;
    EndpointUrl:       string;
    EnvironmentArn:    string;
    EnvironmentId:     string;
    EnvironmentLinks:  EnvironmentLink[];
    EnvironmentName:   string;
    OptionSettings:    OptionSetting[];
    PlatformArn:       string;
    SolutionStackName: string;
    Status:            string;
    Tier:              Tier;
    VersionLabel:      string;
}

export interface EnvironmentLink {
    EnvironmentName: string;
    LinkName:        string;
}

export interface OptionSetting {
    Namespace:    string;
    OptionName:   string;
    ResourceName: string;
    Value:        string;
}

export interface Tier {
    Name:    string;
    Type:    string;
    Version: string;
}

export interface AwsElasticSearchDomain {
    AccessPolicies:              string;
    DomainStatus:                DomainStatus;
    DomainEndpointOptions:       AwsElasticSearchDomainDomainEndpointOptions;
    ElasticsearchClusterConfig:  ElasticsearchClusterConfig;
    ElasticsearchVersion:        string;
    EncryptionAtRestOptions:     EncryptionAtRESTOptions;
    LogPublishingOptions:        LogPublishingOptions;
    NodeToNodeEncryptionOptions: ClientConnectOptions;
    ServiceSoftwareOptions:      ServiceSoftwareOptions;
    VPCOptions:                  VPCOptions;
}

export interface AwsElasticSearchDomainDomainEndpointOptions {
    EnforceHTTPS:      string;
    TLSSecurityPolicy: string;
}

export interface DomainStatus {
    DomainId:   string;
    DomainName: string;
    Endpoint:   string;
    Endpoints:  ProductFields;
}

export interface ElasticsearchClusterConfig {
    DedicatedMasterCount:   string;
    DedicatedMasterEnabled: string;
    DedicatedMasterType:    string;
    InstanceCount:          string;
    InstanceType:           string;
    ZoneAwarenessConfig:    ZoneAwarenessConfig;
    ZoneAwarenessEnabled:   string;
}

export interface ZoneAwarenessConfig {
    AvailabilityZoneCount: string;
}

export interface EncryptionAtRESTOptions {
    Enabled:  string;
    KmsKeyId: string;
}

export interface LogPublishingOptions {
    AuditLogs:      Logs;
    IndexSlowLogs:  Logs;
    SearchSlowLogs: Logs;
}

export interface Logs {
    CloudWatchLogsLogGroupArn: string;
    Enabled:                   string;
}

export interface ServiceSoftwareOptions {
    AutomatedUpdateDate: string;
    Cancellable:         string;
    CurrentVersion:      string;
    Description:         string;
    NewVersion:          string;
    UpdateAvailable:     string;
    UpdateStatus:        string;
    OptionalDeployment?: string;
}

export interface VPCOptions {
    AvailabilityZones: string[];
    SecurityGroupIds:  string[];
    SubnetIds:         string[];
    VPCId:             string;
}

export interface AwsElbLoadBalancer {
    AvailabilityZones:         string[];
    BackendServerDescriptions: BackendServerDescription[];
    CanonicalHostedZoneName:   string;
    CanonicalHostedZoneNameID: string;
    CreatedTime:               string;
    DnsName:                   string;
    HealthCheck:               AwsElbLoadBalancerHealthCheck;
    Instances:                 Instance[];
    ListenerDescriptions:      ListenerDescription[];
    LoadBalancerAttributes:    LoadBalancerAttributes;
    LoadBalancerName:          string;
    Policies:                  Policies;
    Scheme:                    string;
    SecurityGroups:            string[];
    SourceSecurityGroup:       SourceSecurityGroup;
    Subnets:                   string[];
    VpcId:                     string;
}

export interface BackendServerDescription {
    InstancePort: string;
    PolicyNames:  string[];
}

export interface AwsElbLoadBalancerHealthCheck {
    HealthyThreshold:   string;
    Interval:           string;
    Target:             string;
    Timeout:            string;
    UnhealthyThreshold: string;
}

export interface Instance {
    InstanceId: string;
}

export interface ListenerDescription {
    Listener:    Listener;
    PolicyNames: string[];
}

export interface Listener {
    InstancePort:     string;
    InstanceProtocol: string;
    LoadBalancerPort: string;
    Protocol:         string;
    SslCertificateId: string;
}

export interface LoadBalancerAttributes {
    AccessLog:              AccessLog;
    ConnectionDraining:     ConnectionDraining;
    ConnectionSettings:     ConnectionSettings;
    CrossZoneLoadBalancing: ClientConnectOptions;
    AdditionalAttributes:   LoadBalancerAttribute[];
}

export interface AccessLog {
    EmitInterval:   string;
    Enabled:        string;
    S3BucketName:   string;
    S3BucketPrefix: string;
}

export interface LoadBalancerAttribute {
    Key:   string;
    Value: string;
}

export interface ConnectionDraining {
    Enabled: string;
    Timeout: string;
}

export interface ConnectionSettings {
    IdleTimeout: string;
}

export interface Policies {
    AppCookieStickinessPolicies: AppCookieStickinessPolicy[];
    LbCookieStickinessPolicies:  LBCookieStickinessPolicy[];
    OtherPolicies:               string[];
}

export interface AppCookieStickinessPolicy {
    CookieName: string;
    PolicyName: string;
}

export interface LBCookieStickinessPolicy {
    CookieExpirationPeriod: string;
    PolicyName:             string;
}

export interface SourceSecurityGroup {
    GroupName:  string;
    OwnerAlias: string;
}

export interface AwsElbv2LoadBalancer {
    AvailabilityZones:      AvailabilityZones;
    CanonicalHostedZoneId:  string;
    CreatedTime:            string;
    DNSName:                string;
    IpAddressType:          string;
    LoadBalancerAttributes: LoadBalancerAttribute[];
    Scheme:                 string;
    SecurityGroups:         string[];
    State:                  Stat;
    Type:                   string;
    VpcId:                  string;
}

export interface AvailabilityZones {
    SubnetId: string;
    ZoneName: string;
}

export interface Stat {
    Code:   string;
    Reason: string;
}

export interface AwsEventSchemasRegistry {
    Description:  string;
    RegistryArn:  string;
    RegistryName: string;
}

export interface AwsEventsEndpoint {
    Arn:               string;
    Description:       string;
    EndpointId:        string;
    EndpointUrl:       string;
    EventBuses:        EventBus[];
    Name:              string;
    ReplicationConfig: Monitoring;
    RoleArn:           string;
    RoutingConfig:     RoutingConfig;
    State:             string;
}

export interface EventBus {
    EventBusArn: string;
}

export interface RoutingConfig {
    FailoverConfig: FailoverConfig;
}

export interface FailoverConfig {
    Primary:   Primary;
    Secondary: Secondary;
}

export interface Primary {
    HealthCheck: string;
}

export interface Secondary {
    Route: string;
}

export interface AwsEventsEventBus {
    Arn:    string;
    Name:   string;
    Policy: string;
}

export interface AwsGuardDutyDetector {
    FindingPublishingFrequency: string;
    ServiceRole:                string;
    Status:                     string;
    DataSources:                DataSources;
}

export interface DataSources {
    CloudTrail:        Workflow;
    DnsLogs:           Workflow;
    FlowLogs:          Workflow;
    S3Logs:            Workflow;
    Kubernetes:        Kubernetes;
    MalwareProtection: MalwareProtection;
}

export interface Workflow {
    Status: string;
}

export interface Kubernetes {
    AuditLogs: Workflow;
}

export interface MalwareProtection {
    ScanEc2InstanceWithFindings: ScanEc2InstanceWithFindings;
    ServiceRole:                 string;
}

export interface ScanEc2InstanceWithFindings {
    EbsVolumes: Workflow;
}

export interface AwsIamAccessKey {
    AccessKeyId:    string;
    AccountId:      string;
    CreatedAt:      string;
    PrincipalId:    string;
    PrincipalName:  string;
    PrincipalType:  string;
    SessionContext: SessionContext;
    Status:         string;
}

export interface SessionContext {
    Attributes:    Attributes;
    SessionIssuer: SessionIssuer;
}

export interface Attributes {
    CreationDate:     string;
    MfaAuthenticated: string;
}

export interface SessionIssuer {
    AccountId:   string;
    Arn:         string;
    PrincipalId: string;
    Type:        string;
    UserName:    string;
}

export interface AwsIamGroup {
    AttachedManagedPolicies: AttachedManagedPolicy[];
    CreateDate:              string;
    GroupId:                 string;
    GroupName:               string;
    GroupPolicyList:         PolicyList[];
    Path:                    string;
}

export interface AttachedManagedPolicy {
    PolicyArn:  string;
    PolicyName: string;
}

export interface PolicyList {
    PolicyName: string;
}

export interface AwsIamPolicy {
    AttachmentCount:               string;
    CreateDate:                    string;
    DefaultVersionId:              string;
    Description:                   string;
    IsAttachable:                  string;
    Path:                          string;
    PermissionsBoundaryUsageCount: string;
    PolicyId:                      string;
    PolicyName:                    string;
    PolicyVersionList:             PolicyVersionList[];
    UpdateDate:                    string;
}

export interface PolicyVersionList {
    CreateDate:       string;
    IsDefaultVersion: string;
    VersionId:        string;
}

export interface AwsIamRole {
    AssumeRolePolicyDocument: string;
    AttachedManagedPolicies:  AttachedManagedPolicy[];
    CreateDate:               string;
    InstanceProfileList:      InstanceProfileList[];
    MaxSessionDuration:       string;
    Path:                     string;
    PermissionsBoundary:      PermissionsBoundary;
    RoleId:                   string;
    RoleName:                 string;
    RolePolicyList:           PolicyList[];
}

export interface InstanceProfileList {
    Arn:                 string;
    CreateDate:          string;
    InstanceProfileId:   string;
    InstanceProfileName: string;
    Path:                string;
    Roles:               Role[];
}

export interface Role {
    Arn:                      string;
    AssumeRolePolicyDocument: string;
    CreateDate:               string;
    Path:                     string;
    RoleId:                   string;
    RoleName:                 string;
}

export interface PermissionsBoundary {
    PermissionsBoundaryArn:  string;
    PermissionsBoundaryType: string;
}

export interface AwsIamUser {
    AttachedManagedPolicies: AttachedManagedPolicy[];
    CreateDate:              string;
    GroupList:               string[];
    Path:                    string;
    PermissionsBoundary:     PermissionsBoundary;
    UserId:                  string;
    UserName:                string;
    UserPolicyList:          PolicyList[];
}

export interface AwsKinesisStream {
    Arn:                  string;
    Name:                 string;
    RetentionPeriodHours: string;
    ShardCount:           string;
    StreamEncryption:     StreamEncryption;
}

export interface StreamEncryption {
    EncryptionType: string;
    KeyId:          string;
}

export interface AwsKmsKey {
    AWSAccountId:      string;
    CreationDate:      string;
    Description:       string;
    KeyId:             string;
    KeyManager:        string;
    KeyRotationStatus: string;
    KeyState:          string;
    Origin:            string;
}

export interface AwsLambdaFunction {
    Architectures:    string[];
    Code:             Code;
    CodeSha256:       string;
    DeadLetterConfig: DeadLetterConfig;
    Environment:      AwsLambdaFunctionEnvironment;
    FunctionName:     string;
    Handler:          string;
    KmsKeyArn:        string;
    LastModified:     string;
    Layers:           Layers;
    PackageType:      string;
    RevisionId:       string;
    Role:             string;
    Runtime:          string;
    Timeout:          string;
    TracingConfig:    TracingConfig;
    Version:          string;
    VpcConfig:        Vpc;
    MasterArn:        string;
    MemorySize:       string;
}

export interface Code {
    S3Bucket:        string;
    S3Key:           string;
    S3ObjectVersion: string;
    ZipFile:         string;
}

export interface DeadLetterConfig {
    TargetArn: string;
}

export interface AwsLambdaFunctionEnvironment {
    Variables: Variables;
    Error:     Error;
}

export interface Error {
    ErrorCode: string;
    Message:   string;
}

export interface Variables {
    Stage: string;
}

export interface Layers {
    Arn:      string;
    CodeSize: string;
}

export interface TracingConfig {
    Mode: string;
}

export interface Vpc {
    SecurityGroupIds: string[];
    SubnetIds:        string[];
}

export interface AwsLambdaLayerVersion {
    CompatibleRuntimes: string[];
    CreatedDate:        string;
    Version:            string;
}

export interface AwsMskCluster {
    ClusterInfo: ClusterInfo;
}

export interface ClusterInfo {
    ClientAuthentication: ClientAuthentication;
    ClusterName:          string;
    CurrentVersion:       string;
    EncryptionInfo:       EncryptionInfo;
    EnhancedMonitoring:   string;
    NumberOfBrokerNodes:  string;
}

export interface ClientAuthentication {
    Sasl:            Sasl;
    Tls:             TLS;
    Unauthenticated: ClientConnectOptions;
}

export interface Sasl {
    Scram: ClientConnectOptions;
    Iam:   ClientConnectOptions;
}

export interface TLS {
    CertificateAuthorityArnList: any[];
    Enabled:                     string;
}

export interface EncryptionInfo {
    EncryptionAtRest:    EncryptionAtREST;
    EncryptionInTransit: EncryptionInTransit;
}

export interface EncryptionAtREST {
    DataVolumeKMSKeyId: string;
}

export interface EncryptionInTransit {
    ClientBroker: string;
    InCluster:    string;
}

export interface AwsNetworkFirewallFirewall {
    DeleteProtection:               string;
    Description:                    string;
    FirewallArn:                    string;
    FirewallId:                     string;
    FirewallName:                   string;
    FirewallPolicyArn:              string;
    FirewallPolicyChangeProtection: string;
    SubnetChangeProtection:         string;
    SubnetMappings:                 SubnetMapping[];
    VpcId:                          string;
}

export interface SubnetMapping {
    SubnetId: string;
}

export interface AwsNetworkFirewallFirewallPolicy {
    Description:        string;
    FirewallPolicy:     FirewallPolicy;
    FirewallPolicyArn:  string;
    FirewallPolicyId:   string;
    FirewallPolicyName: string;
}

export interface FirewallPolicy {
    StatefulRuleGroupReferences:     StatefulRuleGroupReference[];
    StatelessCustomActions:          CustomAction[];
    StatelessDefaultActions:         string[];
    StatelessFragmentDefaultActions: string[];
    StatelessRuleGroupReferences:    StatelessRuleGroupReference[];
}

export interface StatefulRuleGroupReference {
    ResourceArn: string;
}

export interface CustomAction {
    ActionDefinition: ActionDefinition;
    ActionName:       string;
}

export interface ActionDefinition {
    PublishMetricAction: PublishMetricAction;
}

export interface PublishMetricAction {
    Dimensions: AvailabilityZone[];
}

export interface AvailabilityZone {
    Value: string;
}

export interface StatelessRuleGroupReference {
    Priority:    string;
    ResourceArn: string;
}

export interface AwsNetworkFirewallRuleGroup {
    Capacity:      string;
    Description:   string;
    RuleGroup:     RuleGroup;
    RuleGroupArn:  string;
    RuleGroupId:   string;
    RuleGroupName: string;
    Type:          string;
}

export interface RuleGroup {
    RulesSource:   RulesSource;
    RuleVariables: RuleVariables;
}

export interface RuleVariables {
    IpSets:   Sets;
    PortSets: Sets;
}

export interface Sets {
    Definition: string[];
}

export interface RulesSource {
    RulesSourceList:                RulesSourceList;
    RulesString:                    string;
    StatefulRules:                  StatefulRule[];
    StatelessRulesAndCustomActions: StatelessRulesAndCustomActions;
}

export interface RulesSourceList {
    GeneratedRulesType: string;
    Targets:            string[];
    TargetTypes:        string[];
}

export interface StatefulRule {
    Action:      string;
    Header:      Header;
    RuleOptions: RuleOption[];
}

export interface Header {
    Destination:     string;
    DestinationPort: string;
    Direction:       string;
    Protocol:        string;
    Source:          string;
    SourcePort:      string;
}

export interface RuleOption {
    Keyword:  string;
    Settings: string[];
}

export interface StatelessRulesAndCustomActions {
    CustomActions:  CustomAction[];
    StatelessRules: StatelessRule[];
}

export interface StatelessRule {
    Priority:       string;
    RuleDefinition: RuleDefinition;
}

export interface RuleDefinition {
    Actions:         string[];
    MatchAttributes: MatchAttributes;
}

export interface MatchAttributes {
    DestinationPorts: Port[];
    Destinations:     DestinationElement[];
    Protocols:        string[];
    SourcePorts:      Port[];
    Sources:          DestinationElement[];
    TcpFlags:         TCPFlag[];
}

export interface Port {
    FromPort: string;
    ToPort:   string;
}

export interface DestinationElement {
    AddressDefinition: string;
}

export interface TCPFlag {
    Flags: string[];
    Masks: string[];
}

export interface AwsOpenSearchServiceDomain {
    AccessPolicies:              string;
    AdvancedSecurityOptions:     AdvancedSecurityOptions;
    Arn:                         string;
    ClusterConfig:               ClusterConfig;
    DomainEndpoint:              string;
    DomainEndpointOptions:       AwsOpenSearchServiceDomainDomainEndpointOptions;
    DomainEndpoints:             ProductFields;
    DomainName:                  string;
    EncryptionAtRestOptions:     EncryptionAtRESTOptions;
    EngineVersion:               string;
    Id:                          string;
    LogPublishingOptions:        LogPublishingOptions;
    NodeToNodeEncryptionOptions: ClientConnectOptions;
    ServiceSoftwareOptions:      ServiceSoftwareOptions;
    VpcOptions:                  Vpc;
}

export interface AdvancedSecurityOptions {
    Enabled:                     string;
    InternalUserDatabaseEnabled: string;
    MasterUserOptions:           MasterUserOptions;
}

export interface MasterUserOptions {
    MasterUserArn:      string;
    MasterUserName:     string;
    MasterUserPassword: string;
}

export interface ClusterConfig {
    DedicatedMasterCount:   string;
    DedicatedMasterEnabled: string;
    DedicatedMasterType:    string;
    InstanceCount:          string;
    InstanceType:           string;
    WarmCount:              string;
    WarmEnabled:            string;
    WarmType:               string;
    ZoneAwarenessConfig:    ZoneAwarenessConfig;
    ZoneAwarenessEnabled:   string;
}

export interface AwsOpenSearchServiceDomainDomainEndpointOptions {
    CustomEndpoint:               string;
    CustomEndpointCertificateArn: string;
    CustomEndpointEnabled:        string;
    EnforceHTTPS:                 string;
    TLSSecurityPolicy:            string;
}

export interface AwsRDSDBCluster {
    ActivityStreamStatus:             string;
    AllocatedStorage:                 string;
    AssociatedRoles:                  AwsRDSDBClusterAssociatedRole[];
    AutoMinorVersionUpgrade:          string;
    AvailabilityZones:                string[];
    BackupRetentionPeriod:            string;
    ClusterCreateTime:                string;
    CopyTagsToSnapshot:               string;
    CrossAccountClone:                string;
    CustomEndpoints:                  string[];
    DatabaseName:                     string;
    DbClusterIdentifier:              string;
    DbClusterMembers:                 DBClusterMember[];
    DbClusterOptionGroupMemberships:  DBClusterOptionGroupMembership[];
    DbClusterParameterGroup:          string;
    DbClusterResourceId:              string;
    DbSubnetGroup:                    string;
    DeletionProtection:               string;
    DomainMemberships:                DomainMembership[];
    EnabledCloudwatchLogsExports:     string[];
    Endpoint:                         string;
    Engine:                           string;
    EngineMode:                       string;
    EngineVersion:                    string;
    HostedZoneId:                     string;
    HttpEndpointEnabled:              string;
    IamDatabaseAuthenticationEnabled: string;
    KmsKeyId:                         string;
    MasterUsername:                   string;
    MultiAz:                          string;
    Port:                             string;
    PreferredBackupWindow:            string;
    PreferredMaintenanceWindow:       string;
    ReaderEndpoint:                   string;
    ReadReplicaIdentifiers:           string[];
    Status:                           string;
    StorageEncrypted:                 string;
    VpcSecurityGroups:                AwsRDSDBClusterVpcSecurityGroup[];
}

export interface AwsRDSDBClusterAssociatedRole {
    RoleArn: string;
    Status:  string;
}

export interface DBClusterMember {
    DbClusterParameterGroupStatus: string;
    DbInstanceIdentifier:          string;
    IsClusterWriter:               string;
    PromotionTier:                 string;
}

export interface DBClusterOptionGroupMembership {
    DbClusterOptionGroupName: string;
    Status:                   string;
}

export interface DomainMembership {
    Domain:      string;
    Fqdn:        string;
    IamRoleName: string;
    Status:      string;
}

export interface AwsRDSDBClusterVpcSecurityGroup {
    Status:             string;
    VpcSecurityGroupId: string;
}

export interface AwsRDSDBClusterSnapshot {
    AllocatedStorage:                 string;
    AvailabilityZones:                string[];
    ClusterCreateTime:                string;
    DbClusterIdentifier:              string;
    DbClusterSnapshotAttributes:      DBClusterSnapshotAttribute[];
    DbClusterSnapshotIdentifier:      string;
    Engine:                           string;
    EngineVersion:                    string;
    IamDatabaseAuthenticationEnabled: string;
    KmsKeyId:                         string;
    LicenseModel:                     string;
    MasterUsername:                   string;
    PercentProgress:                  string;
    Port:                             string;
    SnapshotCreateTime:               string;
    SnapshotType:                     string;
    Status:                           string;
    StorageEncrypted:                 string;
    VpcId:                            string;
}

export interface DBClusterSnapshotAttribute {
    AttributeName:   string;
    AttributeValues: string[];
}

export interface AwsRDSDBInstance {
    AllocatedStorage:                      string;
    AssociatedRoles:                       AwsRDSDBInstanceAssociatedRole[];
    AutoMinorVersionUpgrade:               string;
    AvailabilityZone:                      string;
    BackupRetentionPeriod:                 string;
    CACertificateIdentifier:               string;
    CharacterSetName:                      string;
    CopyTagsToSnapshot:                    string;
    DBClusterIdentifier:                   string;
    DBInstanceClass:                       string;
    DBInstanceIdentifier:                  string;
    DbInstancePort:                        string;
    DbInstanceStatus:                      string;
    DbiResourceId:                         string;
    DBName:                                string;
    DbParameterGroups:                     DBParameterGroup[];
    DbSecurityGroups:                      string[];
    DbSubnetGroup:                         DBSubnetGroup;
    DeletionProtection:                    string;
    Endpoint:                              Endpoint;
    DomainMemberships:                     DomainMembership[];
    EnabledCloudwatchLogsExports:          string[];
    Engine:                                string;
    EngineVersion:                         string;
    EnhancedMonitoringResourceArn:         string;
    IAMDatabaseAuthenticationEnabled:      string;
    InstanceCreateTime:                    string;
    Iops:                                  string;
    KmsKeyId:                              string;
    LatestRestorableTime:                  string;
    LicenseModel:                          string;
    ListenerEndpoint:                      Endpoint;
    MasterUsername:                        string;
    MaxAllocatedStorage:                   string;
    MonitoringInterval:                    string;
    MonitoringRoleArn:                     string;
    MultiAz:                               string;
    OptionGroupMemberships:                OptionGroupMembership[];
    PendingModifiedValues:                 AwsRDSDBInstancePendingModifiedValues;
    PerformanceInsightsEnabled:            string;
    PerformanceInsightsKmsKeyId:           string;
    PerformanceInsightsRetentionPeriod:    string;
    PreferredBackupWindow:                 string;
    PreferredMaintenanceWindow:            string;
    ProcessorFeatures:                     Dimension[];
    PromotionTier:                         string;
    PubliclyAccessible:                    string;
    ReadReplicaDBClusterIdentifiers:       string[];
    ReadReplicaDBInstanceIdentifiers:      string[];
    ReadReplicaSourceDBInstanceIdentifier: string;
    SecondaryAvailabilityZone:             string;
    StatusInfos:                           StatusInfo[];
    StorageEncrypted:                      string;
    TdeCredentialArn:                      string;
    Timezone:                              string;
    VpcSecurityGroups:                     AwsRDSDBClusterVpcSecurityGroup[];
}

export interface AwsRDSDBInstanceAssociatedRole {
    RoleArn:     string;
    FeatureName: string;
    Status:      string;
}

export interface DBParameterGroup {
    DbParameterGroupName: string;
    ParameterApplyStatus: string;
}

export interface DBSubnetGroup {
    DbSubnetGroupArn:         string;
    DbSubnetGroupDescription: string;
    DbSubnetGroupName:        string;
    SubnetGroupStatus:        string;
    Subnets:                  Subnet[];
    VpcId:                    string;
}

export interface Subnet {
    SubnetAvailabilityZone: KeyUsage;
    SubnetIdentifier:       string;
    SubnetStatus:           string;
}

export interface Endpoint {
    Address:      string;
    Port:         string;
    HostedZoneId: string;
}

export interface OptionGroupMembership {
    OptionGroupName: string;
    Status:          string;
}

export interface AwsRDSDBInstancePendingModifiedValues {
    AllocatedStorage:             string;
    BackupRetentionPeriod:        string;
    CaCertificateIdentifier:      string;
    DbInstanceClass:              string;
    DbInstanceIdentifier:         string;
    DbSubnetGroupName:            string;
    EngineVersion:                string;
    Iops:                         string;
    LicenseModel:                 string;
    MasterUserPassword:           string;
    MultiAZ:                      string;
    PendingCloudWatchLogsExports: PendingCloudWatchLogsExports;
    Port:                         string;
    ProcessorFeatures:            Dimension[];
    StorageType:                  string;
}

export interface PendingCloudWatchLogsExports {
    LogTypesToDisable: string[];
    LogTypesToEnable:  string[];
}

export interface StatusInfo {
    Message:    string;
    Normal:     string;
    Status:     string;
    StatusType: string;
}

export interface AwsRDSDBSecurityGroup {
    DbSecurityGroupArn:         string;
    DbSecurityGroupDescription: string;
    DbSecurityGroupName:        string;
    Ec2SecurityGroups:          Ec2SecurityGroup[];
    IpRanges:                   AwsRDSDBSecurityGroupIPRange[];
    OwnerId:                    string;
    VpcId:                      string;
}

export interface Ec2SecurityGroup {
    Ec2SecurityGroupuId:     string;
    Ec2SecurityGroupName:    string;
    Ec2SecurityGroupOwnerId: string;
    Status:                  string;
}

export interface AwsRDSDBSecurityGroupIPRange {
    CidrIp: string;
    Status: string;
}

export interface AwsRDSDBSnapshot {
    AllocatedStorage:                 string;
    AvailabilityZone:                 string;
    DbInstanceIdentifier:             string;
    DbiResourceId:                    string;
    DbSnapshotIdentifier:             string;
    Encrypted:                        string;
    Engine:                           string;
    EngineVersion:                    string;
    IamDatabaseAuthenticationEnabled: string;
    InstanceCreateTime:               string;
    Iops:                             string;
    KmsKeyId:                         string;
    LicenseModel:                     string;
    MasterUsername:                   string;
    OptionGroupName:                  string;
    PercentProgress:                  string;
    Port:                             string;
    ProcessorFeatures:                any[];
    SnapshotCreateTime:               string;
    SnapshotType:                     string;
    SourceDbSnapshotIdentifier:       string;
    SourceRegion:                     string;
    Status:                           string;
    StorageType:                      string;
    TdeCredentialArn:                 string;
    Timezone:                         string;
    VpcId:                            string;
}

export interface AwsRDSEventSubscription {
    CustomerAwsId:            string;
    CustSubscriptionId:       string;
    Enabled:                  string;
    EventCategoriesList:      string[];
    EventSubscriptionArn:     string;
    SnsTopicArn:              string;
    SourceIdsList:            string[];
    SourceType:               string;
    Status:                   string;
    SubscriptionCreationTime: string;
}

export interface AwsRedshiftCluster {
    AllowVersionUpgrade:                    string;
    AutomatedSnapshotRetentionPeriod:       string;
    AvailabilityZone:                       string;
    ClusterAvailabilityStatus:              string;
    ClusterCreateTime:                      string;
    ClusterIdentifier:                      string;
    ClusterNodes:                           ClusterNode[];
    ClusterParameterGroups:                 ClusterParameterGroup[];
    ClusterPublicKey:                       string;
    ClusterRevisionNumber:                  string;
    ClusterSecurityGroups:                  ClusterSecurityGroup[];
    ClusterSnapshotCopyStatus:              ClusterSnapshotCopyStatus;
    ClusterStatus:                          string;
    ClusterSubnetGroupName:                 string;
    ClusterVersion:                         string;
    DBName:                                 string;
    DeferredMaintenanceWindows:             DeferredMaintenanceWindow[];
    ElasticIpStatus:                        ElasticIPStatus;
    ElasticResizeNumberOfNodeOptions:       string;
    Encrypted:                              string;
    Endpoint:                               AwsRedshiftClusterEndpoint;
    EnhancedVpcRouting:                     string;
    ExpectedNextSnapshotScheduleTime:       string;
    ExpectedNextSnapshotScheduleTimeStatus: string;
    HsmStatus:                              HSMStatus;
    IamRoles:                               IamRole[];
    KmsKeyId:                               string;
    LoggingStatus:                          LoggingStatus;
    MaintenanceTrackName:                   string;
    ManualSnapshotRetentionPeriod:          string;
    MasterUsername:                         string;
    NextMaintenanceWindowStartTime:         string;
    NodeType:                               string;
    NumberOfNodes:                          string;
    PendingActions:                         string[];
    PendingModifiedValues:                  AwsRedshiftClusterPendingModifiedValues;
    PreferredMaintenanceWindow:             string;
    PubliclyAccessible:                     string;
    ResizeInfo:                             ResizeInfo;
    RestoreStatus:                          RestoreStatus;
    SnapshotScheduleIdentifier:             string;
    SnapshotScheduleState:                  string;
    VpcId:                                  string;
    VpcSecurityGroups:                      AwsRDSDBClusterVpcSecurityGroup[];
}

export interface ClusterNode {
    NodeRole:         string;
    PrivateIPAddress: string;
    PublicIPAddress:  string;
}

export interface ClusterParameterGroup {
    ClusterParameterStatusList: ClusterParameterStatusList[];
    ParameterApplyStatus:       string;
    ParameterGroupName:         string;
}

export interface ClusterParameterStatusList {
    ParameterApplyErrorDescription: string;
    ParameterApplyStatus:           string;
    ParameterName:                  string;
}

export interface ClusterSecurityGroup {
    ClusterSecurityGroupName: string;
    Status:                   string;
}

export interface ClusterSnapshotCopyStatus {
    DestinationRegion:             string;
    ManualSnapshotRetentionPeriod: string;
    RetentionPeriod:               string;
    SnapshotCopyGrantName:         string;
}

export interface DeferredMaintenanceWindow {
    DeferMaintenanceEndTime:    string;
    DeferMaintenanceIdentifier: string;
    DeferMaintenanceStartTime:  string;
}

export interface ElasticIPStatus {
    ElasticIp: string;
    Status:    string;
}

export interface AwsRedshiftClusterEndpoint {
    Address: string;
    Port:    string;
}

export interface HSMStatus {
    HsmClientCertificateIdentifier: string;
    HsmConfigurationIdentifier:     string;
    Status:                         string;
}

export interface IamRole {
    ApplyStatus: string;
    IamRoleArn:  string;
}

export interface LoggingStatus {
    BucketName:                 string;
    LastFailureMessage:         string;
    LastFailureTime:            string;
    LastSuccessfulDeliveryTime: string;
    LoggingEnabled:             string;
    S3KeyPrefix:                string;
}

export interface AwsRedshiftClusterPendingModifiedValues {
    AutomatedSnapshotRetentionPeriod: string;
    ClusterIdentifier:                string;
    ClusterType:                      string;
    ClusterVersion:                   string;
    EncryptionType:                   string;
    EnhancedVpcRouting:               string;
    MaintenanceTrackName:             string;
    MasterUserPassword:               string;
    NodeType:                         string;
    NumberOfNodes:                    string;
    PubliclyAccessible:               string;
}

export interface ResizeInfo {
    AllowCancelResize: string;
    ResizeType:        string;
}

export interface RestoreStatus {
    CurrentRestoreRateInMegaBytesPerSecond: string;
    ElapsedTimeInSeconds:                   string;
    EstimatedTimeToCompletionInSeconds:     string;
    ProgressInMegaBytes:                    string;
    SnapshotSizeInMegaBytes:                string;
    Status:                                 string;
}

export interface AwsRoute53HostedZone {
    HostedZone:         HostedZone;
    NameServers:        string[];
    QueryLoggingConfig: QueryLoggingConfig;
    Vpcs:               VpcElement[];
}

export interface HostedZone {
    Id:     string;
    Name:   string;
    Config: Config;
}

export interface Config {
    Comment: string;
}

export interface QueryLoggingConfig {
    CloudWatchLogsLogGroupArn: CloudWatchLogsLogGroupArn;
}

export interface CloudWatchLogsLogGroupArn {
    CloudWatchLogsLogGroupArn: string;
    Id:                        string;
    HostedZoneId:              string;
}

export interface VpcElement {
    Id:     string;
    Region: string;
}

export interface AwsS3AccessPoint {
    AccessPointArn:                 string;
    Alias:                          string;
    Bucket:                         string;
    BucketAccountId:                string;
    Name:                           string;
    NetworkOrigin:                  string;
    PublicAccessBlockConfiguration: AwsS3AccountPublicAccessBlock;
    VpcConfiguration:               VpcConfiguration;
}

export interface AwsS3AccountPublicAccessBlock {
    BlockPublicAcls:       string;
    BlockPublicPolicy:     string;
    IgnorePublicAcls:      string;
    RestrictPublicBuckets: string;
}

export interface VpcConfiguration {
    VpcId: string;
}

export interface AwsS3Bucket {
    AccessControlList:                 string;
    BucketLifecycleConfiguration:      BucketLifecycleConfiguration;
    BucketLoggingConfiguration:        BucketLoggingConfiguration;
    BucketName:                        string;
    BucketNotificationConfiguration:   BucketNotificationConfiguration;
    BucketVersioningConfiguration:     BucketVersioningConfiguration;
    BucketWebsiteConfiguration:        BucketWebsiteConfiguration;
    CreatedAt:                         string;
    ObjectLockConfiguration:           ObjectLockConfiguration;
    OwnerAccountId:                    string;
    OwnerId:                           string;
    OwnerName:                         string;
    PublicAccessBlockConfiguration:    AwsS3AccountPublicAccessBlock;
    ServerSideEncryptionConfiguration: ServerSideEncryptionConfiguration;
}

export interface BucketLifecycleConfiguration {
    Rules: BucketLifecycleConfigurationRule[];
}

export interface BucketLifecycleConfigurationRule {
    AbortIncompleteMultipartUpload:    AbortIncompleteMultipartUpload;
    ExpirationDate:                    string;
    ExpirationInDays:                  string;
    ExpiredObjectDeleteMarker:         string;
    Filter:                            RuleFilter;
    Id:                                string;
    NoncurrentVersionExpirationInDays: string;
    NoncurrentVersionTransitions:      NoncurrentVersionTransition[];
    Prefix:                            string;
    Status:                            string;
    Transitions:                       Transition[];
}

export interface AbortIncompleteMultipartUpload {
    DaysAfterInitiation: string;
}

export interface RuleFilter {
    Predicate: Predicate;
}

export interface Predicate {
    Operands: Operand[];
    Type:     string;
}

export interface Operand {
    Prefix?: string;
    Type:    string;
    Tag?:    LoadBalancerAttribute;
}

export interface NoncurrentVersionTransition {
    Days:         string;
    StorageClass: string;
}

export interface Transition {
    Date:         string;
    Days:         string;
    StorageClass: string;
}

export interface BucketLoggingConfiguration {
    DestinationBucketName: string;
    LogFilePrefix:         string;
}

export interface BucketNotificationConfiguration {
    Configurations: ConfigurationElement[];
}

export interface ConfigurationElement {
    Destination: string;
    Events:      string[];
    Filter:      ConfigurationFilter;
    Type:        string;
}

export interface ConfigurationFilter {
    S3KeyFilter: S3KeyFilter;
}

export interface S3KeyFilter {
    FilterRules: Dimension[];
}

export interface BucketVersioningConfiguration {
    IsMfaDeleteEnabled: string;
    Status:             string;
}

export interface BucketWebsiteConfiguration {
    ErrorDocument:         string;
    IndexDocumentSuffix:   string;
    RedirectAllRequestsTo: RedirectAllRequestsTo;
    RoutingRules:          RoutingRule[];
}

export interface RedirectAllRequestsTo {
    HostName: string;
    Protocol: string;
}

export interface RoutingRule {
    Condition: Condition;
    Redirect:  Redirect;
}

export interface Condition {
    HttpErrorCodeReturnedEquals: string;
    KeyPrefixEquals:             string;
}

export interface Redirect {
    HostName:             string;
    HttpRedirectCode:     string;
    Protocol:             string;
    ReplaceKeyPrefixWith: string;
    ReplaceKeyWith:       string;
}

export interface ObjectLockConfiguration {
    ObjectLockEnabled: string;
    Rule:              ObjectLockConfigurationRule;
}

export interface ObjectLockConfigurationRule {
    DefaultRetention: DefaultRetention;
}

export interface DefaultRetention {
    Days:  string;
    Mode:  string;
    Years: string;
}

export interface ServerSideEncryptionConfiguration {
    Rules: ServerSideEncryptionConfigurationRule[];
}

export interface ServerSideEncryptionConfigurationRule {
    ApplyServerSideEncryptionByDefault: ApplyServerSideEncryptionByDefault;
}

export interface ApplyServerSideEncryptionByDefault {
    KMSMasterKeyID: string;
    SSEAlgorithm:   string;
}

export interface AwsS3Object {
    ContentType:          string;
    ETag:                 string;
    LastModified:         string;
    ServerSideEncryption: string;
    SSEKMSKeyId:          string;
    VersionId:            string;
}

export interface AwsSagemakerNotebookInstance {
    DirectInternetAccess:                 string;
    InstanceMetadataServiceConfiguration: InstanceMetadataServiceConfiguration;
    InstanceType:                         string;
    LastModifiedTime:                     string;
    NetworkInterfaceId:                   string;
    NotebookInstanceArn:                  string;
    NotebookInstanceName:                 string;
    NotebookInstanceStatus:               string;
    PlatformIdentifier:                   string;
    RoleArn:                              string;
    RootAccess:                           string;
    SecurityGroups:                       string[];
    SubnetId:                             string;
    Url:                                  string;
    VolumeSizeInGB:                       string;
}

export interface InstanceMetadataServiceConfiguration {
    MinimumInstanceMetadataServiceVersion: string;
}

export interface AwsSecretsManagerSecret {
    Deleted:                         string;
    Description:                     string;
    KmsKeyId:                        string;
    Name:                            string;
    RotationEnabled:                 string;
    RotationLambdaArn:               string;
    RotationOccurredWithinFrequency: string;
    RotationRules:                   RotationRules;
}

export interface RotationRules {
    AutomaticallyAfterDays: string;
}

export interface AwsSnsTopic {
    ApplicationSuccessFeedbackRoleArn: string;
    FirehoseFailureFeedbackRoleArn:    string;
    FirehoseSuccessFeedbackRoleArn:    string;
    HttpFailureFeedbackRoleArn:        string;
    HttpSuccessFeedbackRoleArn:        string;
    KmsMasterKeyId:                    string;
    Owner:                             string;
    SqsFailureFeedbackRoleArn:         string;
    SqsSuccessFeedbackRoleArn:         string;
    Subscription:                      Subscription;
    TopicName:                         string;
}

export interface Subscription {
    Endpoint: string;
    Protocol: string;
}

export interface AwsSqsQueue {
    DeadLetterTargetArn:          string;
    KmsDataKeyReusePeriodSeconds: string;
    KmsMasterKeyId:               string;
    QueueName:                    string;
}

export interface AwsSsmPatchCompliance {
    Patch: Patch;
}

export interface Patch {
    ComplianceSummary: ComplianceSummary;
}

export interface ComplianceSummary {
    ComplianceType:                 string;
    CompliantCriticalCount:         string;
    CompliantHighCount:             string;
    CompliantInformationalCount:    string;
    CompliantLowCount:              string;
    CompliantMediumCount:           string;
    CompliantUnspecifiedCount:      string;
    ExecutionType:                  string;
    NonCompliantCriticalCount:      string;
    NonCompliantHighCount:          string;
    NonCompliantInformationalCount: string;
    NonCompliantLowCount:           string;
    NonCompliantMediumCount:        string;
    NonCompliantUnspecifiedCount:   string;
    OverallSeverity:                string;
    PatchBaselineId:                string;
    PatchGroup:                     string;
    Status:                         string;
}

export interface AwsStepFunctionStateMachine {
    StateMachineArn:      string;
    Name:                 string;
    Status:               string;
    RoleArn:              string;
    Type:                 string;
    LoggingConfiguration: LoggingConfiguration;
    TracingConfiguration: ClientConnectOptions;
}

export interface LoggingConfiguration {
    Level:                string;
    IncludeExecutionData: string;
}

export interface AwsWafRRateBasedRule {
    MatchPredicates: MatchPredicate[];
    MetricName:      string;
    Name:            string;
    RateKey:         string;
    RateLimit:       string;
    RuleId:          string;
}

export interface MatchPredicate {
    DataId:  string;
    Negated: string;
    Type:    string;
}

export interface AwsWafRRule {
    MetricName:    string;
    Name:          string;
    RuleId:        string;
    PredicateList: MatchPredicate[];
}

export interface AwsWafRRuleGroup {
    MetricName:  string;
    Name:        string;
    RuleGroupId: string;
    Rules:       AwsWafRegionalRuleGroupRule[];
}

export interface AwsWafRegionalRuleGroupRule {
    Action:   DeploymentController;
    Priority: string;
    RuleId:   string;
    Type:     string;
}

export interface AwsWafRegionalWebACL {
    DefaultAction: string;
    MetricName:    string;
    Name:          string;
    RulesList:     RulesList[];
    WebAclId:      string;
}

export interface RulesList {
    Action:         DeploymentController;
    Priority:       string;
    RuleId:         string;
    Type:           string;
    ExcludedRules:  RulesListExcludedRule[];
    OverrideAction: DeploymentController;
}

export interface RulesListExcludedRule {
    ExclusionType: string;
    RuleId:        string;
}

export interface AwsWafWebACL {
    DefaultAction: string;
    Name:          string;
    Rules:         AwsWafWebACLRule[];
    WebAclId:      string;
}

export interface AwsWafWebACLRule {
    Action:         DeploymentController;
    ExcludedRules:  RuleExcludedRule[];
    OverrideAction: DeploymentController;
    Priority:       string;
    RuleId:         string;
    Type:           string;
}

export interface RuleExcludedRule {
    RuleId: string;
}

export interface AwsWafv2RuleGroup {
    Arn:              string;
    Capacity:         string;
    Description:      string;
    Id:               string;
    Name:             string;
    Rules:            AwsWafv2RuleGroupRule[];
    VisibilityConfig: VisibilityConfig;
}

export interface AwsWafv2RuleGroupRule {
    Action:           PurpleAction;
    Name:             string;
    Priority:         string;
    VisibilityConfig: VisibilityConfig;
}

export interface PurpleAction {
    Allow: Allow;
}

export interface Allow {
    CustomRequestHandling: CustomRequestHandling;
}

export interface CustomRequestHandling {
    InsertHeaders: Dimension[];
}

export interface VisibilityConfig {
    CloudWatchMetricsEnabled: string;
    MetricName:               string;
    SampledRequestsEnabled:   string;
}

export interface AwsWafv2WebACL {
    Arn:                      string;
    Capacity:                 string;
    CaptchaConfig:            CAPTCHAConfig;
    DefaultAction:            Action;
    Description:              string;
    ManagedbyFirewallManager: string;
    Name:                     string;
    Rules:                    AwsWafv2WebACLRule[];
    VisibilityConfig:         VisibilityConfig;
}

export interface CAPTCHAConfig {
    ImmunityTimeProperty: ImmunityTimeProperty;
}

export interface ImmunityTimeProperty {
    ImmunityTime: string;
}

export interface Action {
    Block: Block;
}

export interface Block {
}

export interface AwsWafv2WebACLRule {
    Action:           FluffyAction;
    Name:             string;
    Priority:         string;
    VisibilityConfig: VisibilityConfig;
}

export interface FluffyAction {
    RuleAction: Action;
}

export interface AwsXrayEncryptionConfig {
    KeyId:  string;
    Status: string;
    Type:   string;
}

export interface PurpleContainer {
    ContainerRuntime: string;
    ImageId:          string;
    ImageName:        string;
    LaunchedAt:       string;
    Name:             string;
    Privileged:       string;
    VolumeMounts:     VolumeMount[];
}

export interface VolumeMount {
    Name:      string;
    MountPath: string;
}

export interface DataClassification {
    DetailedResultsLocation: string;
    Result:                  Result;
}

export interface Result {
    AdditionalOccurrences: string;
    CustomDataIdentifiers: CustomDataIdentifiers;
    MimeType:              string;
    SensitiveData:         SensitiveDatum[];
    SizeClassified:        string;
    Status:                Stat;
}

export interface CustomDataIdentifiers {
    Detections: CustomDataIdentifiersDetection[];
    TotalCount: string;
}

export interface CustomDataIdentifiersDetection {
    Arn:         string;
    Count:       string;
    Name:        string;
    Occurrences: Occurrences;
}

export interface Occurrences {
    Cells:        Cell[];
    LineRanges:   Range[];
    OffsetRanges: Range[];
    Pages:        Page[];
    Records:      Record[];
}

export interface Cell {
    CellReference: string;
    Column:        string;
    ColumnName:    string;
    Row:           string;
}

export interface Range {
    End:         string;
    Start:       string;
    StartColumn: string;
}

export interface Page {
    LineRange:   Range;
    OffsetRange: Range;
    PageNumber:  string;
}

export interface Record {
    JsonPath:    string;
    RecordIndex: string;
}

export interface SensitiveDatum {
    Category:   string;
    Detections: SensitiveDatumDetection[];
    TotalCount: string;
}

export interface SensitiveDatumDetection {
    Count:       string;
    Occurrences: Occurrences;
    Type:        string;
}

export interface Details {
    AwsAmazonMQBroker:                 AwsAmazonMQBroker;
    AwsApiGatewayRestApi:              AwsAPIGatewayRESTAPI;
    AwsApiGatewayStage:                AwsAPIGatewayStage;
    AwsApiGatewayV2Api:                AwsAPIGatewayV2API;
    AwsApiGatewayV2Stage:              AwsAPIGatewayV2Stage;
    AwsAppSyncGraphQLApi:              AwsAppSyncGraphQLAPI;
    AwsAthenaWorkGroup:                AwsAthenaWorkGroup;
    AwsAutoScalingAutoScalingGroup:    AwsAutoScalingAutoScalingGroup;
    AwsAutoScalingLaunchConfiguration: AwsAutoScalingLaunchConfiguration;
    ImageId:                           string;
    InstanceMonitoring:                ClientConnectOptions;
    InstanceType:                      string;
    KernelId:                          string;
    KeyName:                           string;
    LaunchConfigurationName:           string;
    MetadataOptions:                   DetailsMetadataOptions;
    PlacementTenancy:                  string;
    RamdiskId:                         string;
    SecurityGroups:                    string[];
    SpotPrice:                         string;
    UserData:                          string;
}

export interface AwsAmazonMQBroker {
    AutoMinorVersionUpgrade:    string;
    BrokerArn:                  string;
    BrokerId:                   string;
    BrokerName:                 string;
    Configuration:              AwsAmazonMQBrokerConfiguration;
    DeploymentMode:             string;
    EncryptionOptions:          EncryptionOptions;
    EngineType:                 string;
    EngineVersion:              string;
    HostInstanceType:           string;
    Logs:                       LogsClass;
    MaintenanceWindowStartTime: MaintenanceWindowStartTime;
    PubliclyAccessible:         string;
    SecurityGroups:             string[];
    StorageType:                string;
    SubnetIds:                  string[];
    Users:                      UserElement[];
}

export interface AwsAmazonMQBrokerConfiguration {
    Id:       string;
    Revision: string;
}

export interface EncryptionOptions {
    UseAwsOwnedKey: string;
}

export interface LogsClass {
    Audit:           string;
    AuditLogGroup:   string;
    General:         string;
    GeneralLogGroup: string;
}

export interface MaintenanceWindowStartTime {
    DayOfWeek: string;
    TimeOfDay: string;
    TimeZone:  string;
}

export interface UserElement {
    Username: string;
}

export interface AwsAPIGatewayRESTAPI {
    ApiKeySource:           string;
    BinaryMediaTypes:       string[];
    CreatedDate:            string;
    Description:            string;
    EndpointConfiguration:  EndpointConfiguration;
    Id:                     string;
    MinimumCompressionSize: string;
    Name:                   string;
    Version:                string;
}

export interface EndpointConfiguration {
    Types: string[];
}

export interface AwsAPIGatewayStage {
    AccessLogSettings:    AccessLogSettings;
    CacheClusterEnabled:  string;
    CacheClusterSize:     string;
    CacheClusterStatus:   string;
    CanarySettings:       CanarySettings;
    ClientCertificateId:  string;
    CreatedDate:          string;
    DeploymentId:         string;
    Description:          string;
    DocumentationVersion: string;
    LastUpdatedDate:      string;
    MethodSettings:       MethodSetting[];
    StageName:            string;
    TracingEnabled:       string;
    Variables:            ProductFields;
    WebAclArn:            string;
}

export interface AccessLogSettings {
    DestinationArn: string;
    Format:         string;
}

export interface CanarySettings {
    DeploymentId:           string;
    PercentTraffic:         string;
    StageVariableOverrides: ProductFields[];
    UseStageCache:          string;
}

export interface MethodSetting {
    CacheDataEncrypted:                     string;
    CachingEnabled:                         string;
    CacheTtlInSeconds:                      string;
    DataTraceEnabled:                       string;
    HttpMethod:                             string;
    LoggingLevel:                           string;
    MetricsEnabled:                         string;
    RequireAuthorizationForCacheControl:    string;
    ResourcePath:                           string;
    ThrottlingBurstLimit:                   string;
    ThrottlingRateLimit:                    string;
    UnauthorizedCacheControlHeaderStrategy: string;
}

export interface AwsAPIGatewayV2API {
    ApiEndpoint:               string;
    ApiId:                     string;
    ApiKeySelectionExpression: string;
    CorsConfiguration:         CorsConfiguration;
    CreatedDate:               string;
    Description:               string;
    Name:                      string;
    ProtocolType:              string;
    RouteSelectionExpression:  string;
    Version:                   string;
}

export interface CorsConfiguration {
    AllowCredentials: string;
    AllowHeaders:     string[];
    AllowMethods:     string[];
    AllowOrigins:     string[];
    ExposeHeaders:    string[];
    MaxAge:           string;
}

export interface AwsAPIGatewayV2Stage {
    AccessLogSettings:           AccessLogSettings;
    ApiGatewayManaged:           string;
    AutoDeploy:                  string;
    ClientCertificateId:         string;
    CreatedDate:                 string;
    DefaultRouteSettings:        RouteSettings;
    DeploymentId:                string;
    Description:                 string;
    LastDeploymentStatusMessage: string;
    LastUpdatedDate:             string;
    RouteSettings:               RouteSettings;
    StageName:                   string;
    StageVariables:              ProductFields[];
}

export interface RouteSettings {
    DataTraceEnabled:       string;
    DetailedMetricsEnabled: string;
    LoggingLevel:           string;
    ThrottlingBurstLimit:   string;
    ThrottlingRateLimit:    string;
}

export interface AwsAppSyncGraphQLAPI {
    AwsAppSyncGraphQlApi: AwsAppSyncGraphQlAPI;
}

export interface AwsAppSyncGraphQlAPI {
    AdditionalAuthenticationProviders: AdditionalAuthenticationProvider[];
    ApiId:                             string;
    Arn:                               string;
    AuthenticationType:                string;
    Id:                                string;
    LogConfig:                         LogConfig;
    Name:                              string;
    XrayEnabled:                       string;
}

export interface AdditionalAuthenticationProvider {
    AuthenticationType:      string;
    LambdaAuthorizerConfig?: LambdaAuthorizerConfig;
}

export interface LambdaAuthorizerConfig {
    AuthorizerResultTtlInSeconds: string;
    AuthorizerUri:                string;
}

export interface LogConfig {
    CloudWatchLogsRoleArn: string;
    ExcludeVerboseContent: string;
    FieldLogLevel:         string;
}

export interface AwsAthenaWorkGroup {
    Description:            string;
    Name:                   string;
    WorkgroupConfiguration: WorkgroupConfiguration;
    State:                  string;
}

export interface WorkgroupConfiguration {
    ResultConfiguration: ResultConfiguration;
}

export interface ResultConfiguration {
    EncryptionConfiguration: EncryptionConfiguration;
}

export interface EncryptionConfiguration {
    EncryptionOption: string;
    KmsKey:           string;
}

export interface AwsAutoScalingAutoScalingGroup {
    AvailabilityZones:       AvailabilityZone[];
    CreatedTime:             string;
    HealthCheckGracePeriod:  string;
    HealthCheckType:         string;
    LaunchConfigurationName: string;
    LoadBalancerNames:       string[];
    LaunchTemplate:          LaunchTemplate;
    MixedInstancesPolicy:    MixedInstancesPolicy;
}

export interface LaunchTemplate {
    LaunchTemplateId:   string;
    LaunchTemplateName: string;
    Version:            string;
}

export interface MixedInstancesPolicy {
    InstancesDistribution: InstancesDistribution;
    LaunchTemplate:        MixedInstancesPolicyLaunchTemplate;
}

export interface InstancesDistribution {
    OnDemandAllocationStrategy:          string;
    OnDemandBaseCapacity:                string;
    OnDemandPercentageAboveBaseCapacity: string;
    SpotAllocationStrategy:              string;
    SpotInstancePools:                   string;
    SpotMaxPrice:                        string;
}

export interface MixedInstancesPolicyLaunchTemplate {
    LaunchTemplateSpecification: LaunchTemplate;
    CapacityRebalance:           string;
    Overrides:                   Override[];
}

export interface Override {
    InstanceType:     string;
    WeightedCapacity: string;
}

export interface AwsAutoScalingLaunchConfiguration {
    AssociatePublicIpAddress:     string;
    BlockDeviceMappings:          AwsAutoScalingLaunchConfigurationBlockDeviceMapping[];
    ClassicLinkVpcId:             string;
    ClassicLinkVpcSecurityGroups: string[];
    CreatedTime:                  string;
    EbsOptimized:                 string;
    IamInstanceProfile:           string;
}

export interface AwsAutoScalingLaunchConfigurationBlockDeviceMapping {
    DeviceName:  string;
    Ebs:         FluffyEbs;
    NoDevice:    string;
    VirtualName: string;
}

export interface FluffyEbs {
    DeleteOnTermination: string;
    Encrypted:           string;
    Iops:                string;
    SnapshotId:          string;
    VolumeSize:          string;
    VolumeType:          string;
}

export interface DetailsMetadataOptions {
    HttpEndPoint:           string;
    HttpPutReponseHopLimit: string;
    HttpTokens:             string;
}

export interface ThreatIntelIndicator {
    Category:       string;
    LastObservedAt: string;
    Source:         string;
    SourceUrl:      string;
    Type:           string;
    Value:          string;
}

export interface Threat {
    FilePaths: FilePathElement[];
    ItemCount: string;
    Name:      string;
    Severity:  string;
}

export interface FilePathElement {
    FileName:   string;
    FilePath:   string;
    Hash:       string;
    ResourceId: string;
}

export interface Vulnerability {
    CodeVulnerabilities:    CodeVulnerability[];
    Cvss:                   Cvss[];
    EpssScore:              string;
    ExploitAvailable:       string;
    FixAvailable:           string;
    Id:                     string;
    LastKnownExploitAt:     string;
    ReferenceUrls:          string[];
    RelatedVulnerabilities: string[];
    Vendor:                 Vendor;
    VulnerablePackages:     VulnerablePackage[];
}

export interface CodeVulnerability {
    Cwes:      string[];
    FilePath:  CodeVulnerabilityFilePath;
    SourceArn: string;
}

export interface CodeVulnerabilityFilePath {
    EndLine:   string;
    FileName:  string;
    FilePath:  string;
    StartLine: string;
}

export interface Cvss {
    Adjustments: Adjustment[];
    BaseScore:   string;
    BaseVector:  string;
    Source:      string;
    Version:     string;
}

export interface Adjustment {
    Metric: string;
    Reason: string;
}

export interface Vendor {
    Name:            string;
    Url:             string;
    VendorCreatedAt: string;
    VendorSeverity:  string;
    VendorUpdatedAt: string;
}

export interface VulnerablePackage {
    Architecture:    string;
    Epoch:           string;
    FilePath:        string;
    FixedInVersion:  string;
    Name:            string;
    PackageManager:  string;
    Release:         string;
    Remediation:     string;
    SourceLayerArn:  string;
    SourceLayerHash: string;
    Version:         string;
}

zfindings.json

"Findings": [ 
    {
    	"Action": {
    		"ActionType": "string",
    		"AwsApiCallAction": {
    			"AffectedResources": {
    				"string": "string"
    			},
    			"Api": "string",
    			"CallerType": "string",
    			"DomainDetails": {
    				"Domain": "string"
    			},
    			"FirstSeen": "string",
    			"LastSeen": "string",
    			"RemoteIpDetails": {
    				"City": {
    					"CityName": "string"
    				},
    				"Country": {
    					"CountryCode": "string",
    					"CountryName": "string"
    				},
    				"IpAddressV4": "string",
    				"Geolocation": {
    					"Lat": number,
    					"Lon": number
    				},
    				"Organization": {
    					"Asn": number,
    					"AsnOrg": "string",
    					"Isp": "string",
    					"Org": "string"
    				}
    			},
    			"ServiceName": "string"
    		},
    		"DnsRequestAction": {
    			"Blocked": boolean,
    			"Domain": "string",
    			"Protocol": "string"
    		},
    		"NetworkConnectionAction": {
    			"Blocked": boolean,
    			"ConnectionDirection": "string",
    			"LocalPortDetails": {
    				"Port": number,
    				"PortName": "string"
    			},
    			"Protocol": "string",
    			"RemoteIpDetails": {
    				"City": {
    					"CityName": "string"
    				},
    				"Country": {
    					"CountryCode": "string",
    					"CountryName": "string"
    				},
    				"IpAddressV4": "string",
    				"Geolocation": {
    					"Lat": number,
    					"Lon": number
    				},
    				"Organization": {
    					"Asn": number,
    					"AsnOrg": "string",
    					"Isp": "string",
    					"Org": "string"
    				}
    			},
    			"RemotePortDetails": {
    				"Port": number,
    				"PortName": "string"
    			}
    		},
    		"PortProbeAction": {
    			"Blocked": boolean,
    			"PortProbeDetails": [{
    				"LocalIpDetails": {
    					"IpAddressV4": "string"
    				},
    				"LocalPortDetails": {
    					"Port": number,
    					"PortName": "string"
    				},
    				"RemoteIpDetails": {
    					"City": {
    						"CityName": "string"
    					},
    					"Country": {
    						"CountryCode": "string",
    						"CountryName": "string"
    					},
    					"GeoLocation": {
    						"Lat": number,
    						"Lon": number
    					},
    					"IpAddressV4": "string",
    					"Organization": {
    						"Asn": number,
    						"AsnOrg": "string",
    						"Isp": "string",
    						"Org": "string"
    					}
    				}
    			}]
    		}
    	},
    	"AwsAccountId": "string",
    	"AwsAccountName": "string",
    	"CompanyName": "string",
    	"Compliance": {
    		"AssociatedStandards": [{
    			"StandardsId": "string"
    		}],
    		"RelatedRequirements": ["string"],
    		"SecurityControlId": "string",
    		"SecurityControlParameters": [
    			{
    				"Name": "string",
    				"Value": ["string"]
    			}
   		],
    		"Status": "string",
    		"StatusReasons": [
    			{
    				"Description": "string",
    				"ReasonCode": "string"
    			}
    		]
    	},
    	"Confidence": number,
    	"CreatedAt": "string",
    	"Criticality": number,
    	"Description": "string",
    	"Detection": {
    		"Sequence": {
    			"Uid": "string",
    			"Actors": [{
    				"Id": "string",
    				"Session": {
    					"Uid": "string",
    					"MfAStatus": "string",
    					"CreatedTime": "string",
    					"Issuer": "string"
    				},
    				"User": {
    					"CredentialUid": "string",
    					"Name": "string",
    					"Type": "string",
    					"Uid": "string",
    					"Account": {
    						"Uid": "string",
    						"Name": "string"
    					}
    				}
    			}],
    			"Endpoints": [{
    				"Id": "string",
    				"Ip": "string",
    				"Domain": "string",
    				"Port": number,
    				"Location": {
    					"City": "string",
    					"Country": "string",
    					"Lat": number,
    					"Lon": number
    				},
    				"AutonomousSystem": {
    					"Name": "string",
    					"Number": number
    				},
    				"Connection": {
    					"Direction": "string"
    				}
    			}],
    			"Signals": [{
    				"Id": "string",
    				"Title": "string",
    				"ActorIds": ["string"],
    				"Count": number,
    				"FirstSeenAt": number,
    				"SignalIndicators": [
    					{
    						"Key": "string",
    						"Title": "string",
    						"Values": ["string"]
    					},
    					{
    						"Key": "string",
    						"Title": "string",
    						"Values": ["string"]
    					}
    				],
    				"LastSeenAt": number,
    				"Name": "string",
    				"ResourceIds": ["string"],
    				"Type": "string"
    			}],
    			"SequenceIndicators": [
    				{
    					"Key": "string",
    					"Title": "string",
    					"Values": ["string"]
    				},
    				{
    					"Key": "string",
    					"Title": "string",
    					"Values": ["string"]
    				}
    			]
    		}
    	},
    	"FindingProviderFields": {
    		"Confidence": number,
    		"Criticality": number,
    		"RelatedFindings": [{
    			"ProductArn": "string",
    			"Id": "string"
    		}],
    		"Severity": {
    			"Label": "string",
    			"Normalized": number,
    			"Original": "string"
    		},
    		"Types": ["string"]
    	},
    	"FirstObservedAt": "string",
    	"GeneratorId": "string",
    	"Id": "string",
    	"LastObservedAt": "string",
    	"Malware": [{
    		"Name": "string",
    		"Path": "string",
    		"State": "string",
    		"Type": "string"
    	}],
    	"Network": {
    		"DestinationDomain": "string",
    		"DestinationIpV4": "string",
    		"DestinationIpV6": "string",
    		"DestinationPort": number,
    		"Direction": "string",
    		"OpenPortRange": {
    			"Begin": integer,
    			"End": integer
    		},
    		"Protocol": "string",
    		"SourceDomain": "string",
    		"SourceIpV4": "string",
    		"SourceIpV6": "string",
    		"SourceMac": "string",
    		"SourcePort": number
    	},
    	"NetworkPath": [{
    		"ComponentId": "string",
    		"ComponentType": "string",
    		"Egress": {
    			"Destination": {
    				"Address": ["string"],
    				"PortRanges": [{
    					"Begin": integer,
    					"End": integer
    				}]
    			},
    			"Protocol": "string",
    			"Source": {
    				"Address": ["string"],
    				"PortRanges": [{
    					"Begin": integer,
    					"End": integer
    				}]
    			}
    		},
    		"Ingress": {
    			"Destination": {
    				"Address": ["string"],
    				"PortRanges": [{
    					"Begin": integer,
    					"End": integer
    				}]
    			},
    			"Protocol": "string",
    			"Source": {
    				"Address": ["string"],
    				"PortRanges": [{
    					"Begin": integer,
    					"End": integer
    				}]
    			}
    		}
    	}],
    	"Note": {
    		"Text": "string",
    		"UpdatedAt": "string",
    		"UpdatedBy": "string"
    	},
    	"PatchSummary": {
    		"FailedCount": number,
    		"Id": "string",
    		"InstalledCount": number,
    		"InstalledOtherCount": number,
    		"InstalledPendingReboot": number,
    		"InstalledRejectedCount": number,
    		"MissingCount": number,
    		"Operation": "string",
    		"OperationEndTime": "string",
    		"OperationStartTime": "string",
    		"RebootOption": "string"
    	},
    	"Process": {
    		"LaunchedAt": "string",
    		"Name": "string",
    		"ParentPid": number,
    		"Path": "string",
    		"Pid": number,
    		"TerminatedAt": "string"
    	},
    	"ProductArn": "string",
    	"ProductFields": {
    		"string": "string"
    	},
    	"ProductName": "string",
    	"RecordState": "string",
    	"Region": "string",
    	"RelatedFindings": [{
    		"Id": "string",
    		"ProductArn": "string"
    	}],
    	"Remediation": {
    		"Recommendation": {
    			"Text": "string",
    			"Url": "string"
    		}
    	},
    	"Resources": [{
    		"ApplicationArn": "string",
    		"ApplicationName": "string",
    		"DataClassification": {
    			"DetailedResultsLocation": "string",
    			"Result": {
    				"AdditionalOccurrences": boolean,
    				"CustomDataIdentifiers": {
    					"Detections": [{
    						"Arn": "string",
    						"Count": integer,
    						"Name": "string",
    						"Occurrences": {
    							"Cells": [{
    								"CellReference": "string",
    								"Column": integer,
    								"ColumnName": "string",
    								"Row": integer
    							}],
    							"LineRanges": [{
    								"End": integer,
    								"Start": integer,
    								"StartColumn": integer
    							}],
    							"OffsetRanges": [{
    								"End": integer,
    								"Start": integer,
    								"StartColumn": integer
    							}],
    							"Pages": [{
    								"LineRange": {
    									"End": integer,
    									"Start": integer,
    									"StartColumn": integer
    								},
    								"OffsetRange": {
    									"End": integer,
    									"Start": integer,
    									"StartColumn": integer
    								},
    								"PageNumber": integer
    							}],
    							"Records": [{
    								"JsonPath": "string",
    								"RecordIndex": integer
    							}]
    						}
    					}],
    					"TotalCount": integer
    				},
    				"MimeType": "string",
    				"SensitiveData": [{
    					"Category": "string",
    					"Detections": [{
    						"Count": integer,
    						"Occurrences": {
    							"Cells": [{
    								"CellReference": "string",
    								"Column": integer,
    								"ColumnName": "string",
    								"Row": integer
    							}],
    							"LineRanges": [{
    								"End": integer,
    								"Start": integer,
    								"StartColumn": integer
    							}],
    							"OffsetRanges": [{
    								"End": integer,
    								"Start": integer,
    								"StartColumn": integer
    							}],
    							"Pages": [{
    								"LineRange": {
    									"End": integer,
    									"Start": integer,
    									"StartColumn": integer
    								},
    								"OffsetRange": {
    									"End": integer,
    									"Start": integer,
    									"StartColumn": integer
    								},
    								"PageNumber": integer
    							}],
    							"Records": [{
    								"JsonPath": "string",
    								"RecordIndex": integer
    							}]
    						},
    						"Type": "string"
    					}],
    					"TotalCount": integer
    				}],
    				"SizeClassified": integer,
    				"Status": {
    					"Code": "string",
    					"Reason": "string"
    				}
    			}
    		},
    		"Details": {
    			"AwsAmazonMQBroker": {
    				"AutoMinorVersionUpgrade": boolean,
    				"BrokerArn": "string",
    				"BrokerId": "string",
    				"BrokerName": "string",
    				"Configuration": {
    					"Id": "string",
    					"Revision": integer
    				},
    				"DeploymentMode": "string",
    				"EncryptionOptions": {
    					"UseAwsOwnedKey": boolean
    				},
    				"EngineType": "string",
    				"EngineVersion": "string",
    				"HostInstanceType": "string",
    				"Logs": {
    					"Audit": boolean,
    					"AuditLogGroup": "string",
    					"General": boolean,
    					"GeneralLogGroup": "string"
    				},
    				"MaintenanceWindowStartTime": {
    					"DayOfWeek": "string",
    					"TimeOfDay": "string",
    					"TimeZone": "string"
    				},
    				"PubliclyAccessible": boolean,
    				"SecurityGroups": [
    					"string"
    				],
    				"StorageType": "string",
    				"SubnetIds": [
    					"string",
    					"string"
    				],
    				"Users": [{
    					"Username": "string"
    				}]
    			},
    			"AwsApiGatewayRestApi": {
    				"ApiKeySource": "string",
    				"BinaryMediaTypes": [" string"],
    				"CreatedDate": "string",
    				"Description": "string",
    				"EndpointConfiguration": {
    					"Types": ["string"]
    				},
    				"Id": "string",
    				"MinimumCompressionSize": number,
    				"Name": "string",
    				"Version": "string"
    			},
    			"AwsApiGatewayStage": {
    				"AccessLogSettings": {
    					"DestinationArn": "string",
    					"Format": "string"
    				},
    				"CacheClusterEnabled": boolean,
    				"CacheClusterSize": "string",
    				"CacheClusterStatus": "string",
    				"CanarySettings": {
    					"DeploymentId": "string",
    					"PercentTraffic": number,
    					"StageVariableOverrides": [{
    						"string": "string"
    					}],
    					"UseStageCache": boolean
    				},
    				"ClientCertificateId": "string",
    				"CreatedDate": "string",
    				"DeploymentId": "string",
    				"Description": "string",
    				"DocumentationVersion": "string",
    				"LastUpdatedDate": "string",
    				"MethodSettings": [{
    					"CacheDataEncrypted": boolean,
    					"CachingEnabled": boolean,
    					"CacheTtlInSeconds": number,
    					"DataTraceEnabled": boolean,
    					"HttpMethod": "string",
    					"LoggingLevel": "string",
    					"MetricsEnabled": boolean,
    					"RequireAuthorizationForCacheControl": boolean,
    					"ResourcePath": "string",
    					"ThrottlingBurstLimit": number,
    					"ThrottlingRateLimit": number,
    					"UnauthorizedCacheControlHeaderStrategy": "string"
    				}],
    				"StageName": "string",
    				"TracingEnabled": boolean,
    				"Variables": {
    					"string": "string"
    				},
    				"WebAclArn": "string"
    			},
    			"AwsApiGatewayV2Api": {
    				"ApiEndpoint": "string",
    				"ApiId": "string",
    				"ApiKeySelectionExpression": "string",
    				"CorsConfiguration": {
    					"AllowCredentials": boolean,
    					"AllowHeaders": ["string"],
    					"AllowMethods": ["string"],
    					"AllowOrigins": ["string"],
    					"ExposeHeaders": ["string"],
    					"MaxAge": number
    				},
    				"CreatedDate": "string",
    				"Description": "string",
    				"Name": "string",
    				"ProtocolType": "string",
    				"RouteSelectionExpression": "string",
    				"Version": "string"
    			},
    			"AwsApiGatewayV2Stage": {
    				"AccessLogSettings": {
    					"DestinationArn": "string",
    					"Format": "string"
    				},
    				"ApiGatewayManaged": boolean,
    				"AutoDeploy": boolean,
    				"ClientCertificateId": "string",
    				"CreatedDate": "string",
    				"DefaultRouteSettings": {
    					"DataTraceEnabled": boolean,
    					"DetailedMetricsEnabled": boolean,
    					"LoggingLevel": "string",
    					"ThrottlingBurstLimit": number,
    					"ThrottlingRateLimit": number
    				},
    				"DeploymentId": "string",
    				"Description": "string",
    				"LastDeploymentStatusMessage": "string",
    				"LastUpdatedDate": "string",
    				"RouteSettings": {
    					"DetailedMetricsEnabled": boolean,
    					"LoggingLevel": "string",
    					"DataTraceEnabled": boolean,
    					"ThrottlingBurstLimit": number,
    					"ThrottlingRateLimit": number
    				},
    				"StageName": "string",
    				"StageVariables": [{
    					"string": "string"
    				}]
    			},
    			"AwsAppSyncGraphQLApi": {
    				"AwsAppSyncGraphQlApi": {
    					"AdditionalAuthenticationProviders": [
    					{
    						"AuthenticationType": "string",
    						"LambdaAuthorizerConfig": {
    							"AuthorizerResultTtlInSeconds": integer,
    							"AuthorizerUri": "string"
    						}
    					},
    					{
    						"AuthenticationType": "string"
    					}
    					],
    					"ApiId": "string",
    					"Arn": "string",
    					"AuthenticationType": "string",
    					"Id": "string",
    					"LogConfig": {
    						"CloudWatchLogsRoleArn": "string",
    						"ExcludeVerboseContent": boolean,
    						"FieldLogLevel": "string"
    					},
    					"Name": "string",
    					"XrayEnabled": boolean
    				}
    			},
    			"AwsAthenaWorkGroup": {
    				"Description": "string",
    				"Name": "string",
    				"WorkgroupConfiguration": {
    					"ResultConfiguration": {
    						"EncryptionConfiguration": {
    							"EncryptionOption": "string",
    							"KmsKey": "string"
    						}
    					}
    				},
    				"State": "string"
    			},
    			"AwsAutoScalingAutoScalingGroup": {
    				"AvailabilityZones": [{
    					"Value": "string"
    				}],
    				"CreatedTime": "string",
    				"HealthCheckGracePeriod": integer,
    				"HealthCheckType": "string",
    				"LaunchConfigurationName": "string",
    				"LoadBalancerNames": ["string"],
    				"LaunchTemplate": {                            
                        "LaunchTemplateId": "string",
                        "LaunchTemplateName": "string",
                        "Version": "string"
                    },
    				"MixedInstancesPolicy": {
    					"InstancesDistribution": {
    						"OnDemandAllocationStrategy": "string",
    						"OnDemandBaseCapacity": number,
    						"OnDemandPercentageAboveBaseCapacity": number,
    						"SpotAllocationStrategy": "string",
    						"SpotInstancePools": number,
    						"SpotMaxPrice": "string"
    					},
    					"LaunchTemplate": {
    						"LaunchTemplateSpecification": {
    							"LaunchTemplateId": "string",
    							"LaunchTemplateName": "string",
    							"Version": "string"
    						},
    						"CapacityRebalance": boolean,
    						"Overrides": [{
    							"InstanceType": "string",
    							"WeightedCapacity": "string"
    						}]
    					}
    				}
    			},
    			"AwsAutoScalingLaunchConfiguration": {
    				"AssociatePublicIpAddress": boolean,
    				"BlockDeviceMappings": [{
    					"DeviceName": "string",
    					"Ebs": {
    						"DeleteOnTermination": boolean,
    						"Encrypted": boolean,
    						"Iops": number,
    						"SnapshotId": "string",
    						"VolumeSize": number,
    						"VolumeType": "string"
    					},
    					"NoDevice": boolean,
    					"VirtualName": "string"
    				}],
    				"ClassicLinkVpcId": "string",
    				"ClassicLinkVpcSecurityGroups": ["string"],
    				"CreatedTime": "string",
    				"EbsOptimized": boolean,
    				"IamInstanceProfile": "string"
    			},
    			"ImageId": "string",
    			"InstanceMonitoring": {
    				"Enabled": boolean
    			},
    			"InstanceType": "string",
    			"KernelId": "string",
    			"KeyName": "string",
    			"LaunchConfigurationName": "string",
    			"MetadataOptions": {
    				"HttpEndPoint": "string",
    				"HttpPutReponseHopLimit": number,
    				"HttpTokens": "string"
    			},
    			"PlacementTenancy": "string",
    			"RamdiskId": "string",
    			"SecurityGroups": ["string"],
    			"SpotPrice": "string",
    			"UserData": "string"
    		},
    		"AwsBackupBackupPlan": {
    			"BackupPlan": {
    				"AdvancedBackupSettings": [{
    					"BackupOptions": {
    						"WindowsVSS":"string"
    					},
    					"ResourceType":"string"
    				}],
    				"BackupPlanName": "string",
    				"BackupPlanRule": [{
    					"CompletionWindowMinutes": integer,
    					"CopyActions": [{
    						"DestinationBackupVaultArn": "string",
    						"Lifecycle": {
    							"DeleteAfterDays": integer,
    							"MoveToColdStorageAfterDays": integer
    						}
    					}],
    					"Lifecycle": {
    						"DeleteAfterDays": integer
    					},
    					"RuleName": "string",
    					"ScheduleExpression": "string",
    					"StartWindowMinutes": integer,
    					"TargetBackupVault": "string"
    				}]
    			},
    			"BackupPlanArn": "string",
    			"BackupPlanId": "string",
    			"VersionId": "string"
    	},
    		"AwsBackupBackupVault": {
    			"AccessPolicy": {
    				"Statement": [{
    					"Action": ["string"],
    					"Effect": "string",
    					"Principal": {
    						"AWS": "string"
    					},
    					"Resource": "string"
    				}],
    				"Version": "string"
    			},
    			"BackupVaultArn": "string",
    			"BackupVaultName": "string",
    			"EncryptionKeyArn": "string",
    			"Notifications": {
    				"BackupVaultEvents": ["string"],
    				"SNSTopicArn": "string"
    			}
    		},
    		"AwsBackupRecoveryPoint": {
    			"BackupSizeInBytes": integer,
    			"BackupVaultName": "string",
    			"BackupVaultArn": "string",
    			"CalculatedLifecycle": {
    				"DeleteAt": "string",
    				"MoveToColdStorageAt": "string"
    			},
    			"CompletionDate": "string",
    			"CreatedBy": {
    				"BackupPlanArn": "string",
    				"BackupPlanId": "string",
    				"BackupPlanVersion": "string",
    				"BackupRuleId": "string"
    			},
    			"CreationDate": "string",
    			"EncryptionKeyArn": "string",
    			"IamRoleArn": "string",
    			"IsEncrypted": boolean,
    			"LastRestoreTime": "string",
    			"Lifecycle": {
    				"DeleteAfterDays": integer,
    				"MoveToColdStorageAfterDays": integer
    			},
    			"RecoveryPointArn": "string",
    			"ResourceArn": "string",
    			"ResourceType": "string",
    			"SourceBackupVaultArn": "string",
    			"Status": "string",
    			"StatusMessage": "string",
    			"StorageClass": "string"
    		},
    		"AwsCertificateManagerCertificate": {
    			"CertificateAuthorityArn": "string",
    			"CreatedAt": "string",
    			"DomainName": "string",
    			"DomainValidationOptions": [{
    				"DomainName": "string",
    				"ResourceRecord": {
    					"Name": "string",
    					"Type": "string",
    					"Value": "string"
    				},
    				"ValidationDomain": "string",
    				"ValidationEmails": ["string"],
    				"ValidationMethod": "string",
    				"ValidationStatus": "string"
    			}],
    			"ExtendedKeyUsages": [{
    				"Name": "string",
    				"OId": "string"
    			}],
    			"FailureReason": "string",
    			"ImportedAt": "string",
    			"InUseBy": ["string"],
    			"IssuedAt": "string",
    			"Issuer": "string",
    			"KeyAlgorithm": "string",
    			"KeyUsages": [{
    				"Name": "string"
    			}],
    			"NotAfter": "string",
    			"NotBefore": "string",
    			"Options": {
    				"CertificateTransparencyLoggingPreference": "string"
    			},
    			"RenewalEligibility": "string",
    			"RenewalSummary": {
    				"DomainValidationOptions": [{
    					"DomainName": "string",
    					"ResourceRecord": {
    						"Name": "string",
    						"Type": "string",
    						"Value": "string"
    					},
    					"ValidationDomain": "string",
    					"ValidationEmails": ["string"],
    					"ValidationMethod": "string",
    					"ValidationStatus": "string"
    				}],
    				"RenewalStatus": "string",
    				"RenewalStatusReason": "string",
    				"UpdatedAt": "string"
    			},
    			"Serial": "string",
    			"SignatureAlgorithm": "string",
    			"Status": "string",
    			"Subject": "string",
    			"SubjectAlternativeNames": ["string"],
    			"Type": "string"
    		},
    		"AwsCloudFormationStack": {
    			"Capabilities": ["string"],
    			"CreationTime": "string",
    			"Description": "string",
    			"DisableRollback": boolean,
    			"DriftInformation": {
    				"StackDriftStatus": "string"
    			},
    			"EnableTerminationProtection": boolean,
    			"LastUpdatedTime": "string",
    			"NotificationArns": ["string"],
    			"Outputs": [{
    				"Description": "string",
    				"OutputKey": "string",
    				"OutputValue": "string"
    			}],
    			"RoleArn": "string",
    			"StackId": "string",
    			"StackName": "string",
    			"StackStatus": "string",
    			"StackStatusReason": "string",
    			"TimeoutInMinutes": number 
    		},
    		"AwsCloudFrontDistribution": {
    			"CacheBehaviors": {
    				"Items": [{
    					"ViewerProtocolPolicy": "string"
    				}]
    			},
    			"DefaultCacheBehavior": {
    				"ViewerProtocolPolicy": "string"
    			},
    			"DefaultRootObject": "string",
    			"DomainName": "string",
    			"Etag": "string",
    			"LastModifiedTime": "string",
    			"Logging": {
    				"Bucket": "string",
    				"Enabled": boolean,
    				"IncludeCookies": boolean,
    				"Prefix": "string"
    			},
    			"OriginGroups": {
    				"Items": [{
    					"FailoverCriteria": {
    						"StatusCodes": {
    							"Items": [number],
    							"Quantity": number
    						}
    					}
    				}]
    			},
    			"Origins": {
    				"Items": [{
    					"CustomOriginConfig": {
    						"HttpPort": number,
    						"HttpsPort": number,
    						"OriginKeepaliveTimeout": number,
    						"OriginProtocolPolicy": "string",
    						"OriginReadTimeout": number,
    						"OriginSslProtocols": {
    							"Items": ["string"],
    							"Quantity": number
    						} 
    					},		
    					"DomainName": "string",
    					"Id": "string",
    					"OriginPath": "string",
    					"S3OriginConfig": {
    						"OriginAccessIdentity": "string"
    					}
    				}]
    			},
    			"Status": "string",
    			"ViewerCertificate": {
    				"AcmCertificateArn": "string",
    				"Certificate": "string",
    				"CertificateSource": "string",
    				"CloudFrontDefaultCertificate": boolean,
    				"IamCertificateId": "string",
    				"MinimumProtocolVersion": "string",
    				"SslSupportMethod": "string"
    			},
    			"WebAclId": "string"
    		},
    		"AwsCloudTrailTrail": {
    			"CloudWatchLogsLogGroupArn": "string",
    			"CloudWatchLogsRoleArn": "string",
    			"HasCustomEventSelectors": boolean,
    			"HomeRegion": "string",
    			"IncludeGlobalServiceEvents": boolean,
    			"IsMultiRegionTrail": boolean,
    			"IsOrganizationTrail": boolean,
    			"KmsKeyId": "string",
    			"LogFileValidationEnabled": boolean,
    			"Name": "string",
    			"S3BucketName": "string",
    			"S3KeyPrefix": "string",
    			"SnsTopicArn": "string",
    			"SnsTopicName": "string",
    			"TrailArn": "string"
    		},
    		"AwsCloudWatchAlarm": {
    			"ActionsEnabled": boolean,
    			"AlarmActions": ["string"],
    			"AlarmArn": "string",
    			"AlarmConfigurationUpdatedTimestamp": "string",
    			"AlarmDescription": "string",
    			"AlarmName": "string",
    			"ComparisonOperator": "string",
    			"DatapointsToAlarm": number,
    			"Dimensions": [{
    				"Name": "string",
    				"Value": "string"
    			}],
    			"EvaluateLowSampleCountPercentile": "string",
    			"EvaluationPeriods": number,
    			"ExtendedStatistic": "string",
    			"InsufficientDataActions": ["string"],
    			"MetricName": "string",
    			"Namespace": "string",
    			"OkActions": ["string"],
    			"Period": number,
    			"Statistic": "string",
    			"Threshold": number,
    			"ThresholdMetricId": "string",
    			"TreatMissingData": "string",
    			"Unit": "string"
    		},
    		"AwsCodeBuildProject": {
    			"Artifacts": [{
    				"ArtifactIdentifier": "string",
    				"EncryptionDisabled": boolean,
    				"Location": "string",
    				"Name": "string",
    				"NamespaceType": "string",
    				"OverrideArtifactName": boolean,
    				"Packaging": "string",
    				"Path": "string",
    				"Type": "string"
    			}],
    			"SecondaryArtifacts": [{
                    "ArtifactIdentifier": "string",
                    "Type": "string",
                    "Location": "string",
                    "Name": "string",
                    "NamespaceType": "string",
                    "Packaging": "string",
                    "Path": "string",
                    "EncryptionDisabled": boolean,
                    "OverrideArtifactName": boolean
                }],
    			"EncryptionKey": "string",
    			"Certificate": "string",
    			"Environment": {
    				"Certificate": "string",
    				"EnvironmentVariables": [{
    					"Name": "string",
    					"Type": "string",
    					"Value": "string"
    				}],
    				"ImagePullCredentialsType": "string",
    				"PrivilegedMode": boolean,
    				"RegistryCredential": {
    					"Credential": "string",
    					"CredentialProvider": "string"
    				},
    				"Type": "string"
    			},
    			"LogsConfig": {
    				"CloudWatchLogs": {
    					"GroupName": "string",
    					"Status": "string",
    					"StreamName": "string"
    				},
    				"S3Logs": {
    					"EncryptionDisabled": boolean,
    					"Location": "string",
    					"Status": "string"
    				}
    			},
    			"Name": "string",
    			"ServiceRole": "string",
    			"Source": {
    				"Type": "string",
    				"Location": "string",
    				"GitCloneDepth": integer
    			},
    			"VpcConfig": {
    				"VpcId": "string",
    				"Subnets": ["string"],
    				"SecurityGroupIds": ["string"]
    			}
    		},
    		"AwsDmsEndpoint": {
    			"CertificateArn": "string",
    			"DatabaseName": "string",
    			"EndpointArn": "string",
    			"EndpointIdentifier": "string",
    			"EndpointType": "string", 
    			"EngineName": "string",
    			"KmsKeyId": "string",
    			"Port": integer,
    			"ServerName": "string",
    			"SslMode": "string",
    			"Username": "string"
    		},
    		"AwsDmsReplicationInstance": {
    			"AllocatedStorage": integer,
    			"AutoMinorVersionUpgrade": boolean,
    			"AvailabilityZone": "string",
    			"EngineVersion": "string",
    			"KmsKeyId": "string",
    			"MultiAZ": boolean,
    			"PreferredMaintenanceWindow": "string",
    			"PubliclyAccessible": boolean,
    			"ReplicationInstanceClass": "string",
    			"ReplicationInstanceIdentifier": "string",
    			"ReplicationSubnetGroup": {
        			"ReplicationSubnetGroupIdentifier": "string"
    			},
    			"VpcSecurityGroups": [
        			{
            			"VpcSecurityGroupId": "string"
        			}
    			]
    		},
    		"AwsDmsReplicationTask": {
    			"CdcStartPosition": "string",
    			"Id": "string",
    			"MigrationType": "string",
    			"ReplicationInstanceArn": "string",
    			"ReplicationTaskIdentifier": "string",
    			"ReplicationTaskSettings": {
    				"string": "string"
    			},
    			"SourceEndpointArn": "string",
    			"TableMappings": {
    				"string": "string"
    			},
    			"TargetEndpointArn": "string"
    		},
    		"AwsDynamoDbTable": {
    			"AttributeDefinitions": [{
    				"AttributeName": "string",
    				"AttributeType": "string"
    			}],
    			"BillingModeSummary": {
    				"BillingMode": "string",
    				"LastUpdateToPayPerRequestDateTime": "string"
    			},
    			"CreationDateTime": "string",
    			"DeletionProtectionEnabled": boolean,
    			"GlobalSecondaryIndexes": [{
    				"Backfilling": boolean,
    				"IndexArn": "string",
    				"IndexName": "string",
    				"IndexSizeBytes": number,
    				"IndexStatus": "string",
    				"ItemCount": number,
    				"KeySchema": [{
    					"AttributeName": "string",
    					"KeyType": "string"
    				}],
    				"Projection": {
    					"NonKeyAttributes": ["string"],
    					"ProjectionType": "string"
    				},
    				"ProvisionedThroughput": {
    					"LastDecreaseDateTime": "string",
    					"LastIncreaseDateTime": "string",
    					"NumberOfDecreasesToday": number,
    					"ReadCapacityUnits": number,
    					"WriteCapacityUnits": number
    				}
    			}],
    			"GlobalTableVersion": "string",
    			"ItemCount": number,
    			"KeySchema": [{
    				"AttributeName": "string",
    				"KeyType": "string"
    			}],
    			"LatestStreamArn": "string",
    			"LatestStreamLabel": "string",
    			"LocalSecondaryIndexes": [{
    				"IndexArn": "string",
    				"IndexName": "string",
    				"KeySchema": [{
    					"AttributeName": "string",
    					"KeyType": "string"
    				}],
    				"Projection": {
    					"NonKeyAttributes": ["string"],
    					"ProjectionType": "string"
    				}
    			}],
    			"ProvisionedThroughput": {
    				"LastDecreaseDateTime": "string",
    				"LastIncreaseDateTime": "string",
    				"NumberOfDecreasesToday": number,
    				"ReadCapacityUnits": number,
    				"WriteCapacityUnits": number
    			},
    			"Replicas": [{
    				"GlobalSecondaryIndexes": [{
    					"IndexName": "string",
    					"ProvisionedThroughputOverride": {
    						"ReadCapacityUnits": number
    					}
    				}],
    				"KmsMasterKeyId": "string",
    				"ProvisionedThroughputOverride": {
    					"ReadCapacityUnits": number
    				},
    				"RegionName": "string",
    				"ReplicaStatus": "string",
    				"ReplicaStatusDescription": "string"
    			}],
    			"RestoreSummary": {
    				"RestoreDateTime": "string",
    				"RestoreInProgress": boolean,
    				"SourceBackupArn": "string",
    				"SourceTableArn": "string"
    			},
    			"SseDescription": {
    				"InaccessibleEncryptionDateTime": "string",
    				"KmsMasterKeyArn": "string",
    				"SseType": "string",
    				"Status": "string"
    			},
    			"StreamSpecification": {
    				"StreamEnabled": boolean,
    				"StreamViewType": "string"
    			},
    			"TableId": "string",
    			"TableName": "string",
    			"TableSizeBytes": number,
    			"TableStatus": "string"
    		},
    		"AwsEc2ClientVpnEndpoint": {
    			"AuthenticationOptions": [
    				{
    					"MutualAuthentication": {
    						"ClientRootCertificateChainArn": "string"
    					},
    					"Type": "string"
    				}
    			],
    			"ClientCidrBlock": "string",
    			"ClientConnectOptions": {
    				"Enabled": boolean
    			},
    			"ClientLoginBannerOptions": {
    				"Enabled": boolean
    			},
    			"ClientVpnEndpointId": "string",
    			"ConnectionLogOptions": {
    				"Enabled": boolean
    			},
    			"Description": "string",
    			"DnsServer": ["string"],
    			"ServerCertificateArn": "string",
    			"SecurityGroupIdSet": [
    				"string"
    			],
    			"SelfServicePortalUrl": "string",
    			"SessionTimeoutHours": "integer",
    			"SplitTunnel": boolean,
    			"TransportProtocol": "string",
    			"VpcId": "string",
    			"VpnPort": integer
    		},
    		"AwsEc2Eip": {
    			"AllocationId": "string",
    			"AssociationId": "string",
    			"Domain": "string",
    			"InstanceId": "string",
    			"NetworkBorderGroup": "string",
    			"NetworkInterfaceId": "string",
    			"NetworkInterfaceOwnerId": "string",
    			"PrivateIpAddress": "string",
    			"PublicIp": "string",
    			"PublicIpv4Pool": "string"
    		},
    		"AwsEc2Instance": {
    			"IamInstanceProfileArn": "string",
    			"ImageId": "string",
    			"IpV4Addresses": ["string"],
    			"IpV6Addresses": ["string"],
    			"KeyName": "string",
    			"LaunchedAt": "string",
    			"MetadataOptions": {
    				"HttpEndpoint": "string",
    				"HttpProtocolIpv6": "string",
    				"HttpPutResponseHopLimit": number,
    				"HttpTokens": "string",
    				"InstanceMetadataTags": "string"
    			},
    			"Monitoring": {
    				"State": "string"
    			},
    			"NetworkInterfaces": [{                
    				"NetworkInterfaceId": "string"
    			}],
    			"SubnetId": "string",
    			"Type": "string",    			
    			"VirtualizationType": "string",
    			"VpcId": "string"
    		},   
    		"AwsEc2LaunchTemplate": {
    			"DefaultVersionNumber": "string",
    			"ElasticGpuSpecifications": ["string"],
    			"ElasticInferenceAccelerators": ["string"],
    			"Id": "string",
    			"ImageId": "string",
    			"LatestVersionNumber": "string",
    			"LaunchTemplateData": {
    				"BlockDeviceMappings": [{
    					"DeviceName": "string",
    					"Ebs": {
    						"DeleteonTermination": boolean,
    						"Encrypted": boolean,
    						"SnapshotId": "string",
    						"VolumeSize": number,
    						"VolumeType": "string"
    					}
    				}],
    				"MetadataOptions": {
    					"HttpTokens": "string",
    					"HttpPutResponseHopLimit" : number
    				},
    				"Monitoring": {
    					"Enabled": boolean
    				},
    				"NetworkInterfaces": [{
    					"AssociatePublicIpAddress" : boolean
    				}]
    			},
    			"LaunchTemplateName": "string",
    			"LicenseSpecifications": ["string"],
    			"SecurityGroupIds": ["string"],
    			"SecurityGroups": ["string"],
    			"TagSpecifications": ["string"]
    		},
    		"AwsEc2NetworkAcl": {
    			"Associations": [{
    				"NetworkAclAssociationId": "string",
    				"NetworkAclId": "string",
    				"SubnetId": "string"
    			}],
    			"Entries": [{
    				"CidrBlock": "string",
    				"Egress": boolean,
    				"IcmpTypeCode": {
    					"Code": number,
    					"Type": number
    				},
    				"Ipv6CidrBlock": "string",
    				"PortRange": {
    					"From": number,
    					"To": number
    				},
    				"Protocol": "string",
    				"RuleAction": "string",
    				"RuleNumber": number
    			}],
    			"IsDefault": boolean,
    			"NetworkAclId": "string",
    			"OwnerId": "string",
    			"VpcId": "string"
    		},
    		"AwsEc2NetworkInterface": {
    			"Attachment": {
    				"AttachmentId": "string",
    				"AttachTime": "string",
    				"DeleteOnTermination": boolean,
    				"DeviceIndex": number,
    				"InstanceId": "string",
    				"InstanceOwnerId": "string",
    				"Status": "string"
    			},
    			"Ipv6Addresses": [{
    				"Ipv6Address": "string"
    			}],
    			"NetworkInterfaceId": "string",
    			"PrivateIpAddresses": [{
    				"PrivateDnsName": "string",
    				"PrivateIpAddress": "string"
    			}],
    			"PublicDnsName": "string",
    			"PublicIp": "string",
    			"SecurityGroups": [{
    				"GroupId": "string",
    				"GroupName": "string"
    			}],
    			"SourceDestCheck": boolean
    		},
    		"AwsEc2RouteTable": {
    			"AssociationSet": [{
    				"AssociationState": {
    					"State": "string"
    				},
    				"Main": boolean,
    				"RouteTableAssociationId": "string",
    				"RouteTableId": "string"
    			}],
    			"PropogatingVgwSet": [],
    			"RouteTableId": "string",
    			"RouteSet": [
    				{
    					"DestinationCidrBlock": "string",
    					"GatewayId": "string",
    					"Origin": "string",
    					"State": "string"
    				},
    				{
    					"DestinationCidrBlock": "string",
    					"GatewayId": "string",
    					"Origin": "string",
    					"State": "string"
    				}
    			],
    			"VpcId": "string"
    		},
    		"AwsEc2SecurityGroup": {
    			"GroupId": "string",
    			"GroupName": "string",
    			"IpPermissions": [{
    				"FromPort": number,
    				"IpProtocol": "string",
    				"IpRanges": [{
    					"CidrIp": "string"
    				}],
    				"Ipv6Ranges": [{
    					"CidrIpv6": "string"
    				}],
    				"PrefixListIds": [{
    					"PrefixListId": "string"
    				}],
    				"ToPort": number,
    				"UserIdGroupPairs": [{
    					"GroupId": "string",
    					"GroupName": "string",
    					"PeeringStatus": "string",
    					"UserId": "string",
    					"VpcId": "string",
    					"VpcPeeringConnectionId": "string"
    				}]
    			}],
    			"IpPermissionsEgress": [{
    				"FromPort": number,
    				"IpProtocol": "string",
    				"IpRanges": [{
    					"CidrIp": "string"
    				}],
    				"Ipv6Ranges": [{
    					"CidrIpv6": "string"
    				}],
    				"PrefixListIds": [{
    					"PrefixListId": "string"
    				}],
    				"ToPort": number,
    				"UserIdGroupPairs": [{
    					"GroupId": "string",
    					"GroupName": "string",
    					"PeeringStatus": "string",
    					"UserId": "string",
    					"VpcId": "string",
    					"VpcPeeringConnectionId": "string"
    				}]
    			}],
    			"OwnerId": "string",
    			"VpcId": "string"
    		},
    		"AwsEc2Subnet": {
    			"AssignIpv6AddressOnCreation": boolean,
    			"AvailabilityZone": "string",
    			"AvailabilityZoneId": "string",
    			"AvailableIpAddressCount": number,
    			"CidrBlock": "string",
    			"DefaultForAz": boolean,
    			"Ipv6CidrBlockAssociationSet": [{
    				"AssociationId": "string",
    				"Ipv6CidrBlock": "string",
    				"CidrBlockState": "string"
    			}],
    			"MapPublicIpOnLaunch": boolean,
    			"OwnerId": "string",
    			"State": "string",
    			"SubnetArn": "string",
    			"SubnetId": "string",
    			"VpcId": "string"
    		},
    		"AwsEc2TransitGateway": {
    			"AmazonSideAsn": number,
    			"AssociationDefaultRouteTableId": "string",
    			"AutoAcceptSharedAttachments": "string",
    			"DefaultRouteTableAssociation": "string",
    			"DefaultRouteTablePropagation": "string",
    			"Description": "string",
    			"DnsSupport": "string",
    			"Id": "string",
    			"MulticastSupport": "string",
    			"PropagationDefaultRouteTableId": "string",
    			"TransitGatewayCidrBlocks": ["string"],
    			"VpnEcmpSupport": "string"
    		},
    		"AwsEc2Volume": {
    			"Attachments": [{
    				"AttachTime": "string",
    				"DeleteOnTermination": boolean,
    				"InstanceId": "string",
    				"Status": "string"
    			}],
    			"CreateTime": "string",
    			"DeviceName": "string",
    			"Encrypted": boolean,
    			"KmsKeyId": "string",
    			"Size": number,
    			"SnapshotId": "string",
    			"Status": "string",
    			"VolumeId": "string",
    			"VolumeScanStatus": "string",
    			"VolumeType": "string"
    		},
    		"AwsEc2Vpc": {
    			"CidrBlockAssociationSet": [{
    				"AssociationId": "string",
    				"CidrBlock": "string",
    				"CidrBlockState": "string"
    			}],
    			"DhcpOptionsId": "string",
    			"Ipv6CidrBlockAssociationSet": [{
    				"AssociationId": "string",
    				"CidrBlockState": "string",
    				"Ipv6CidrBlock": "string"
    			}],
    			"State": "string"
    		},
    		"AwsEc2VpcEndpointService": {
    			"AcceptanceRequired": boolean,
    			"AvailabilityZones": ["string"],
    			"BaseEndpointDnsNames": ["string"],
    			"ManagesVpcEndpoints": boolean,
    			"GatewayLoadBalancerArns": ["string"],
    			"NetworkLoadBalancerArns": ["string"],
    			"PrivateDnsName": "string",
    			"ServiceId": "string",
    			"ServiceName": "string",
    			"ServiceState": "string",
    			"ServiceType": [{
    				"ServiceType": "string"
    			}]
    		},
    		"AwsEc2VpcPeeringConnection": {
    			"AccepterVpcInfo": {
    				"CidrBlock": "string",
    				"CidrBlockSet": [{
    					"CidrBlock": "string"
    				}],
    				"Ipv6CidrBlockSet": [{
    					"Ipv6CidrBlock": "string"
    				}],
    				"OwnerId": "string",
    				"PeeringOptions": {
    					"AllowDnsResolutionFromRemoteVpc": boolean,
    					"AllowEgressFromLocalClassicLinkToRemoteVpc": boolean,
    					"AllowEgressFromLocalVpcToRemoteClassicLink": boolean
    				},
    				"Region": "string",
    				"VpcId": "string"
    			},
    			"ExpirationTime": "string",
    			"RequesterVpcInfo": {
    				"CidrBlock": "string",
    				"CidrBlockSet": [{
    					"CidrBlock": "string"
    				}],
    				"Ipv6CidrBlockSet": [{
    					"Ipv6CidrBlock": "string"
    				}],
    				"OwnerId": "string",
    				"PeeringOptions": {
    					"AllowDnsResolutionFromRemoteVpc": boolean,
    					"AllowEgressFromLocalClassicLinkToRemoteVpc": boolean,
    					"AllowEgressFromLocalVpcToRemoteClassicLink": boolean
    				},
    				"Region": "string",
    				"VpcId": "string"
    			},
    			"Status": {
    				"Code": "string",
    				"Message": "string"
    			},
    			"VpcPeeringConnectionId": "string"
    		},
    		"AwsEcrContainerImage": {
    			"Architecture": "string",
    			"ImageDigest": "string",
    			"ImagePublishedAt": "string",
    			"ImageTags": ["string"],
    			"RegistryId": "string",
    			"RepositoryName": "string"
    		},
    		"AwsEcrRepository": {
    			"Arn": "string",
    			"ImageScanningConfiguration": {
    				"ScanOnPush": boolean
    			},
    			"ImageTagMutability": "string",
    			"LifecyclePolicy": {
    				"LifecyclePolicyText": "string",
    				"RegistryId": "string"
    			},
    			"RepositoryName": "string",
    			"RepositoryPolicyText": "string"
    		},
    		"AwsEcsCluster": {
    			"ActiveServicesCount": number,
    			"CapacityProviders": ["string"],
    			"ClusterArn": "string",
    			"ClusterName": "string",
    			"ClusterSettings": [{
    				"Name": "string",
    				"Value": "string"
    			}],
    			"Configuration": {
    				"ExecuteCommandConfiguration": {
    					"KmsKeyId": "string",
    					"LogConfiguration": {
    						"CloudWatchEncryptionEnabled": boolean,
    						"CloudWatchLogGroupName": "string",
    						"S3BucketName": "string",
    						"S3EncryptionEnabled": boolean,
    						"S3KeyPrefix": "string"
    					},
    					"Logging": "string"
    				}
    			},
    			"DefaultCapacityProviderStrategy": [{
    				"Base": number,
    				"CapacityProvider": "string",
    				"Weight": number
    			}],
    			"RegisteredContainerInstancesCount": number,
    			"RunningTasksCount": number,
    			"Status": "string"
    		},
    		"AwsEcsContainer": {
    			"Image": "string",
    			"MountPoints": [{
    				"ContainerPath": "string",
    				"SourceVolume": "string"
    			}],
    			"Name": "string",
    			"Privileged": boolean
    		},
    		"AwsEcsService": {
    			"CapacityProviderStrategy": [{
    				"Base": number,
    				"CapacityProvider": "string",
    				"Weight": number
    			}],
    			"Cluster": "string",
    			"DeploymentConfiguration": {
    				"DeploymentCircuitBreaker": {
    					"Enable": boolean,
    					"Rollback": boolean
    				},
    				"MaximumPercent": number,
    				"MinimumHealthyPercent": number
    			},
    			"DeploymentController": {
    				"Type": "string"
    			},
    			"DesiredCount": number,
    			"EnableEcsManagedTags": boolean,
    			"EnableExecuteCommand": boolean,
    			"HealthCheckGracePeriodSeconds": number,
    			"LaunchType": "string",
    			"LoadBalancers": [{
    				"ContainerName": "string",
    				"ContainerPort": number,
    				"LoadBalancerName": "string",
    				"TargetGroupArn": "string"
    			}],
    			"Name": "string",
    			"NetworkConfiguration": {
    				"AwsVpcConfiguration": {
    					"AssignPublicIp": "string",
    					"SecurityGroups": ["string"],
    					"Subnets": ["string"]
    				}
    			},
    			"PlacementConstraints": [{
    				"Expression": "string",
    				"Type": "string"
    			}],
    			"PlacementStrategies": [{
    				"Field": "string",
    				"Type": "string"
    			}],
    			"PlatformVersion": "string",
    			"PropagateTags": "string",
    			"Role": "string",
    			"SchedulingStrategy": "string",
    			"ServiceArn": "string",
    			"ServiceName": "string",
    			"ServiceRegistries": [{
    				"ContainerName": "string",
    				"ContainerPort": number,
    				"Port": number,
    				"RegistryArn": "string"
    			}],
    			"TaskDefinition": "string"
    		},
    		"AwsEcsTask": {
    			"CreatedAt": "string",
    			"ClusterArn": "string",
    			"Group": "string",
    			"StartedAt": "string",
    			"StartedBy": "string",
    			"TaskDefinitionArn": "string",
    			"Version": number,
    			"Volumes": [{
    				"Name": "string",
    				"Host": {
    					"SourcePath": "string"
    				}
    			}],
    			"Containers": [{
    				"Image": "string",
    				"MountPoints": [{
    					"ContainerPath": "string",
    					"SourceVolume": "string"
    				}],
    				"Name": "string",
    				"Privileged": boolean
    			}]
    		},
    		"AwsEcsTaskDefinition": {
    			"ContainerDefinitions": [{
    				"Command": ["string"],
    				"Cpu": number,
    				"DependsOn": [{
    					"Condition": "string",
    					"ContainerName": "string"
    				}],
    				"DisableNetworking": boolean,
    				"DnsSearchDomains": ["string"],
    				"DnsServers": ["string"],
    				"DockerLabels": {
    					"string": "string"
    				},
    				"DockerSecurityOptions": ["string"],
    				"EntryPoint": ["string"],
    				"Environment": [{
    					"Name": "string",
    					"Value": "string"
    				}],
    				"EnvironmentFiles": [{
    					"Type": "string",
    					"Value": "string"
    				}],
    				"Essential": boolean,
    				"ExtraHosts": [{
    					"Hostname": "string",
    					"IpAddress": "string"
    				}],
    				"FirelensConfiguration": {
    					"Options": {
    						"string": "string"
    					},
    					"Type": "string"
    				},
    				"HealthCheck": {
    					"Command": ["string"],
    					"Interval": number,
    					"Retries": number,
    					"StartPeriod": number,
    					"Timeout": number
    				},
    				"Hostname": "string",
    				"Image": "string",
    				"Interactive": boolean,
    				"Links": ["string"],
    				"LinuxParameters": {
    					"Capabilities": {
    						"Add": ["string"],
    						"Drop": ["string"]
    					},
    					"Devices": [{
    						"ContainerPath": "string",
    						"HostPath": "string",
    						"Permissions": ["string"]
    					}],
    					"InitProcessEnabled": boolean,
    					"MaxSwap": number,
    					"SharedMemorySize": number,
    					"Swappiness": number,
    					"Tmpfs": [{
    						"ContainerPath": "string",
    						"MountOptions": ["string"],
    						"Size": number
    					}]
    				},
    				"LogConfiguration": {
    					"LogDriver": "string",
    					"Options": {
    						"string": "string"
    					},
    					"SecretOptions": [{
    						"Name": "string",
    						"ValueFrom": "string"
    					}]
    				},
    				"Memory": number,
    				"MemoryReservation": number,
    				"MountPoints": [{
    					"ContainerPath": "string",
    					"ReadOnly": boolean,
    					"SourceVolume": "string"
    				}],
    				"Name": "string",
    				"PortMappings": [{
    					"ContainerPort": number,
    					"HostPort": number,
    					"Protocol": "string"
    				}],
    				"Privileged": boolean,
    				"PseudoTerminal": boolean,
    				"ReadonlyRootFilesystem": boolean,
    				"RepositoryCredentials": {
    					"CredentialsParameter": "string"
    				},
    				"ResourceRequirements": [{
    					"Type": "string",
    					"Value": "string"
    				}],
    				"Secrets": [{
    					"Name": "string",
    					"ValueFrom": "string"
    				}],
    				"StartTimeout": number,
    				"StopTimeout": number,
    				"SystemControls": [{
    					"Namespace": "string",
    					"Value": "string"
    				}],
    				"Ulimits": [{
    					"HardLimit": number,
    					"Name": "string",
    					"SoftLimit": number
    				}],
    				"User": "string",
    				"VolumesFrom": [{
    					"ReadOnly": boolean,
    					"SourceContainer": "string"
    				}],
    				"WorkingDirectory": "string"
    			}],
    			"Cpu": "string",
    			"ExecutionRoleArn": "string",
    			"Family": "string",
    			"InferenceAccelerators": [{
    				"DeviceName": "string",
    				"DeviceType": "string"
    			}],
    			"IpcMode": "string",
    			"Memory": "string",
    			"NetworkMode": "string",
    			"PidMode": "string",
    			"PlacementConstraints": [{
    				"Expression": "string",
    				"Type": "string"
    			}],
    			"ProxyConfiguration": {
    				"ContainerName": "string",
    				"ProxyConfigurationProperties": [{
    					"Name": "string",
    					"Value": "string"
    				}],
    				"Type": "string"
    			},
    			"RequiresCompatibilities": ["string"],
    			"Status": "string",
    			"TaskRoleArn": "string",
    			"Volumes": [{
    				"DockerVolumeConfiguration": {
    					"Autoprovision": boolean,
    					"Driver": "string",
    					"DriverOpts": {
    						"string": "string"
    					},
    					"Labels": {
    						"string": "string"
    					},
    					"Scope": "string"
    				},
    				"EfsVolumeConfiguration": {
    					"AuthorizationConfig": {
    						"AccessPointId": "string",
    						"Iam": "string"
    					},
    					"FilesystemId": "string",
    					"RootDirectory": "string",
    					"TransitEncryption": "string",
    					"TransitEncryptionPort": number
    				},
    				"Host": {
    					"SourcePath": "string"
    				},
    				"Name": "string"
    			}]
    		},
    		"AwsEfsAccessPoint": {
    			"AccessPointId": "string",
    			"Arn": "string",
    			"ClientToken": "string",
    			"FileSystemId": "string",
    			"PosixUser": {
    				"Gid": "string",
    				"SecondaryGids": ["string"],
    				"Uid": "string"
    			},
    			"RootDirectory": {
    				"CreationInfo": {
    					"OwnerGid": "string",
    					"OwnerUid": "string",
    					"Permissions": "string"
    				},
    				"Path": "string"
    			}
    		},
    		"AwsEksCluster": {
    			"Arn": "string",
    			"CertificateAuthorityData": "string",
    			"ClusterStatus": "string",
    			"Endpoint": "string",
    			"Logging": {
    				"ClusterLogging": [{
    					"Enabled": boolean,
    					"Types": ["string"]
    				}]
    			},
    			"Name": "string",
    			"ResourcesVpcConfig": {
    				"EndpointPublicAccess": boolean,
    				"SecurityGroupIds": ["string"],
    				"SubnetIds": ["string"]
    			},
    			"RoleArn": "string",
    			"Version": "string"
    		},
    		"AwsElasticBeanstalkEnvironment": {
    			"ApplicationName": "string",
    			"Cname": "string",
    			"DateCreated": "string",
    			"DateUpdated": "string",
    			"Description": "string",
    			"EndpointUrl": "string",
    			"EnvironmentArn": "string",
    			"EnvironmentId": "string",
    			"EnvironmentLinks": [{
    				"EnvironmentName": "string",
    				"LinkName": "string"
    			}],
    			"EnvironmentName": "string",
    			"OptionSettings": [{
    				"Namespace": "string",
    				"OptionName": "string",
    				"ResourceName": "string",
    				"Value": "string"
    			}],
    			"PlatformArn": "string",
    			"SolutionStackName": "string",
    			"Status": "string",
    			"Tier": {
    				"Name": "string",
    				"Type": "string",
    				"Version": "string"
    			},
    			"VersionLabel": "string"
    		},
    		"AwsElasticSearchDomain": {
    			"AccessPolicies": "string",
    			"DomainStatus": {
    				"DomainId": "string",
    				"DomainName": "string",
    				"Endpoint": "string",
    				"Endpoints": {
    					"string": "string"
    				}
    			},
    			"DomainEndpointOptions": {
    				"EnforceHTTPS": boolean,
    				"TLSSecurityPolicy": "string"
    			},
    			"ElasticsearchClusterConfig": {
    				"DedicatedMasterCount": number,
    				"DedicatedMasterEnabled": boolean,
    				"DedicatedMasterType": "string",
    				"InstanceCount": number,
    				"InstanceType": "string",
    				"ZoneAwarenessConfig": {
    					"AvailabilityZoneCount": number
    				},
    				"ZoneAwarenessEnabled": boolean
    			},
    			"ElasticsearchVersion": "string",
    			"EncryptionAtRestOptions": {
    				"Enabled": boolean,
    				"KmsKeyId": "string"
    			},
    			"LogPublishingOptions": {
    				"AuditLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				},
    				"IndexSlowLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				},
    				"SearchSlowLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				}
    			},
    			"NodeToNodeEncryptionOptions": {
    				"Enabled": boolean
    			},
    			"ServiceSoftwareOptions": {
    				"AutomatedUpdateDate": "string",
    				"Cancellable": boolean,
    				"CurrentVersion": "string",
    				"Description": "string",
    				"NewVersion": "string",
    				"UpdateAvailable": boolean,
    				"UpdateStatus": "string"
    			},
    			"VPCOptions": {
    				"AvailabilityZones": [
    					"string"
    				],
    				"SecurityGroupIds": [
    					"string"
    				],
    				"SubnetIds": [
    					"string"
    				],
    				"VPCId": "string"
    			}
    		},
    		"AwsElbLoadBalancer": {
    			"AvailabilityZones": ["string"],
    			"BackendServerDescriptions": [{
    				"InstancePort": number,
    				"PolicyNames": ["string"]
    			}],
    			"CanonicalHostedZoneName": "string",
    			"CanonicalHostedZoneNameID": "string",
    			"CreatedTime": "string",
    			"DnsName": "string",
    			"HealthCheck": {
    				"HealthyThreshold": number,
    				"Interval": number,
    				"Target": "string",
    				"Timeout": number,
    				"UnhealthyThreshold": number
    			},
    			"Instances": [{
    				"InstanceId": "string"
    			}],
    			"ListenerDescriptions": [{
    				"Listener": {
    					"InstancePort": number,
    					"InstanceProtocol": "string",
    					"LoadBalancerPort": number,
    					"Protocol": "string",
    					"SslCertificateId": "string"
    				},
    				"PolicyNames": ["string"]
    			}],
    			"LoadBalancerAttributes": {
    				"AccessLog": {
    					"EmitInterval": number,
    					"Enabled": boolean,
    					"S3BucketName": "string",
    					"S3BucketPrefix": "string"
    				},
    				"ConnectionDraining": {
    					"Enabled": boolean,
    					"Timeout": number
    				},
    				"ConnectionSettings": {
    					"IdleTimeout": number
    				},
    				"CrossZoneLoadBalancing": {
    					"Enabled": boolean
    				},
    				"AdditionalAttributes": [{
                        "Key": "string",
                        "Value": "string"
                    }]
    			},
    			"LoadBalancerName": "string",
    			"Policies": {
    				"AppCookieStickinessPolicies": [{
    					"CookieName": "string",
    					"PolicyName": "string"
    				}],
    				"LbCookieStickinessPolicies": [{
    					"CookieExpirationPeriod": number,
    					"PolicyName": "string"
    				}],
    				"OtherPolicies": ["string"]
    			},
    			"Scheme": "string",
    			"SecurityGroups": ["string"],
    			"SourceSecurityGroup": {
    				"GroupName": "string",
    				"OwnerAlias": "string"
    			},
    			"Subnets": ["string"],
    			"VpcId": "string"
    		},
    		"AwsElbv2LoadBalancer": {
    			"AvailabilityZones": {
    				"SubnetId": "string",
    				"ZoneName": "string"
    			},
    			"CanonicalHostedZoneId": "string",
    			"CreatedTime": "string",
    			"DNSName": "string",
    			"IpAddressType": "string",
    			"LoadBalancerAttributes": [{
    				"Key": "string",
    				"Value": "string"
    			}],
    			"Scheme": "string",
    			"SecurityGroups": ["string"],
    			"State": {
    				"Code": "string",
    				"Reason": "string"
    			},
    			"Type": "string",
    			"VpcId": "string"
    		},
    		"AwsEventSchemasRegistry": {
    			"Description": "string",
    			"RegistryArn": "string",
    			"RegistryName": "string"
    		},
    		"AwsEventsEndpoint": {
    			"Arn": "string",
    			"Description": "string",
    			"EndpointId": "string",
    			"EndpointUrl": "string",
    			"EventBuses": [
        			{
            			"EventBusArn": "string"
        			},
        			{
            			"EventBusArn": "string"
        			}
    			],
    			"Name": "string",
    			"ReplicationConfig": {
        			"State": "string"
    			},
    			"RoleArn": "string",
    			"RoutingConfig": {
        			"FailoverConfig": {
            			"Primary": {
                			"HealthCheck": "string"
            			},
            			"Secondary": {
                			"Route": "string"
            			}
        			}
    			},
    			"State": "string"
    		},
    		"AwsEventsEventBus": {
    			"Arn": "string",
    			"Name": "string",
    			"Policy": "string"
    		},
    		"AwsGuardDutyDetector": {
    			"FindingPublishingFrequency": "string",
    			"ServiceRole": "string",
    			"Status": "string",
    			"DataSources": {
    				"CloudTrail": {
    					"Status": "string"
    				},
    				"DnsLogs": {
    					"Status": "string"
    				},
    				"FlowLogs": {
    					"Status": "string"
    				},
    				"S3Logs": {
    					"Status": "string"
    				},
    				"Kubernetes": {
    					"AuditLogs": {
    						"Status": "string"
    					}
    				},
    				"MalwareProtection": {
    					"ScanEc2InstanceWithFindings": {
    						"EbsVolumes": {
    							"Status": "string"
    						}
    					},
    					"ServiceRole": "string"
    				}
    			}
    		},
    		"AwsIamAccessKey": {
    			"AccessKeyId": "string",
    			"AccountId": "string",
    			"CreatedAt": "string",
    			"PrincipalId": "string",
    			"PrincipalName": "string",
    			"PrincipalType": "string",
    			"SessionContext": {
    				"Attributes": {
    					"CreationDate": "string",
    					"MfaAuthenticated": boolean
    				},
    				"SessionIssuer": {
    					"AccountId": "string",
    					"Arn": "string",
    					"PrincipalId": "string",
    					"Type": "string",
    					"UserName": "string"
    				}
    			},
    			"Status": "string"
    		},
    		"AwsIamGroup": {
    			"AttachedManagedPolicies": [{
    				"PolicyArn": "string",
    				"PolicyName": "string"
    			}],
    			"CreateDate": "string",
    			"GroupId": "string",
    			"GroupName": "string",
    			"GroupPolicyList": [{
    				"PolicyName": "string"
    			}],
    			"Path": "string"
    		},
    		"AwsIamPolicy": {
    			"AttachmentCount": number,
    			"CreateDate": "string",
    			"DefaultVersionId": "string",
    			"Description": "string",
    			"IsAttachable": boolean,
    			"Path": "string",
    			"PermissionsBoundaryUsageCount": number,
    			"PolicyId": "string",
    			"PolicyName": "string",
    			"PolicyVersionList": [{
    				"CreateDate": "string",
    				"IsDefaultVersion": boolean,
    				"VersionId": "string"
    			}],
    			"UpdateDate": "string"
    		},
    		"AwsIamRole": {
    			"AssumeRolePolicyDocument": "string",
    			"AttachedManagedPolicies": [{
    				"PolicyArn": "string",
    				"PolicyName": "string"
    			}],
    			"CreateDate": "string",
    			"InstanceProfileList": [{
    				"Arn": "string",
    				"CreateDate": "string",
    				"InstanceProfileId": "string",
    				"InstanceProfileName": "string",
    				"Path": "string",
    				"Roles": [{
    					"Arn": "string",
    					"AssumeRolePolicyDocument": "string",
    					"CreateDate": "string",
    					"Path": "string",
    					"RoleId": "string",
    					"RoleName": "string"
    				}]
    			}],
    			"MaxSessionDuration": number,
    			"Path": "string",
    			"PermissionsBoundary": {
    				"PermissionsBoundaryArn": "string",
    				"PermissionsBoundaryType": "string"
    			},
    			"RoleId": "string",
    			"RoleName": "string",
    			"RolePolicyList": [{
    				"PolicyName": "string"
    			}]
    		},
    		"AwsIamUser": {
    			"AttachedManagedPolicies": [{
    				"PolicyArn": "string",
    				"PolicyName": "string"
    			}],
    			"CreateDate": "string",
    			"GroupList": ["string"],
    			"Path": "string",
    			"PermissionsBoundary": {
    				"PermissionsBoundaryArn": "string",
    				"PermissionsBoundaryType": "string"
    			},
    			"UserId": "string",
    			"UserName": "string",
    			"UserPolicyList": [{
    				"PolicyName": "string"
    			}]
    		},
    		"AwsKinesisStream": {
    			"Arn": "string",
    			"Name": "string",
    			"RetentionPeriodHours": number,
    			"ShardCount": number,
    			"StreamEncryption": {
    				"EncryptionType": "string",
    				"KeyId": "string"
    			}
    		},
    		"AwsKmsKey": {
    			"AWSAccountId": "string",
    			"CreationDate": "string",
    			"Description": "string",
    			"KeyId": "string",
    			"KeyManager": "string",
    			"KeyRotationStatus": boolean,
    			"KeyState": "string",
    			"Origin": "string"
    		},
    		"AwsLambdaFunction": {
    			"Architectures": [
    				"string"
    			],
    			"Code": {
    				"S3Bucket": "string",
    				"S3Key": "string",
    				"S3ObjectVersion": "string",
    				"ZipFile": "string"
    			},
    			"CodeSha256": "string",
    			"DeadLetterConfig": {
    				"TargetArn": "string"
    			},
    			"Environment": {
    				"Variables": {
    					"Stage": "string"
    				},
    				"Error": {
    					"ErrorCode": "string",
    					"Message": "string"
    				}
    			},
    			"FunctionName": "string",
    			"Handler": "string",
    			"KmsKeyArn": "string",
    			"LastModified": "string",
    			"Layers": {
    				"Arn": "string",
    				"CodeSize": number
    			},
    			"PackageType": "string",
    			"RevisionId": "string",
    			"Role": "string",
    			"Runtime": "string",
    			"Timeout": integer,
    			"TracingConfig": {
    				"Mode": "string"
    			},
    			"Version": "string",
    			"VpcConfig": {
    				"SecurityGroupIds": ["string"],
    				"SubnetIds": ["string"]
    			},
    			"MasterArn": "string",
    			"MemorySize": number
    		},
    		"AwsLambdaLayerVersion": {
    			"CompatibleRuntimes": [
    				"string"
    			],
    			"CreatedDate": "string",
    			"Version": number
    		},
    		"AwsMskCluster": {
    			"ClusterInfo": {
    				"ClientAuthentication": {
    					"Sasl": {
    						"Scram": {
    							"Enabled": boolean
    						},
    						"Iam": {
    							"Enabled": boolean
    						}
    					},
    					"Tls": {
    						"CertificateAuthorityArnList": [],
    						"Enabled": boolean
    					},
    					"Unauthenticated": {
    						"Enabled": boolean
    					}
    				},
    				"ClusterName": "string",
    				"CurrentVersion": "string",
    				"EncryptionInfo": {
    					"EncryptionAtRest": {
    						"DataVolumeKMSKeyId": "string"
    					},
    					"EncryptionInTransit": {
    						"ClientBroker": "string",
    						"InCluster": boolean
    					}
    				},
    				"EnhancedMonitoring": "string",
    				"NumberOfBrokerNodes": integer
    			}
    		},
    		"AwsNetworkFirewallFirewall": {
    			"DeleteProtection": boolean,
    			"Description": "string",
    			"FirewallArn": "string",
    			"FirewallId": "string",
    			"FirewallName": "string",
    			"FirewallPolicyArn": "string",
    			"FirewallPolicyChangeProtection": boolean,
    			"SubnetChangeProtection": boolean,
    			"SubnetMappings": [{
    				"SubnetId": "string"
    			}],
    			"VpcId": "string"
    		},
    		"AwsNetworkFirewallFirewallPolicy": {
    			"Description": "string",
    			"FirewallPolicy": {
    				"StatefulRuleGroupReferences": [{
    					"ResourceArn": "string"
    				}],
    				"StatelessCustomActions": [{
    					"ActionDefinition": {
    						"PublishMetricAction": {
    							"Dimensions": [{
    								"Value": "string"
    							}]
    						}
    					},
    					"ActionName": "string"
    				}],
    				"StatelessDefaultActions": ["string"],
    				"StatelessFragmentDefaultActions": ["string"],
    				"StatelessRuleGroupReferences": [{
    					"Priority": number,
    					"ResourceArn": "string"
    				}]
    			},
    			"FirewallPolicyArn": "string",
    			"FirewallPolicyId": "string",
    			"FirewallPolicyName": "string"
    		},
    		"AwsNetworkFirewallRuleGroup": {
    			"Capacity": number,
    			"Description": "string",
    			"RuleGroup": {
    				"RulesSource": {
    					"RulesSourceList": {
    						"GeneratedRulesType": "string",
    						"Targets": ["string"],
    						"TargetTypes": ["string"]
    					},
    					"RulesString": "string",
    					"StatefulRules": [{
    						"Action": "string",
    						"Header": {
    							"Destination": "string",
    							"DestinationPort": "string",
    							"Direction": "string",
    							"Protocol": "string",
    							"Source": "string",
    							"SourcePort": "string"
    						},
    						"RuleOptions": [{
    							"Keyword": "string",
    							"Settings": ["string"]
    						}]
    					}],
    					"StatelessRulesAndCustomActions": {
    						"CustomActions": [{
    							"ActionDefinition": {
    								"PublishMetricAction": {
    									"Dimensions": [{
    										"Value": "string"
    									}]
    								}
    							},
    							"ActionName": "string"
    						}],
    						"StatelessRules": [{
    							"Priority": number,
    							"RuleDefinition": {
    								"Actions": ["string"],
    								"MatchAttributes": {
    									"DestinationPorts": [{
    										"FromPort": number,
    										"ToPort": number
    									}],
    									"Destinations": [{
    										"AddressDefinition": "string"
    									}],
    									"Protocols": [number],
    									"SourcePorts": [{
    										"FromPort": number,
    										"ToPort": number
    									}],
    									"Sources": [{
    										"AddressDefinition": "string"
    									}],
    									"TcpFlags": [{
    										"Flags": ["string"],
    										"Masks": ["string"]
    									}]
    								}
    							}
    						}]
    					}
    				},
    				"RuleVariables": {
    					"IpSets": {
    						"Definition": ["string"]
    					},
    					"PortSets": {
    						"Definition": ["string"]
    					}
    				}
    			},
    			"RuleGroupArn": "string",
    			"RuleGroupId": "string",
    			"RuleGroupName": "string",
    			"Type": "string"
    		},
    		"AwsOpenSearchServiceDomain": {
    			"AccessPolicies": "string",
    			"AdvancedSecurityOptions": {
    				"Enabled": boolean,
    				"InternalUserDatabaseEnabled": boolean,
    				"MasterUserOptions": {
    					"MasterUserArn": "string",
    					"MasterUserName": "string",
    					"MasterUserPassword": "string"
    				}
    			},
    			"Arn": "string",
    			"ClusterConfig": {
    				"DedicatedMasterCount": number,
    				"DedicatedMasterEnabled": boolean,
    				"DedicatedMasterType": "string",
    				"InstanceCount": number,
    				"InstanceType": "string",
    				"WarmCount": number,
    				"WarmEnabled": boolean,
    				"WarmType": "string",
    				"ZoneAwarenessConfig": {
    					"AvailabilityZoneCount": number
    				},
    				"ZoneAwarenessEnabled": boolean
    			},
    			"DomainEndpoint": "string",
    			"DomainEndpointOptions": {
    				"CustomEndpoint": "string",
    				"CustomEndpointCertificateArn": "string",
    				"CustomEndpointEnabled": boolean,
    				"EnforceHTTPS": boolean,
    				"TLSSecurityPolicy": "string"
    			},
    			"DomainEndpoints": {
    				"string": "string"
    			},
    			"DomainName": "string",
    			"EncryptionAtRestOptions": {
    				"Enabled": boolean,
    				"KmsKeyId": "string"
    			},
    			"EngineVersion": "string",
    			"Id": "string",
    			"LogPublishingOptions": {
    				"AuditLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				},
    				"IndexSlowLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				},
    				"SearchSlowLogs": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Enabled": boolean
    				}
    			},
    			"NodeToNodeEncryptionOptions": {
    				"Enabled": boolean
    			},
    			"ServiceSoftwareOptions": {
    				"AutomatedUpdateDate": "string",
    				"Cancellable": boolean,
    				"CurrentVersion": "string",
    				"Description": "string",
    				"NewVersion": "string",
    				"OptionalDeployment": boolean,
    				"UpdateAvailable": boolean,
    				"UpdateStatus": "string"
    			},
    			"VpcOptions": {
    				"SecurityGroupIds": ["string"],
    				"SubnetIds": ["string"]
    			}
    		},
    		"AwsRdsDbCluster": {
    			"ActivityStreamStatus": "string",
    			"AllocatedStorage": number,
    			"AssociatedRoles": [{
    				"RoleArn": "string",
    				"Status": "string"
    			}],
    			"AutoMinorVersionUpgrade": boolean,
    			"AvailabilityZones": ["string"],
    			"BackupRetentionPeriod": integer,
    			"ClusterCreateTime": "string",
    			"CopyTagsToSnapshot": boolean,
    			"CrossAccountClone": boolean,
    			"CustomEndpoints": ["string"],
    			"DatabaseName": "string",
    			"DbClusterIdentifier": "string",
    			"DbClusterMembers": [{
    				"DbClusterParameterGroupStatus": "string",
    				"DbInstanceIdentifier": "string",
    				"IsClusterWriter": boolean,
    				"PromotionTier": integer
    			}],
    			"DbClusterOptionGroupMemberships": [{
    				"DbClusterOptionGroupName": "string",
    				"Status": "string"
    			}],
    			"DbClusterParameterGroup": "string",
    			"DbClusterResourceId": "string",
    			"DbSubnetGroup": "string",
    			"DeletionProtection": boolean,
    			"DomainMemberships": [{
    				"Domain": "string",
    				"Fqdn": "string",
    				"IamRoleName": "string",
    				"Status": "string"
    			}],
    			"EnabledCloudwatchLogsExports": ["string"],
    			"Endpoint": "string",
    			"Engine": "string",
    			"EngineMode": "string",
    			"EngineVersion": "string",
    			"HostedZoneId": "string",
    			"HttpEndpointEnabled": boolean,
    			"IamDatabaseAuthenticationEnabled": boolean,
    			"KmsKeyId": "string",
    			"MasterUsername": "string",
    			"MultiAz": boolean,
    			"Port": integer,
    			"PreferredBackupWindow": "string",
    			"PreferredMaintenanceWindow": "string",
    			"ReaderEndpoint": "string",
    			"ReadReplicaIdentifiers": ["string"],
    			"Status": "string",
    			"StorageEncrypted": boolean,
    			"VpcSecurityGroups": [{
    				"Status": "string",
    				"VpcSecurityGroupId": "string"
    			}]
    		},
    		"AwsRdsDbClusterSnapshot": {
    			"AllocatedStorage": integer,
    			"AvailabilityZones": ["string"],
    			"ClusterCreateTime": "string",
    			"DbClusterIdentifier": "string",
    			"DbClusterSnapshotAttributes": [{
    				"AttributeName": "string",
    				"AttributeValues": ["string"]
    			}],
    			"DbClusterSnapshotIdentifier": "string",
    			"Engine": "string",
    			"EngineVersion": "string",
    			"IamDatabaseAuthenticationEnabled": boolean,
    			"KmsKeyId": "string",
    			"LicenseModel": "string",
    			"MasterUsername": "string",
    			"PercentProgress": integer,
    			"Port": integer,
    			"SnapshotCreateTime": "string",
    			"SnapshotType": "string",
    			"Status": "string",
    			"StorageEncrypted": boolean,
    			"VpcId": "string"
    		},
    		"AwsRdsDbInstance": {
    			"AllocatedStorage": number,
    			"AssociatedRoles": [{
    				"RoleArn": "string",
    				"FeatureName": "string",
    				"Status": "string"
    			}],
    			"AutoMinorVersionUpgrade": boolean,
    			"AvailabilityZone": "string",
    			"BackupRetentionPeriod": number,
    			"CACertificateIdentifier": "string",
    			"CharacterSetName": "string",
    			"CopyTagsToSnapshot": boolean,
    			"DBClusterIdentifier": "string",
    			"DBInstanceClass": "string",
    			"DBInstanceIdentifier": "string",
    			"DbInstancePort": number,
    			"DbInstanceStatus": "string",
    			"DbiResourceId": "string",
    			"DBName": "string",
    			"DbParameterGroups": [{
    				"DbParameterGroupName": "string",
    				"ParameterApplyStatus": "string"
    			}],
    			"DbSecurityGroups": ["string"],
    			"DbSubnetGroup": {
    				"DbSubnetGroupArn": "string",
    				"DbSubnetGroupDescription": "string",
    				"DbSubnetGroupName": "string",
    				"SubnetGroupStatus": "string",
    				"Subnets": [{
    					"SubnetAvailabilityZone": {
    						"Name": "string"
    					},
    					"SubnetIdentifier": "string",
    					"SubnetStatus": "string"
    				}],
    				"VpcId": "string"
    			},
    			"DeletionProtection": boolean,
    			"Endpoint": {
    				"Address": "string",
    				"Port": number,
    				"HostedZoneId": "string"
    			},
    			"DomainMemberships": [{
    				"Domain": "string",
    				"Fqdn": "string",
    				"IamRoleName": "string",
    				"Status": "string"
    			}],
    			"EnabledCloudwatchLogsExports": ["string"],
    			"Engine": "string",
    			"EngineVersion": "string",
    			"EnhancedMonitoringResourceArn": "string",
    			"IAMDatabaseAuthenticationEnabled": boolean,
    			"InstanceCreateTime": "string",
    			"Iops": number,
    			"KmsKeyId": "string",
    			"LatestRestorableTime": "string",
    			"LicenseModel": "string",
    			"ListenerEndpoint": {
    				"Address": "string",
    				"HostedZoneId": "string",
    				"Port": number
    			},
    			"MasterUsername": "admin",
    			"MaxAllocatedStorage": number,
    			"MonitoringInterval": number,
    			"MonitoringRoleArn": "string",
    			"MultiAz": boolean,
    			"OptionGroupMemberships": [{
    				"OptionGroupName": "string",
    				"Status": "string"
    			}],
    			"PendingModifiedValues": {
    				"AllocatedStorage": number,
    				"BackupRetentionPeriod": number,
    				"CaCertificateIdentifier": "string",
    				"DbInstanceClass": "string",
    				"DbInstanceIdentifier": "string",
    				"DbSubnetGroupName": "string",
    				"EngineVersion": "string",
    				"Iops": number,
    				"LicenseModel": "string",
    				"MasterUserPassword": "string",
    				"MultiAZ": boolean,
    				"PendingCloudWatchLogsExports": {
    					"LogTypesToDisable": ["string"],
    					"LogTypesToEnable": ["string"]
    				},
    				"Port": number,
    				"ProcessorFeatures": [{
    					"Name": "string",
    					"Value": "string"
    				}],
    				"StorageType": "string"
    			},
    			"PerformanceInsightsEnabled": boolean,
    			"PerformanceInsightsKmsKeyId": "string",
    			"PerformanceInsightsRetentionPeriod": number,
    			"PreferredBackupWindow": "string",
    			"PreferredMaintenanceWindow": "string",
    			"ProcessorFeatures": [{
    				"Name": "string",
    				"Value": "string"
    			}],
    			"PromotionTier": number,
    			"PubliclyAccessible": boolean,
    			"ReadReplicaDBClusterIdentifiers": ["string"],
    			"ReadReplicaDBInstanceIdentifiers": ["string"],
    			"ReadReplicaSourceDBInstanceIdentifier": "string",
    			"SecondaryAvailabilityZone": "string",
    			"StatusInfos": [{
    				"Message": "string",
    				"Normal": boolean,
    				"Status": "string",
    				"StatusType": "string"
    			}],
    			"StorageEncrypted": boolean,
    			"TdeCredentialArn": "string",
    			"Timezone": "string",
    			"VpcSecurityGroups": [{
    				"VpcSecurityGroupId": "string",
    				"Status": "string"
    			}]
    		},
    		"AwsRdsDbSecurityGroup": {
    			"DbSecurityGroupArn": "string",
    			"DbSecurityGroupDescription": "string",
    			"DbSecurityGroupName": "string",
    			"Ec2SecurityGroups": [{
    				"Ec2SecurityGroupuId": "string",
    				"Ec2SecurityGroupName": "string",
    				"Ec2SecurityGroupOwnerId": "string",
    				"Status": "string"
    			}],
    			"IpRanges": [{
    				"CidrIp": "string",
    				"Status": "string"
    			}],
    			"OwnerId": "string",
    			"VpcId": "string"
    		},
    		"AwsRdsDbSnapshot": {
    			"AllocatedStorage": integer,
    			"AvailabilityZone": "string",
    			"DbInstanceIdentifier": "string",
    			"DbiResourceId": "string",
    			"DbSnapshotIdentifier": "string",
    			"Encrypted": boolean,
    			"Engine": "string",
    			"EngineVersion": "string",
    			"IamDatabaseAuthenticationEnabled": boolean,
    			"InstanceCreateTime": "string",
    			"Iops": number,
    			"KmsKeyId": "string",
    			"LicenseModel": "string",
    			"MasterUsername": "string",
    			"OptionGroupName": "string",
    			"PercentProgress": integer,
    			"Port": integer,
    			"ProcessorFeatures": [],
    			"SnapshotCreateTime": "string",
    			"SnapshotType": "string",
    			"SourceDbSnapshotIdentifier": "string",
    			"SourceRegion": "string",
    			"Status": "string",
    			"StorageType": "string",
    			"TdeCredentialArn": "string",
    			"Timezone": "string",
    			"VpcId": "string"
    		},
    		"AwsRdsEventSubscription": {
    			"CustomerAwsId": "string",
    			"CustSubscriptionId": "string",
    			"Enabled": boolean,
    			"EventCategoriesList": ["string"],
    			"EventSubscriptionArn": "string",
    			"SnsTopicArn": "string",
    			"SourceIdsList": ["string"],
    			"SourceType": "string",
    			"Status": "string",
    			"SubscriptionCreationTime": "string"
    		},
    		"AwsRedshiftCluster": {
    			"AllowVersionUpgrade": boolean,
    			"AutomatedSnapshotRetentionPeriod": number,
    			"AvailabilityZone": "string",
    			"ClusterAvailabilityStatus": "string",
    			"ClusterCreateTime": "string",
    			"ClusterIdentifier": "string",
    			"ClusterNodes": [{
    				"NodeRole": "string",
    				"PrivateIPAddress": "string",
    				"PublicIPAddress": "string"
    			}],
    			"ClusterParameterGroups": [{
    				"ClusterParameterStatusList": [{
    					"ParameterApplyErrorDescription": "string",
    					"ParameterApplyStatus": "string",
    					"ParameterName": "string"
    				}],
    				"ParameterApplyStatus": "string",
    				"ParameterGroupName": "string"
    			}],
    			"ClusterPublicKey": "string",
    			"ClusterRevisionNumber": "string",
    			"ClusterSecurityGroups": [{
    				"ClusterSecurityGroupName": "string",
    				"Status": "string"
    			}],
    			"ClusterSnapshotCopyStatus": {
    				"DestinationRegion": "string",
    				"ManualSnapshotRetentionPeriod": number,
    				"RetentionPeriod": number,
    				"SnapshotCopyGrantName": "string"
    			},
    			"ClusterStatus": "string",
    			"ClusterSubnetGroupName": "string",
    			"ClusterVersion": "string",
    			"DBName": "string",
    			"DeferredMaintenanceWindows": [{
    				"DeferMaintenanceEndTime": "string",
    				"DeferMaintenanceIdentifier": "string",
    				"DeferMaintenanceStartTime": "string"
    			}],
    			"ElasticIpStatus": {
    				"ElasticIp": "string",
    				"Status": "string"
    			},
    			"ElasticResizeNumberOfNodeOptions": "string",
    			"Encrypted": boolean,
    			"Endpoint": {
    				"Address": "string",
    				"Port": number
    			},
    			"EnhancedVpcRouting": boolean,
    			"ExpectedNextSnapshotScheduleTime": "string",
    			"ExpectedNextSnapshotScheduleTimeStatus": "string",
    			"HsmStatus": {
    				"HsmClientCertificateIdentifier": "string",
    				"HsmConfigurationIdentifier": "string",
    				"Status": "string"
    			},
    			"IamRoles": [{
    				"ApplyStatus": "string",
    				"IamRoleArn": "string"
    			}],
    			"KmsKeyId": "string",
    			"LoggingStatus":{
                    "BucketName": "string",
                    "LastFailureMessage": "string",
                    "LastFailureTime": "string",
                    "LastSuccessfulDeliveryTime": "string",
                    "LoggingEnabled": boolean,
                    "S3KeyPrefix": "string"
                },
    			"MaintenanceTrackName": "string",
    			"ManualSnapshotRetentionPeriod": number,
    			"MasterUsername": "string",
    			"NextMaintenanceWindowStartTime": "string",
    			"NodeType": "string",
    			"NumberOfNodes": number,
    			"PendingActions": ["string"],
    			"PendingModifiedValues": {
    				"AutomatedSnapshotRetentionPeriod": number,
    				"ClusterIdentifier": "string",
    				"ClusterType": "string",
    				"ClusterVersion": "string",
    				"EncryptionType": "string",
    				"EnhancedVpcRouting": boolean,
    				"MaintenanceTrackName": "string",
    				"MasterUserPassword": "string",
    				"NodeType": "string",
    				"NumberOfNodes": number,
    				"PubliclyAccessible": "string"
    			},
    			"PreferredMaintenanceWindow": "string",
    			"PubliclyAccessible": boolean,
    			"ResizeInfo": {
    				"AllowCancelResize": boolean,
    				"ResizeType": "string"
    			},
    			"RestoreStatus": {
    				"CurrentRestoreRateInMegaBytesPerSecond": number,
    				"ElapsedTimeInSeconds": number,
    				"EstimatedTimeToCompletionInSeconds": number,
    				"ProgressInMegaBytes": number,
    				"SnapshotSizeInMegaBytes": number,
    				"Status": "string"
    			},
    			"SnapshotScheduleIdentifier": "string",
    			"SnapshotScheduleState": "string",
    			"VpcId": "string",
    			"VpcSecurityGroups": [{
    				"Status": "string",
    				"VpcSecurityGroupId": "string"
    			}]
    		},
    		"AwsRoute53HostedZone": {
    			"HostedZone": {
    				"Id": "string",
    				"Name": "string",
    				"Config": {
    					"Comment": "string"
    				}
    			},
    			"NameServers": ["string"],
    			"QueryLoggingConfig": {
    				"CloudWatchLogsLogGroupArn": {
    					"CloudWatchLogsLogGroupArn": "string",
    					"Id": "string",
    					"HostedZoneId": "string"
    				}
    			},
    			"Vpcs": [
    				{
    					"Id": "string",
    					"Region": "string"
    				}
    			]
    		},
    		"AwsS3AccessPoint": {
    			"AccessPointArn": "string",
    			"Alias": "string",
    			"Bucket": "string",
    			"BucketAccountId": "string",
    			"Name": "string",
    			"NetworkOrigin": "string",
    			"PublicAccessBlockConfiguration": {
    				"BlockPublicAcls": boolean,
    				"BlockPublicPolicy": boolean,
    				"IgnorePublicAcls": boolean,
    				"RestrictPublicBuckets": boolean
    			},
    			"VpcConfiguration": {
    				"VpcId": "string"
    			}
    		},
    		"AwsS3AccountPublicAccessBlock": {
    			"BlockPublicAcls": boolean,
    			"BlockPublicPolicy": boolean,
    			"IgnorePublicAcls": boolean,
    			"RestrictPublicBuckets": boolean
    		},
    		"AwsS3Bucket": {
    			"AccessControlList": "string",
    			"BucketLifecycleConfiguration": {
    				"Rules": [{
    					"AbortIncompleteMultipartUpload": {
    						"DaysAfterInitiation": number
    					},
    					"ExpirationDate": "string",
    					"ExpirationInDays": number,
    					"ExpiredObjectDeleteMarker": boolean,
    					"Filter": {
    						"Predicate": {
    							"Operands": [{
    									"Prefix": "string",
    									"Type": "string"
    								},
    								{
    									"Tag": {
    										"Key": "string",
    										"Value": "string"
    									},
    									"Type": "string"
    								}
    							],
    							"Type": "string"
    						}
    					},
    					"Id": "string",
    					"NoncurrentVersionExpirationInDays": number,
    					"NoncurrentVersionTransitions": [{
    						"Days": number,
    						"StorageClass": "string"
    					}],
    					"Prefix": "string",
    					"Status": "string",
    					"Transitions": [{
    						"Date": "string",
    						"Days": number,
    						"StorageClass": "string"
    					}]
    				}]
    			},
    			"BucketLoggingConfiguration": {
    				"DestinationBucketName": "string",
    				"LogFilePrefix": "string"
    			},
    			"BucketName": "string",
    			"BucketNotificationConfiguration": {
    				"Configurations": [{
    					"Destination": "string",
    					"Events": ["string"],
    					"Filter": {
    						"S3KeyFilter": {
    							"FilterRules": [{
    								"Name": "string",
    								"Value": "string"
    							}]
    						}
    					},
    					"Type": "string"
    				}]
    			},
    			"BucketVersioningConfiguration": {
    				"IsMfaDeleteEnabled": boolean,
    				"Status": "string"
    			},
    			"BucketWebsiteConfiguration": {
    				"ErrorDocument": "string",
    				"IndexDocumentSuffix": "string",
    				"RedirectAllRequestsTo": {
    					"HostName": "string",
    					"Protocol": "string"
    				},
    				"RoutingRules": [{
    					"Condition": {
    						"HttpErrorCodeReturnedEquals": "string",
    						"KeyPrefixEquals": "string"
    					},
    					"Redirect": {
    						"HostName": "string",
    						"HttpRedirectCode": "string",
    						"Protocol": "string",
    						"ReplaceKeyPrefixWith": "string",
    						"ReplaceKeyWith": "string"
    					}
    				}]
    			},
    			"CreatedAt": "string",
    			"ObjectLockConfiguration": {
    				"ObjectLockEnabled": "string",
    				"Rule": {
    					"DefaultRetention": {
    						"Days": integer,
    						"Mode": "string",
    						"Years": integer
    					}
    				}
    			},
    			"OwnerAccountId": "string",
    			"OwnerId": "string",
    			"OwnerName": "string",
    			"PublicAccessBlockConfiguration": {
    				"BlockPublicAcls": boolean,
    				"BlockPublicPolicy": boolean,
    				"IgnorePublicAcls": boolean,
    				"RestrictPublicBuckets": boolean
    			},
    			"ServerSideEncryptionConfiguration": {
    				"Rules": [{
    					"ApplyServerSideEncryptionByDefault": {
    						"KMSMasterKeyID": "string",
    						"SSEAlgorithm": "string"
    					}
    				}]
    			}
    		},
    		"AwsS3Object": {
    			"ContentType": "string",
    			"ETag": "string",
    			"LastModified": "string",
    			"ServerSideEncryption": "string",
    			"SSEKMSKeyId": "string",
    			"VersionId": "string"
    		},
    		"AwsSagemakerNotebookInstance": {
    			"DirectInternetAccess": "string",
    			"InstanceMetadataServiceConfiguration": {
    				"MinimumInstanceMetadataServiceVersion": "string"
    			},
    			"InstanceType": "string",
    			"LastModifiedTime": "string",
    			"NetworkInterfaceId": "string",
    			"NotebookInstanceArn": "string",
    			"NotebookInstanceName": "string",
    			"NotebookInstanceStatus": "string",
    			"PlatformIdentifier": "string",
    			"RoleArn": "string",
    			"RootAccess": "string",
    			"SecurityGroups": ["string"],
    			"SubnetId": "string",
    			"Url": "string",
    			"VolumeSizeInGB": number
    		},
    		"AwsSecretsManagerSecret": {
    			"Deleted": boolean,
    			"Description": "string",
    			"KmsKeyId": "string",
    			"Name": "string",
    			"RotationEnabled": boolean,
    			"RotationLambdaArn": "string",
    			"RotationOccurredWithinFrequency": boolean,
    			"RotationRules": {
    				"AutomaticallyAfterDays": integer
    			}
    		},
    		"AwsSnsTopic": {
    			"ApplicationSuccessFeedbackRoleArn": "string",		
    			"FirehoseFailureFeedbackRoleArn": "string",
    			"FirehoseSuccessFeedbackRoleArn": "string",
    			"HttpFailureFeedbackRoleArn": "string",
    			"HttpSuccessFeedbackRoleArn": "string",
    			"KmsMasterKeyId": "string",                 
    			"Owner": "string",
    			"SqsFailureFeedbackRoleArn": "string",
    			"SqsSuccessFeedbackRoleArn": "string",	
    			"Subscription": {
    				"Endpoint": "string",
    				"Protocol": "string"
    			},
    			"TopicName": "string"   			              
    		},
    		"AwsSqsQueue": {
    			"DeadLetterTargetArn": "string",
    			"KmsDataKeyReusePeriodSeconds": number,
    			"KmsMasterKeyId": "string",
    			"QueueName": "string"
    		},
    		"AwsSsmPatchCompliance": {
    			"Patch": {
    				"ComplianceSummary": {
    					"ComplianceType": "string",
    					"CompliantCriticalCount": integer,
    					"CompliantHighCount": integer,
    					"CompliantInformationalCount": integer,
    					"CompliantLowCount": integer,
    					"CompliantMediumCount": integer,
    					"CompliantUnspecifiedCount": integer,
    					"ExecutionType": "string",
    					"NonCompliantCriticalCount": integer,
    					"NonCompliantHighCount": integer,
    					"NonCompliantInformationalCount": integer,
    					"NonCompliantLowCount": integer,
    					"NonCompliantMediumCount": integer,
    					"NonCompliantUnspecifiedCount": integer,
    					"OverallSeverity": "string",
    					"PatchBaselineId": "string",
    					"PatchGroup": "string",
    					"Status": "string"
    				}
    			}
    		},
    		"AwsStepFunctionStateMachine": {
    			"StateMachineArn": "string",
    			"Name": "string",
    			"Status": "string",
    			"RoleArn": "string",
    			"Type": "string",
    			"LoggingConfiguration": {
    				"Level": "string",
    				"IncludeExecutionData": boolean
    			},
    			"TracingConfiguration": {
    				"Enabled": boolean
    			}
    		},
    		"AwsWafRateBasedRule": {
    			"MatchPredicates": [{
    				"DataId": "string",
    				"Negated": boolean,
    				"Type": "string"
    			}],
    			"MetricName": "string",
    			"Name": "string",
    			"RateKey": "string",
    			"RateLimit": number,
    			"RuleId": "string"
    		},
    		"AwsWafRegionalRateBasedRule": {
    			"MatchPredicates": [{
    				"DataId": "string",
    				"Negated": boolean,
    				"Type": "string"
    			}],
    			"MetricName": "string",
    			"Name": "string",
    			"RateKey": "string",
    			"RateLimit": number,
    			"RuleId": "string"
    		},
    		"AwsWafRegionalRule": {
    			"MetricName": "string",
    			"Name": "string",
    			"RuleId": "string",
    			"PredicateList": [{
        			"DataId": "string",
        			"Negated": boolean,
        			"Type": "string"
    			}]
    		},
    		"AwsWafRegionalRuleGroup": {
    			"MetricName": "string",
    			"Name": "string",
    			"RuleGroupId": "string",
    			"Rules": [{
    				"Action": {
    					"Type": "string"
    				},
    				"Priority": number,
    				"RuleId": "string",
    				"Type": "string"
    			}]
    		},
    		"AwsWafRegionalWebAcl": {
    			"DefaultAction": "string",
    			"MetricName" : "string",
    			"Name": "string",
    			"RulesList" : [{
    				"Action": {
    					"Type": "string"
    				},
    				"Priority": number,
    				"RuleId": "string",
    				"Type": "string",
    				"ExcludedRules": [{
    					"ExclusionType": "string",
    					"RuleId": "string"
    				}],
    				"OverrideAction": {
    					"Type": "string"
    				}
    			}],
    			"WebAclId": "string"
    		},
    		"AwsWafRule": {
    			"MetricName": "string",
    			"Name": "string",
    			"PredicateList": [{
    				"DataId": "string",
    				"Negated": boolean,
    				"Type": "string"
    			}],
    			"RuleId": "string"
    		},
    		"AwsWafRuleGroup": {
    			"MetricName": "string",
    			"Name": "string",
    			"RuleGroupId": "string",
    			"Rules": [{
    				"Action": {
    					"Type": "string"
    				},
    				"Priority": number,
    				"RuleId": "string",
    				"Type": "string"
    			}]
    		},
    		"AwsWafv2RuleGroup": {
    			"Arn": "string",
    			"Capacity": number,
    			"Description": "string",
    			"Id": "string",
    			"Name": "string",
    			"Rules": [{
    				"Action": {
    				"Allow": {
    					"CustomRequestHandling": {
    						"InsertHeaders": [
    							{
    							"Name": "string",
    							"Value": "string"
    							},
    							{
    							"Name": "string",
    							"Value": "string"
    							}
    						]
    					}
    				}
    				},
    				"Name": "string",
    				"Priority": number,
    				"VisibilityConfig": {
    					"CloudWatchMetricsEnabled": boolean,
    					"MetricName": "string",
    					"SampledRequestsEnabled": boolean
    				}
    			}],
    			"VisibilityConfig": {
    				"CloudWatchMetricsEnabled": boolean,
    				"MetricName": "string",
    				"SampledRequestsEnabled": boolean
    			}
    		},
    		"AwsWafWebAcl": {
    			"DefaultAction": "string",
    			"Name": "string",
    			"Rules": [{
    				"Action": {
    					"Type": "string"
    				},
    				"ExcludedRules": [{
    					"RuleId": "string"
    				}],
    				"OverrideAction": {
    					"Type": "string"
    				},
    				"Priority": number,
    				"RuleId": "string",
    				"Type": "string"
    			}],
    			"WebAclId": "string"
    		},
    		"AwsWafv2WebAcl": {
    			"Arn": "string",
    			"Capacity": number,
    			"CaptchaConfig": {
    				"ImmunityTimeProperty": {
    					"ImmunityTime": number
    				}
    			},
    			"DefaultAction": {
    				"Block": {}
    			},
    			"Description": "string",
    			"ManagedbyFirewallManager": boolean,
    			"Name": "string",
    			"Rules": [{
    				"Action": {
    					"RuleAction": {
    						"Block": {}
    					}
    				},
    				"Name": "string",
    				"Priority": number,
    				"VisibilityConfig": {
    					"SampledRequestsEnabled": boolean,
    					"CloudWatchMetricsEnabled": boolean,
    					"MetricName": "string"
    				}
    			}],
    			"VisibilityConfig": {
    				"SampledRequestsEnabled": boolean,
    				"CloudWatchMetricsEnabled": boolean,
    				"MetricName": "string"
    			}
    		},
    		"AwsXrayEncryptionConfig": {
    			"KeyId": "string",
    			"Status": "string",
    			"Type": "string"
    		},
    		"Container": {
    			"ContainerRuntime": "string",
    			"ImageId": "string",
    			"ImageName": "string",
    			"LaunchedAt": "string",
    			"Name": "string",
    			"Privileged": boolean,
    			"VolumeMounts": [{
    				"Name": "string",
    				"MountPath": "string"
    			}]
    		}, 
    		"Other": {
    			"string": "string"
    		},
    		"Id": "string",
    		"Partition": "string",
    		"Region": "string",
    		"ResourceRole": "string",
    		"Tags": {
    			"string": "string"
    		},
    		"Type": "string"
    	}],
    	"SchemaVersion": "string",
    	"Severity": {
    		"Label": "string",
    		"Normalized": number,
    		"Original": "string"
    	},
    	"Sample": boolean,
    	"SourceUrl": "string",
    	"Threats": [{
    		"FilePaths": [{
    			"FileName": "string",
    			"FilePath": "string",
    			"Hash": "string",
    			"ResourceId": "string"
    		}],
    		"ItemCount": number,
    		"Name": "string",
    		"Severity": "string"
    	}],
    	"ThreatIntelIndicators": [{
    		"Category": "string",
    		"LastObservedAt": "string",
    		"Source": "string",
    		"SourceUrl": "string",
    		"Type": "string",
    		"Value": "string"
    	}],
    	"Title": "string",
    	"Types": ["string"],
    	"UpdatedAt": "string",
    	"UserDefinedFields": {
    		"string": "string"
    	},
    	"VerificationState": "string",
    	"Vulnerabilities": [{
    		"CodeVulnerabilities": [{
    			"Cwes": [
    				"string",
    				"string"
    			],
    			"FilePath": {
    				"EndLine": integer,
    				"FileName": "string",
    				"FilePath": "string",
    				"StartLine": integer
    			},
    			"SourceArn":"string"
    		}],
    		"Cvss": [{
    			"Adjustments": [{
    				"Metric": "string",
    				"Reason": "string"
    			}],
    			"BaseScore": number,
    			"BaseVector": "string",
    			"Source": "string",
    			"Version": "string"
    		}],
    		"EpssScore": number,
    		"ExploitAvailable": "string",
    		"FixAvailable": "string",
    		"Id": "string",
    		"LastKnownExploitAt": "string",
    		"ReferenceUrls": ["string"],
    		"RelatedVulnerabilities": ["string"],
    		"Vendor": {
    			"Name": "string",
    			"Url": "string",
    			"VendorCreatedAt": "string",
    			"VendorSeverity": "string",
    			"VendorUpdatedAt": "string"
    		},
    		"VulnerablePackages": [{
    			"Architecture": "string",
    			"Epoch": "string",
    			"FilePath": "string",
    			"FixedInVersion": "string",
    			"Name": "string",
    			"PackageManager": "string",
    			"Release": "string",
    			"Remediation": "string",
    			"SourceLayerArn": "string",
    			"SourceLayerHash": "string",
    			"Version": "string"
    		}]
    	}],
    	"Workflow": {
    		"Status": "string"
    	},
    	"WorkflowState": "string"
    }
]