classes.ts

/* eslint-disable @stylistic/quote-props */
/* eslint-disable @stylistic/comma-dangle */
/*
 * Do not edit this file manually. To prevent misconfiguration, this file
 * should only be modified by an automated GitHub workflow, that ensures
 * that the regions present in this list correspond to all the regions
 * where we have the AWS::CDK::Metadata handler deployed.
 *
 * See: https://github.com/aws/aws-cdk/issues/27189
 */

export const AWS_CDK_CONSTRUCTOR_PROPS: { [key: string]: any } = {
  '@aws-cdk.aws-amplify-alpha': {
    'App': {
      'appName': '*',
      'sourceCodeProvider': '*',
      'autoBranchCreation': {
        'patterns': '*',
        'basicAuth': '*',
        'buildSpec': '*',
        'autoBuild': 'boolean',
        'pullRequestPreview': 'boolean',
        'environmentVariables': '*',
        'pullRequestEnvironmentName': '*',
        'stage': '*'
      },
      'autoBranchDeletion': 'boolean',
      'basicAuth': '*',
      'buildSpec': '*',
      'customResponseHeaders': {
        'appRoot': '*',
        'pattern': '*',
        'headers': '*'
      },
      'customRules': '*',
      'description': '*',
      'environmentVariables': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'platform': 'Platform',
      'cacheConfigType': 'CacheConfigType',
      'computeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'buildComputeType': 'BuildComputeType',
      'addCustomRule': [
        '*'
      ],
      'addEnvironment': [
        '*',
        '*'
      ],
      'addAutoBranchEnvironment': [
        '*',
        '*'
      ],
      'addBranch': [
        '*',
        {
          'basicAuth': '*',
          'branchName': '*',
          'buildSpec': '*',
          'description': '*',
          'autoBuild': 'boolean',
          'pullRequestPreview': 'boolean',
          'environmentVariables': '*',
          'pullRequestEnvironmentName': '*',
          'stage': '*',
          'asset': '*',
          'performanceMode': 'boolean',
          'skewProtection': 'boolean',
          'computeRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      ],
      'addDomain': [
        '*',
        {
          'domainName': '*',
          'subDomains': {
            'branch': {
              'branchName': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'prefix': '*'
          },
          'enableAutoSubdomain': 'boolean',
          'autoSubdomainCreationPatterns': '*',
          'customCertificate': {
            'certificateArn': '*'
          }
        }
      ]
    },
    'Branch': {
      'app': {
        'appId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'basicAuth': '*',
      'branchName': '*',
      'buildSpec': '*',
      'description': '*',
      'autoBuild': 'boolean',
      'pullRequestPreview': 'boolean',
      'environmentVariables': '*',
      'pullRequestEnvironmentName': '*',
      'stage': '*',
      'asset': '*',
      'performanceMode': 'boolean',
      'skewProtection': 'boolean',
      'computeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addEnvironment': [
        '*',
        '*'
      ]
    },
    'Domain': {
      'app': {
        'appId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoSubDomainIamRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'domainName': '*',
      'subDomains': {
        'branch': {
          'branchName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'prefix': '*'
      },
      'enableAutoSubdomain': 'boolean',
      'autoSubdomainCreationPatterns': '*',
      'customCertificate': {
        'certificateArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'mapSubDomain': [
        {
          'branchName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        '*'
      ],
      'mapRoot': [
        {
          'branchName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    }
  },
  '@aws-cdk.aws-apprunner-alpha': {
    'AutoScalingConfiguration': {
      'autoScalingConfigurationName': '*',
      'maxConcurrency': '*',
      'maxSize': '*',
      'minSize': '*'
    },
    'ObservabilityConfiguration': {
      'observabilityConfigurationName': '*',
      'traceConfigurationVendor': 'TraceConfigurationVendor'
    },
    'Service': {
      'source': '*',
      'autoDeploymentsEnabled': 'boolean',
      'autoScalingConfiguration': {
        'autoScalingConfigurationArn': '*',
        'autoScalingConfigurationName': '*',
        'autoScalingConfigurationRevision': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cpu': '*',
      'memory': '*',
      'accessRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'instanceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'serviceName': '*',
      'vpcConnector': {
        'vpcConnectorName': '*',
        'vpcConnectorArn': '*',
        'vpcConnectorRevision': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'isPubliclyAccessible': 'boolean',
      'healthCheck': '*',
      'kmsKey': '*',
      'ipAddressType': 'IpAddressType',
      'observabilityConfiguration': {
        'observabilityConfigurationName': '*',
        'observabilityConfigurationArn': '*',
        'observabilityConfigurationRevision': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addToRolePolicy': [
        '*'
      ],
      'addEnvironmentVariable': [
        '*',
        '*'
      ],
      'addSecret': [
        '*',
        '*'
      ]
    },
    'VpcConnector': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcConnectorName': '*'
    },
    'VpcIngressConnection': {
      'vpcIngressConnectionName': '*',
      'service': {
        'serviceName': '*',
        'serviceArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'interfaceVpcEndpoint': {
        'vpcEndpointId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      }
    }
  },
  '@aws-cdk.aws-cloud9-alpha': {
    'Ec2Environment': {
      'owner': '*',
      'instanceType': '*',
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ec2EnvironmentName': '*',
      'description': '*',
      'clonedRepositories': '*',
      'connectionType': 'ConnectionType',
      'imageId': 'ImageId',
      'automaticStop': '*'
    }
  },
  '@aws-cdk.aws-codestar-alpha': {
    'GitHubRepository': {
      'owner': '*',
      'repositoryName': '*',
      'accessToken': '*',
      'contentsBucket': '*',
      'contentsKey': '*',
      'contentsS3Version': '*',
      'enableIssues': 'boolean',
      'visibility': 'RepositoryVisibility',
      'description': '*'
    }
  },
  '@aws-cdk.aws-ec2-alpha': {
    'IpamPool': {
      'ipamScopeId': '*',
      'addressFamily': 'AddressFamily',
      'ipv4ProvisionedCidrs': '*',
      'locale': '*',
      'publicIpSource': 'IpamPoolPublicIpSource',
      'awsService': 'AwsServiceName',
      'ipamPoolName': '*',
      'provisionCidr': [
        '*',
        {
          'netmaskLength': '*',
          'cidr': '*'
        }
      ]
    },
    'IpamScope': {
      'ipamId': '*',
      'ipamOperatingRegions': '*',
      'ipamScopeId': '*',
      'ipamScopeName': '*'
    },
    'Ipam': {
      'addScope': [
        '*',
        '*',
        {
          'ipamScopeName': '*'
        }
      ]
    },
    'EgressOnlyInternetGateway': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'egressOnlyInternetGatewayName': '*'
    },
    'InternetGateway': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'internetGatewayName': '*'
    },
    'VPNGatewayV2': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'type': 'VpnConnectionType',
      'amazonSideAsn': '*',
      'vpnGatewayName': '*',
      'vpnRoutePropagation': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      }
    },
    'NatGateway': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnet': {
        'ipv6CidrBlock': '*',
        'subnetType': 'SubnetType',
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'allocationId': '*',
      'connectivityType': 'NatConnectivityType',
      'maxDrainDuration': '*',
      'privateIpAddress': '*',
      'secondaryAllocationIds': '*',
      'secondaryPrivateIpAddressCount': '*',
      'secondaryPrivateIpAddresses': '*',
      'natGatewayName': '*'
    },
    'VPCPeeringConnection': {
      'requestorVpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'acceptorVpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'peerRoleArn': '*',
      'vpcPeeringConnectionName': '*'
    },
    'Route': {
      'routeTable': {
        'routeTableId': '*'
      },
      'destination': '*',
      'target': '*',
      'routeName': '*'
    },
    'RouteTable': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'routeTableName': '*',
      'addRoute': [
        '*',
        '*',
        '*',
        '*'
      ]
    },
    'SubnetV2': {
      'vpc': {
        'secondaryCidrBlock': {
          'amazonProvidedIpv6CidrBlock': 'boolean',
          'cidrBlock': '*',
          'ipv6IpamPoolId': '*',
          'ipv4IpamPoolId': '*',
          'ipv6CidrBlock': '*',
          'ipv6Pool': '*'
        },
        'ipv4CidrBlock': '*',
        'region': '*',
        'ownerAccountId': '*',
        'ipv4IpamProvisionedCidrs': '*',
        'vpcName': '*',
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv4CidrBlock': '*',
      'ipv6CidrBlock': '*',
      'availabilityZone': '*',
      'routeTable': {
        'routeTableId': '*'
      },
      'defaultRouteTableName': '*',
      'subnetType': 'SubnetType',
      'subnetName': '*',
      'assignIpv6AddressOnCreation': 'boolean',
      'mapPublicIpOnLaunch': 'boolean',
      'associateNetworkAcl': [
        '*',
        {
          'networkAclId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'TransitGatewayRouteTableAssociation': {
      'transitGatewayVpcAttachment': {
        'transitGatewayAttachmentId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'transitGatewayRouteTable': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'routeTableId': '*'
      },
      'transitGatewayRouteTableAssociationName': '*'
    },
    'TransitGatewayRouteTablePropagation': {
      'transitGatewayVpcAttachment': {
        'transitGatewayAttachmentId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'transitGatewayRouteTable': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'routeTableId': '*'
      },
      'transitGatewayRouteTablePropagationName': '*'
    },
    'TransitGatewayRouteTable': {
      'transitGateway': {
        'transitGatewayId': '*',
        'transitGatewayArn': '*',
        'defaultRouteTable': {
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'routeTableId': '*'
        },
        'defaultRouteTableAssociation': 'boolean',
        'defaultRouteTablePropagation': 'boolean',
        'dnsSupport': 'boolean',
        'securityGroupReferencingSupport': 'boolean',
        'routerType': 'RouterType',
        'routerTargetId': '*'
      },
      'transitGatewayRouteTableName': '*'
    },
    'TransitGatewayRoute': {
      'transitGatewayAttachment': {
        'transitGatewayAttachmentId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'destinationCidrBlock': '*',
      'transitGatewayRouteTable': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'routeTableId': '*'
      },
      'transitGatewayRouteName': '*'
    },
    'TransitGatewayBlackholeRoute': {
      'destinationCidrBlock': '*',
      'transitGatewayRouteTable': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'routeTableId': '*'
      },
      'transitGatewayRouteName': '*'
    },
    'TransitGatewayVpcAttachment': {
      'transitGateway': {
        'transitGatewayId': '*',
        'transitGatewayArn': '*',
        'defaultRouteTable': {
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'routeTableId': '*'
        },
        'defaultRouteTableAssociation': 'boolean',
        'defaultRouteTablePropagation': 'boolean',
        'dnsSupport': 'boolean',
        'securityGroupReferencingSupport': 'boolean',
        'routerType': 'RouterType',
        'routerTargetId': '*'
      },
      'subnets': {
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcAttachmentOptions': {
        'applianceModeSupport': 'boolean',
        'dnsSupport': 'boolean',
        'ipv6Support': 'boolean',
        'securityGroupReferencingSupport': 'boolean'
      },
      'transitGatewayAttachmentName': '*'
    },
    'TransitGateway': {
      'transitGatewayName': '*',
      'amazonSideAsn': '*',
      'autoAcceptSharedAttachments': 'boolean',
      'defaultRouteTableAssociation': 'boolean',
      'defaultRouteTablePropagation': 'boolean',
      'description': '*',
      'dnsSupport': 'boolean',
      'securityGroupReferencingSupport': 'boolean',
      'transitGatewayCidrBlocks': '*'
    },
    'VpcV2': {
      'primaryAddressBlock': '*',
      'secondaryAddressBlocks': '*',
      'enableDnsHostnames': 'boolean',
      'enableDnsSupport': 'boolean',
      'defaultInstanceTenancy': 'DefaultInstanceTenancy',
      'vpcName': '*'
    },
    'VPCCidrBlock': {
      'vpcId': '*',
      'amazonProvidedIpv6CidrBlock': 'boolean',
      'cidrBlock': '*',
      'cidrBlockName': '*',
      'ipv6NetmaskLength': '*',
      'ipv4NetmaskLength': '*',
      'ipv6IpamPoolId': '*',
      'ipv4IpamPoolId': '*',
      'ipv4IpamProvisionedCidrs': '*',
      'ipv6CidrBlock': '*',
      'ipv6Pool': '*'
    }
  },
  '@aws-cdk.aws-elasticache-alpha': {
    'IamUser': {
      'userName': '*',
      'engine': 'UserEngine',
      'userId': '*',
      'accessControl': '*',
      'grantConnect': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ]
    },
    'NoPasswordUser': {
      'userName': '*',
      'engine': 'UserEngine',
      'userId': '*',
      'accessControl': '*'
    },
    'PasswordUser': {
      'userName': '*',
      'passwords': '*',
      'engine': 'UserEngine',
      'userId': '*',
      'accessControl': '*'
    },
    'ServerlessCache': {
      'engine': 'CacheEngine',
      'serverlessCacheName': '*',
      'description': '*',
      'cacheUsageLimits': {
        'dataStorageMinimumSize': '*',
        'requestRateLimitMinimum': '*',
        'requestRateLimitMaximum': '*'
      },
      'backup': {
        'backupTime': '*',
        'backupRetentionLimit': '*',
        'backupNameBeforeDeletion': '*',
        'backupArnsToRestore': '*'
      },
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'userGroup': {
        'userGroupName': '*',
        'engine': 'UserEngine',
        'users': {
          'userId': '*',
          'engine': 'UserEngine',
          'userName': '*',
          'userArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'userGroupArn': '*'
      }
    },
    'UserGroup': {
      'userGroupName': '*',
      'engine': 'UserEngine',
      'users': {
        'userId': '*',
        'engine': 'UserEngine',
        'userName': '*',
        'userArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addUser': [
        {
          'userId': '*',
          'engine': 'UserEngine',
          'userName': '*',
          'userArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    }
  },
  '@aws-cdk.aws-gamelift-alpha': {
    'Alias': {
      'aliasName': '*',
      'description': '*',
      'fleet': {
        'fleetId': '*',
        'fleetArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        'resourceArnForDestination': '*'
      },
      'terminalMessage': '*'
    },
    'BuildFleet': {
      'content': {
        'buildId': '*',
        'buildArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      },
      'ingressRules': {
        'port': '*',
        'source': {
          'uniqueId': '*'
        }
      },
      'fleetName': '*',
      'description': '*',
      'useSpot': 'boolean',
      'useCertificate': 'boolean',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'peerVpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'metricGroup': '*',
      'instanceType': '*',
      'desiredCapacity': '*',
      'minSize': '*',
      'maxSize': '*',
      'protectNewGameSession': 'boolean',
      'runtimeConfiguration': {
        'gameSessionActivationTimeout': '*',
        'maxConcurrentGameSessionActivations': '*',
        'serverProcesses': {
          'concurrentExecutions': '*',
          'launchPath': '*',
          'parameters': '*'
        }
      },
      'locations': {
        'region': '*',
        'capacity': {
          'desiredCapacity': '*',
          'maxSize': '*',
          'minSize': '*'
        }
      },
      'resourceCreationLimitPolicy': {
        'newGameSessionsPerCreator': '*',
        'policyPeriod': '*'
      },
      'addIngressRule': [
        {
          'uniqueId': '*'
        },
        '*'
      ]
    },
    'Build': {
      'buildName': '*',
      'buildVersion': '*',
      'operatingSystem': 'OperatingSystem',
      'content': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'serverSdkVersion': '*'
    },
    'GameServerGroup': {
      'gameServerGroupName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'minSize': '*',
      'maxSize': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'instanceDefinitions': {
        'instanceType': '*',
        'weight': '*'
      },
      'launchTemplate': {
        'versionNumber': '*',
        'launchTemplateId': '*',
        'launchTemplateName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'protectGameServer': 'boolean',
      'autoScalingPolicy': {
        'estimatedInstanceWarmup': '*',
        'targetTrackingConfiguration': '*'
      },
      'deleteOption': 'DeleteOption',
      'balancingStrategy': 'BalancingStrategy'
    },
    'GameSessionQueue': {
      'gameSessionQueueName': '*',
      'customEventData': '*',
      'allowedLocations': '*',
      'notificationTarget': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'playerLatencyPolicies': {
        'maximumIndividualPlayerLatency': '*'
      },
      'priorityConfiguration': {
        'locationOrder': '*',
        'priorityOrder': 'PriorityType'
      },
      'timeout': '*',
      'destinations': {
        'resourceArnForDestination': '*'
      },
      'addDestination': [
        {
          'resourceArnForDestination': '*'
        }
      ]
    },
    'MatchmakingRuleSet': {
      'matchmakingRuleSetName': '*',
      'content': '*'
    },
    'QueuedMatchmakingConfiguration': {
      'additionalPlayerCount': '*',
      'manualBackfillMode': 'boolean',
      'gameProperties': {
        'key': '*',
        'value': '*'
      },
      'gameSessionData': '*',
      'gameSessionQueues': {
        'gameSessionQueueName': '*',
        'gameSessionQueueArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'matchmakingConfigurationName': '*',
      'description': '*',
      'requireAcceptance': 'boolean',
      'acceptanceTimeout': '*',
      'customEventData': '*',
      'notificationTarget': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'requestTimeout': '*',
      'ruleSet': {
        'matchmakingRuleSetName': '*',
        'matchmakingRuleSetArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addGameSessionQueue': [
        {
          'gameSessionQueueName': '*',
          'gameSessionQueueArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'Script': {
      'scriptName': '*',
      'scriptVersion': '*',
      'content': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'StandaloneMatchmakingConfiguration': {
      'matchmakingConfigurationName': '*',
      'description': '*',
      'requireAcceptance': 'boolean',
      'acceptanceTimeout': '*',
      'customEventData': '*',
      'notificationTarget': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'requestTimeout': '*',
      'ruleSet': {
        'matchmakingRuleSetName': '*',
        'matchmakingRuleSetArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    }
  },
  '@aws-cdk.aws-glue-alpha': {
    'Connection': {
      'type': '*',
      'connectionName': '*',
      'description': '*',
      'properties': '*',
      'matchCriteria': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'subnet': {
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addProperty': [
        '*',
        '*'
      ]
    },
    'DataQualityRuleset': {
      'rulesetName': '*',
      'clientToken': '*',
      'description': '*',
      'rulesetDqdl': '*',
      'tags': '*',
      'targetTable': '*'
    },
    'Database': {
      'databaseName': '*',
      'locationUri': '*',
      'description': '*'
    },
    'ExternalTable': {
      'connection': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'externalDataLocation': '*',
      'tableName': '*',
      'description': '*',
      'database': {
        'catalogArn': '*',
        'catalogId': '*',
        'databaseArn': '*',
        'databaseName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'columns': {
        'name': '*',
        'type': {
          'isPrimitive': 'boolean',
          'inputString': '*'
        },
        'comment': '*'
      },
      'partitionKeys': {
        'name': '*',
        'type': {
          'isPrimitive': 'boolean',
          'inputString': '*'
        },
        'comment': '*'
      },
      'partitionIndexes': {
        'indexName': '*',
        'keyNames': '*'
      },
      'dataFormat': '*',
      'compressed': 'boolean',
      'storedAsSubDirectories': 'boolean',
      'enablePartitionFiltering': 'boolean',
      'storageParameters': '*',
      'parameters': '*',
      'partitionProjection': '*',
      'grantRead': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantWrite': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantReadWrite': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'S3Table': {
      'bucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3Prefix': '*',
      'encryption': 'TableEncryption',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tableName': '*',
      'description': '*',
      'database': {
        'catalogArn': '*',
        'catalogId': '*',
        'databaseArn': '*',
        'databaseName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'columns': {
        'name': '*',
        'type': {
          'isPrimitive': 'boolean',
          'inputString': '*'
        },
        'comment': '*'
      },
      'partitionKeys': {
        'name': '*',
        'type': {
          'isPrimitive': 'boolean',
          'inputString': '*'
        },
        'comment': '*'
      },
      'partitionIndexes': {
        'indexName': '*',
        'keyNames': '*'
      },
      'dataFormat': '*',
      'compressed': 'boolean',
      'storedAsSubDirectories': 'boolean',
      'enablePartitionFiltering': 'boolean',
      'storageParameters': '*',
      'parameters': '*',
      'partitionProjection': '*',
      'grantRead': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantWrite': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantReadWrite': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'SecurityConfiguration': {
      'securityConfigurationName': '*',
      'cloudWatchEncryption': {
        'mode': 'CloudWatchEncryptionMode',
        'kmsKey': '*'
      },
      'jobBookmarksEncryption': {
        'mode': 'JobBookmarksEncryptionMode',
        'kmsKey': '*'
      },
      's3Encryption': {
        'mode': 'S3EncryptionMode',
        'kmsKey': '*'
      }
    },
    'Table': {}
  },
  '@aws-cdk.aws-imagebuilder-alpha': {
    'Component': {
      'data': '*',
      'platform': 'Platform',
      'componentName': '*',
      'componentVersion': '*',
      'description': '*',
      'changeDescription': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'supportedOsVersions': '*',
      'tags': '*'
    },
    'ContainerRecipe': {
      'baseImage': '*',
      'targetRepository': '*',
      'containerRecipeName': '*',
      'containerRecipeVersion': '*',
      'description': '*',
      'dockerfile': '*',
      'components': {
        'component': {
          'componentArn': '*',
          'componentName': '*',
          'componentVersion': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'parameters': '*'
      },
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'workingDirectory': '*',
      'osVersion': '*',
      'instanceBlockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'instanceImage': '*',
      'tags': '*',
      'addInstanceBlockDevice': [
        {
          'deviceName': '*',
          'volume': '*',
          'mappingEnabled': 'boolean'
        }
      ]
    },
    'DistributionConfiguration': {
      'amiDistributions': {
        'region': '*',
        'amiTags': '*',
        'amiDescription': '*',
        'amiKmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'amiLaunchPermission': {
          'organizationalUnitArns': '*',
          'organizationArns': '*',
          'isPublicUserGroup': 'boolean',
          'accountIds': '*'
        },
        'amiName': '*',
        'amiTargetAccountIds': '*',
        'ssmParameters': {
          'amiAccount': '*',
          'dataType': 'ParameterDataType',
          'parameter': {
            'stringValue': '*',
            'parameterArn': '*',
            'parameterName': '*',
            'parameterType': '*'
          }
        },
        'launchTemplates': {
          'launchTemplate': {
            'versionNumber': '*',
            'launchTemplateId': '*',
            'launchTemplateName': '*'
          },
          'accountId': '*',
          'setDefaultVersion': 'boolean'
        },
        'fastLaunchConfigurations': {
          'enabled': 'boolean',
          'maxParallelLaunches': '*',
          'targetSnapshotCount': '*'
        },
        'licenseConfigurationArns': '*'
      },
      'containerDistributions': {
        'region': '*',
        'containerRepository': '*',
        'containerDescription': '*',
        'containerTags': '*'
      },
      'distributionConfigurationName': '*',
      'description': '*',
      'tags': '*',
      'addAmiDistributions': [
        {
          'region': '*',
          'amiTags': '*',
          'amiDescription': '*',
          'amiKmsKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'amiLaunchPermission': {
            'organizationalUnitArns': '*',
            'organizationArns': '*',
            'isPublicUserGroup': 'boolean',
            'accountIds': '*'
          },
          'amiName': '*',
          'amiTargetAccountIds': '*',
          'ssmParameters': {
            'amiAccount': '*',
            'dataType': 'ParameterDataType',
            'parameter': {
              'stringValue': '*',
              'parameterArn': '*',
              'parameterName': '*',
              'parameterType': '*'
            }
          },
          'launchTemplates': {
            'launchTemplate': {
              'versionNumber': '*',
              'launchTemplateId': '*',
              'launchTemplateName': '*'
            },
            'accountId': '*',
            'setDefaultVersion': 'boolean'
          },
          'fastLaunchConfigurations': {
            'enabled': 'boolean',
            'maxParallelLaunches': '*',
            'targetSnapshotCount': '*'
          },
          'licenseConfigurationArns': '*'
        }
      ],
      'addContainerDistributions': [
        {
          'region': '*',
          'containerRepository': '*',
          'containerDescription': '*',
          'containerTags': '*'
        }
      ]
    },
    'ImagePipeline': {
      'recipe': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'imagePipelineName': '*',
      'description': '*',
      'schedule': {
        'expression': '*',
        'autoDisableFailureCount': '*',
        'startCondition': 'ScheduleStartCondition'
      },
      'status': 'ImagePipelineStatus',
      'infrastructureConfiguration': {
        'infrastructureConfigurationArn': '*',
        'infrastructureConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'distributionConfiguration': {
        'distributionConfigurationArn': '*',
        'distributionConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'workflows': {
        'workflow': {
          'workflowArn': '*',
          'workflowName': '*',
          'workflowType': '*',
          'workflowVersion': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'onFailure': 'WorkflowOnFailure',
        'parallelGroup': '*',
        'parameters': '*'
      },
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'imagePipelineLogGroup': {
        'logGroupArn': '*',
        'logGroupName': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'stack': '*',
        'node': '*'
      },
      'imageLogGroup': {
        'logGroupArn': '*',
        'logGroupName': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'stack': '*',
        'node': '*'
      },
      'imageScanningEnabled': 'boolean',
      'imageScanningEcrRepository': {
        'repositoryName': '*',
        'repositoryArn': '*',
        'repositoryUri': '*',
        'registryUri': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'imageScanningEcrTags': '*',
      'enhancedImageMetadataEnabled': 'boolean',
      'imageTestsEnabled': 'boolean',
      'tags': '*',
      'grantDefaultExecutionRolePermissions': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'ImageRecipe': {
      'baseImage': '*',
      'imageRecipeName': '*',
      'imageRecipeVersion': '*',
      'description': '*',
      'components': {
        'component': {
          'componentArn': '*',
          'componentName': '*',
          'componentVersion': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'parameters': '*'
      },
      'amiTags': '*',
      'blockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'workingDirectory': '*',
      'uninstallSsmAgentAfterBuild': 'boolean',
      'userDataOverride': '*',
      'tags': '*',
      'addBlockDevice': [
        {
          'deviceName': '*',
          'volume': '*',
          'mappingEnabled': 'boolean'
        }
      ]
    },
    'Image': {
      'recipe': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'infrastructureConfiguration': {
        'infrastructureConfigurationArn': '*',
        'infrastructureConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'distributionConfiguration': {
        'distributionConfigurationArn': '*',
        'distributionConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'workflows': {
        'workflow': {
          'workflowArn': '*',
          'workflowName': '*',
          'workflowType': '*',
          'workflowVersion': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'onFailure': 'WorkflowOnFailure',
        'parallelGroup': '*',
        'parameters': '*'
      },
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logGroup': {
        'logGroupArn': '*',
        'logGroupName': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'stack': '*',
        'node': '*'
      },
      'imageScanningEnabled': 'boolean',
      'imageScanningEcrRepository': {
        'repositoryName': '*',
        'repositoryArn': '*',
        'repositoryUri': '*',
        'registryUri': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'imageScanningEcrTags': '*',
      'enhancedImageMetadataEnabled': 'boolean',
      'imageTestsEnabled': 'boolean',
      'deletionExecutionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'grantDefaultExecutionRolePermissions': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'InfrastructureConfiguration': {
      'infrastructureConfigurationName': '*',
      'description': '*',
      'instanceTypes': '*',
      'instanceProfile': {
        'instanceProfileName': '*',
        'instanceProfileArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'keyPair': {
        'keyPairName': '*',
        'type': 'KeyPairType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'terminateInstanceOnFailure': 'boolean',
      'httpPutResponseHopLimit': '*',
      'httpTokens': 'HttpTokens',
      'notificationTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'logging': {
        's3Bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        's3KeyPrefix': '*'
      },
      'ec2InstanceAvailabilityZone': '*',
      'ec2InstanceHostId': '*',
      'ec2InstanceHostResourceGroupArn': '*',
      'ec2InstanceTenancy': 'Tenancy',
      'resourceTags': '*',
      'tags': '*',
      '_bind': [
        {
          'isContainerBuild': 'boolean'
        }
      ]
    },
    'LifecyclePolicy': {
      'resourceType': 'LifecyclePolicyResourceType',
      'details': {
        'action': {
          'type': 'LifecyclePolicyActionType',
          'includeAmis': 'boolean',
          'includeContainers': 'boolean',
          'includeSnapshots': 'boolean'
        },
        'filter': {
          'ageFilter': {
            'age': '*',
            'retainAtLeast': '*'
          },
          'countFilter': {
            'count': '*'
          }
        },
        'exclusionRules': {
          'imageExclusionRules': {
            'tags': '*'
          },
          'amiExclusionRules': {
            'isPublic': 'boolean',
            'regions': '*',
            'sharedAccounts': '*',
            'tags': '*'
          }
        }
      },
      'resourceSelection': {
        'recipes': {
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'tags': '*'
      },
      'lifecyclePolicyName': '*',
      'description': '*',
      'status': 'LifecyclePolicyStatus',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*'
    },
    'Workflow': {
      'data': '*',
      'workflowType': 'WorkflowType',
      'workflowName': '*',
      'workflowVersion': '*',
      'description': '*',
      'changeDescription': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*'
    }
  },
  '@aws-cdk.aws-iot-alpha': {
    'AccountAuditConfiguration': {},
    'Logging': {},
    'ScheduledAudit': {
      'auditChecks': 'AuditCheck',
      'accountAuditConfiguration': {
        'accountId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'dayOfWeek': 'DayOfWeek',
      'dayOfMonth': '*',
      'frequency': 'Frequency',
      'scheduledAuditName': '*'
    },
    'TopicRule': {
      'topicRuleName': '*',
      'actions': '*',
      'description': '*',
      'errorAction': '*',
      'enabled': 'boolean',
      'sql': '*',
      'addAction': [
        '*'
      ]
    }
  },
  '@aws-cdk.aws-iotevents-alpha': {
    'DetectorModel': {
      'detectorModelName': '*',
      'description': '*',
      'evaluationMethod': 'EventEvaluation',
      'detectorKey': '*',
      'initialState': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'Input': {
      'inputName': '*',
      'attributeJsonPaths': '*'
    }
  },
  '@aws-cdk.aws-ivs-alpha': {
    'Channel': {
      'authorized': 'boolean',
      'containerFormat': 'ContainerFormat',
      'insecureIngest': 'boolean',
      'latencyMode': 'LatencyMode',
      'channelName': '*',
      'multitrackInputConfiguration': {
        'maximumResolution': 'MaximumResolution',
        'policy': 'Policy'
      },
      'type': 'ChannelType',
      'preset': 'Preset',
      'recordingConfiguration': {
        'recordingConfigurationId': '*',
        'recordingConfigurationArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'PlaybackKeyPair': {
      'publicKeyMaterial': '*',
      'playbackKeyPairName': '*'
    },
    'RecordingConfiguration': {
      'bucket': '*',
      'recordingConfigurationName': '*',
      'recordingReconnectWindow': '*',
      'renditionConfiguration': '*',
      'thumbnailConfiguration': '*'
    },
    'StreamKey': {
      'channel': {
        'channelArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    }
  },
  '@aws-cdk.aws-kinesisanalytics-flink-alpha': {
    'Import': {
      'applicationArn': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      }
    },
    'Application': {
      'applicationName': '*',
      'runtime': '*',
      'code': '*',
      'checkpointingEnabled': 'boolean',
      'checkpointInterval': '*',
      'minPauseBetweenCheckpoints': '*',
      'logLevel': 'LogLevel',
      'metricsLevel': 'MetricsLevel',
      'autoScalingEnabled': 'boolean',
      'parallelism': '*',
      'parallelismPerKpu': '*',
      'snapshotsEnabled': 'boolean',
      'propertyGroups': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'removalPolicy': 'RemovalPolicy',
      'logGroup': {
        'logGroupArn': '*',
        'logGroupName': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'stack': '*',
        'node': '*'
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      }
    }
  },
  '@aws-cdk.aws-lambda-go-alpha': {
    'GoFunction': {
      'entry': '*',
      'runtime': '*',
      'moduleDir': '*',
      'bundling': {
        'forcedDockerBundling': 'boolean',
        'dockerImage': '*',
        'goBuildFlags': '*',
        'buildArgs': '*',
        'assetHashType': 'AssetHashType',
        'assetHash': '*',
        'commandHooks': '*',
        'cgoEnabled': 'boolean',
        'goProxies': '*',
        'bundlingFileAccess': 'BundlingFileAccess',
        'entrypoint': '*',
        'command': '*',
        'volumes': {
          'hostPath': '*',
          'containerPath': '*',
          'consistency': 'DockerVolumeConsistency'
        },
        'volumesFrom': '*',
        'environment': '*',
        'workingDirectory': '*',
        'user': '*',
        'securityOpt': '*',
        'network': '*',
        'platform': '*'
      },
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*'
    }
  },
  '@aws-cdk.aws-lambda-python-alpha': {
    'PythonFunction': {
      'entry': '*',
      'runtime': '*',
      'index': '*',
      'handler': '*',
      'bundling': {
        'poetryIncludeHashes': 'boolean',
        'poetryWithoutUrls': 'boolean',
        'assetExcludes': '*',
        'outputPathSuffix': '*',
        'image': '*',
        'buildArgs': '*',
        'assetHashType': 'AssetHashType',
        'assetHash': '*',
        'commandHooks': '*',
        'bundlingFileAccess': 'BundlingFileAccess',
        'entrypoint': '*',
        'command': '*',
        'volumes': {
          'hostPath': '*',
          'containerPath': '*',
          'consistency': 'DockerVolumeConsistency'
        },
        'volumesFrom': '*',
        'environment': '*',
        'workingDirectory': '*',
        'user': '*',
        'securityOpt': '*',
        'network': '*',
        'platform': '*'
      },
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*'
    },
    'PythonLayerVersion': {
      'entry': '*',
      'compatibleRuntimes': '*',
      'compatibleArchitectures': '*',
      'bundling': {
        'poetryIncludeHashes': 'boolean',
        'poetryWithoutUrls': 'boolean',
        'assetExcludes': '*',
        'outputPathSuffix': '*',
        'image': '*',
        'buildArgs': '*',
        'assetHashType': 'AssetHashType',
        'assetHash': '*',
        'commandHooks': '*',
        'bundlingFileAccess': 'BundlingFileAccess',
        'entrypoint': '*',
        'command': '*',
        'volumes': {
          'hostPath': '*',
          'containerPath': '*',
          'consistency': 'DockerVolumeConsistency'
        },
        'volumesFrom': '*',
        'environment': '*',
        'workingDirectory': '*',
        'user': '*',
        'securityOpt': '*',
        'network': '*',
        'platform': '*'
      },
      'description': '*',
      'license': '*',
      'layerVersionName': '*',
      'removalPolicy': 'RemovalPolicy'
    }
  },
  '@aws-cdk.aws-location-alpha': {
    'ApiKey': {
      'apiKeyName': '*',
      'description': '*',
      'expireTime': '*',
      'forceDelete': 'boolean',
      'forceUpdate': 'boolean',
      'noExpiry': 'boolean',
      'allowMapsActions': 'AllowMapsAction',
      'allowPlacesActions': 'AllowPlacesAction',
      'allowRoutesActions': 'AllowRoutesAction',
      'allowReferers': '*'
    },
    'GeofenceCollection': {
      'geofenceCollectionName': '*',
      'description': '*',
      'kmsKey': '*',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantRead': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'Map': {
      'mapName': '*',
      'description': '*',
      'style': 'Style',
      'customLayers': 'CustomLayer',
      'politicalView': 'PoliticalView',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantRendering': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'PlaceIndex': {
      'placeIndexName': '*',
      'dataSource': 'DataSource',
      'intendedUse': 'IntendedUse',
      'description': '*',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantSearch': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'RouteCalculator': {
      'routeCalculatorName': '*',
      'dataSource': 'DataSource',
      'description': '*',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantRead': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'Tracker': {
      'trackerName': '*',
      'description': '*',
      'eventBridgeEnabled': 'boolean',
      'kmsKey': '*',
      'kmsKeyEnableGeospatialQueries': 'boolean',
      'positionFiltering': 'PositionFiltering',
      'geofenceCollections': {
        'geofenceCollectionName': '*',
        'geofenceCollectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addGeofenceCollections': [
        {
          'geofenceCollectionName': '*',
          'geofenceCollectionArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantUpdateDevicePositions': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantRead': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    }
  },
  '@aws-cdk.aws-msk-alpha': {
    'Cluster': {
      'clusterName': '*',
      'kafkaVersion': '*',
      'numberOfBrokerNodes': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'instanceType': '*',
      'brokerType': 'BrokerType',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'ebsStorageInfo': {
        'volumeSize': '*',
        'encryptionKey': '*'
      },
      'storageMode': 'StorageMode',
      'configurationInfo': {
        'arn': '*',
        'revision': '*'
      },
      'monitoring': {
        'clusterMonitoringLevel': 'ClusterMonitoringLevel',
        'enablePrometheusJmxExporter': 'boolean',
        'enablePrometheusNodeExporter': 'boolean'
      },
      'logging': {
        'firehoseDeliveryStreamName': '*',
        'cloudwatchLogGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        's3': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*'
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'prefix': '*'
        }
      },
      'encryptionInTransit': {
        'clientBroker': 'ClientBrokerEncryption',
        'enableInCluster': 'boolean'
      },
      'clientAuthentication': '*',
      'removalPolicy': 'RemovalPolicy',
      'addUser': [
        '*'
      ]
    },
    'ServerlessCluster': {
      'clusterName': '*',
      'vpcConfigs': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'vpcSubnets': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*'
        },
        'securityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      }
    }
  },
  '@aws-cdk.aws-neptune-alpha': {
    'DatabaseCluster': {
      'engineVersion': '*',
      'backupRetention': '*',
      'preferredBackupWindow': '*',
      'kmsKey': '*',
      'storageEncrypted': 'boolean',
      'instances': '*',
      'dbClusterName': '*',
      'iamAuthentication': 'boolean',
      'instanceIdentifierBase': '*',
      'instanceType': '*',
      'associatedRoles': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'deletionProtection': 'boolean',
      'preferredMaintenanceWindow': '*',
      'clusterParameterGroup': {
        'clusterParameterGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'parameterGroup': {
        'parameterGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'subnetGroup': {
        'subnetGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'autoMinorVersionUpgrade': 'boolean',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'serverlessScalingConfiguration': {
        'minCapacity': '*',
        'maxCapacity': '*'
      },
      'copyTagsToSnapshot': 'boolean',
      'port': '*'
    },
    'DatabaseInstance': {
      'cluster': {
        'clusterIdentifier': '*',
        'clusterResourceIdentifier': '*',
        'clusterEndpoint': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'instanceType': '*',
      'availabilityZone': '*',
      'dbInstanceName': '*',
      'parameterGroup': {
        'parameterGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'removalPolicy': 'RemovalPolicy',
      'autoMinorVersionUpgrade': 'boolean'
    },
    'ClusterParameterGroup': {
      'clusterParameterGroupName': '*',
      'description': '*',
      'parameters': '*',
      'family': '*'
    },
    'ParameterGroup': {
      'parameterGroupName': '*',
      'description': '*',
      'parameters': '*',
      'family': '*'
    },
    'SubnetGroup': {
      'description': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetGroupName': '*',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'removalPolicy': 'RemovalPolicy'
    }
  },
  '@aws-cdk.aws-pipes-alpha': {
    'ImportedPipe': {},
    'Pipe': {
      'source': {
        'sourceArn': '*'
      },
      'filter': {
        'filters': {
          'pattern': '*'
        }
      },
      'enrichment': {
        'enrichmentArn': '*'
      },
      'target': {
        'targetArn': '*'
      },
      'pipeName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logDestinations': '*',
      'logLevel': 'LogLevel',
      'logIncludeExecutionData': 'IncludeExecutionData',
      'description': '*',
      'desiredState': 'DesiredState',
      'tags': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    }
  },
  '@aws-cdk.aws-redshift-alpha': {
    'Cluster': {
      'clusterName': '*',
      'parameterGroup': {
        'clusterParameterGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'numberOfNodes': '*',
      'nodeType': 'NodeType',
      'clusterType': 'ClusterType',
      'port': '*',
      'encrypted': 'boolean',
      'encryptionKey': '*',
      'preferredMaintenanceWindow': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'subnetGroup': {
        'clusterSubnetGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'masterUser': {
        'masterUsername': '*',
        'masterPassword': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'excludeCharacters': '*'
      },
      'roles': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'defaultRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'defaultDatabaseName': '*',
      'loggingProperties': {
        'loggingBucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'loggingKeyPrefix': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'publiclyAccessible': 'boolean',
      'classicResizing': 'boolean',
      'elasticIp': '*',
      'rebootForParameterChanges': 'boolean',
      'enhancedVpcRouting': 'boolean',
      'multiAz': 'boolean',
      'resourceAction': 'ResourceAction',
      'availabilityZoneRelocation': 'boolean',
      'maintenanceTrackName': 'MaintenanceTrackName',
      'addRotationSingleUser': [
        '*'
      ],
      'addRotationMultiUser': [
        '*',
        {
          'secret': {
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'secretArn': '*',
            'secretFullArn': '*',
            'secretName': '*',
            'secretValue': '*'
          },
          'automaticallyAfter': '*'
        }
      ],
      'addToParameterGroup': [
        '*',
        '*'
      ],
      'enableRebootForParameterChanges': [],
      'addDefaultIamRole': [
        {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'addIamRole': [
        {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'DatabaseSecret': {
      'username': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'excludeCharacters': '*'
    },
    'ClusterParameterGroup': {
      'description': '*',
      'parameters': '*',
      'addParameter': [
        '*',
        '*'
      ]
    },
    'ClusterSubnetGroup': {
      'description': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'removalPolicy': 'RemovalPolicy'
    }
  },
  '@aws-cdk.aws-route53resolver-alpha': {
    'FirewallDomainList': {
      'name': '*',
      'domains': '*'
    },
    'FirewallRuleGroupAssociation': {
      'firewallRuleGroup': {
        'firewallRuleGroupId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'mutationProtection': 'boolean',
      'name': '*',
      'priority': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      }
    },
    'FirewallRuleGroup': {
      'name': '*',
      'rules': {
        'action': '*',
        'firewallDomainList': {
          'firewallDomainListId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'priority': '*'
      },
      'addRule': [
        {
          'action': '*',
          'firewallDomainList': {
            'firewallDomainListId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'priority': '*'
        }
      ],
      'associate': [
        '*',
        {
          'mutationProtection': 'boolean',
          'name': '*',
          'priority': '*',
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          }
        }
      ]
    }
  },
  '@aws-cdk.aws-s3objectlambda-alpha': {
    'AccessPoint': {
      'bucket': '*',
      'handler': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'accessPointName': '*',
      'cloudWatchMetricsEnabled': 'boolean',
      'supportsGetObjectRange': 'boolean',
      'supportsGetObjectPartNumber': 'boolean',
      'payload': '*'
    }
  },
  '@aws-cdk.aws-s3tables-alpha': {
    'Namespace': {
      'namespaceName': '*',
      'tableBucket': {
        'tableBucketArn': '*',
        'tableBucketName': '*',
        'account': '*',
        'region': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'removalPolicy': 'RemovalPolicy'
    },
    'TableBucketPolicy': {
      'tableBucket': {
        'tableBucketArn': '*',
        'tableBucketName': '*',
        'account': '*',
        'region': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'resourcePolicy': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'TableBucket': {
      'tableBucketName': '*',
      'unreferencedFileRemoval': {
        'noncurrentDays': '*',
        'status': 'UnreferencedFileRemovalStatus',
        'unreferencedDays': '*'
      },
      'region': '*',
      'account': '*',
      'encryption': 'TableBucketEncryption',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'removalPolicy': 'RemovalPolicy',
      'requestMetricsStatus': 'RequestMetricsStatus'
    },
    'TablePolicy': {
      'table': {
        'tableArn': '*',
        'tableName': '*',
        'account': '*',
        'region': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'resourcePolicy': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'Table': {
      'tableName': '*',
      'namespace': {
        'namespaceName': '*',
        'tableBucket': {
          'tableBucketArn': '*',
          'tableBucketName': '*',
          'account': '*',
          'region': '*',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      },
      'openTableFormat': 'OpenTableFormat',
      'compaction': {
        'status': 'Status',
        'targetFileSizeMb': '*'
      },
      'icebergMetadata': {
        'icebergSchema': {
          'schemaFieldList': {
            'id': '*',
            'name': '*',
            'required': 'boolean',
            'type': '*'
          }
        },
        'icebergPartitionSpec': {
          'fields': {
            'sourceId': '*',
            'transform': '*',
            'name': '*',
            'fieldId': '*'
          },
          'specId': '*'
        },
        'icebergSortOrder': {
          'fields': {
            'sourceId': '*',
            'direction': 'SortDirection',
            'nullOrder': 'NullOrder'
          },
          'orderId': '*'
        },
        'tableProperties': {
          'key': '*',
          'value': '*'
        }
      },
      'snapshotManagement': {
        'maxSnapshotAgeHours': '*',
        'minSnapshotsToKeep': '*',
        'status': 'Status'
      },
      'removalPolicy': 'RemovalPolicy',
      'withoutMetadata': 'boolean'
    }
  },
  '@aws-cdk.aws-sagemaker-alpha': {
    'EndpointConfig': {
      'endpointConfigName': '*',
      'encryptionKey': '*',
      'instanceProductionVariants': {
        'acceleratorType': '*',
        'initialInstanceCount': '*',
        'instanceType': '*',
        'containerStartupHealthCheckTimeout': '*',
        'initialVariantWeight': '*',
        'model': {
          'modelArn': '*',
          'modelName': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'connections': '*'
        },
        'variantName': '*'
      },
      'serverlessProductionVariant': {
        'maxConcurrency': '*',
        'memorySizeInMB': '*',
        'provisionedConcurrency': '*',
        'initialVariantWeight': '*',
        'model': {
          'modelArn': '*',
          'modelName': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'connections': '*'
        },
        'variantName': '*'
      },
      'addInstanceProductionVariant': [
        {
          'acceleratorType': '*',
          'initialInstanceCount': '*',
          'instanceType': '*',
          'containerStartupHealthCheckTimeout': '*',
          'initialVariantWeight': '*',
          'model': {
            'modelArn': '*',
            'modelName': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'connections': '*'
          },
          'variantName': '*'
        }
      ],
      'addServerlessProductionVariant': [
        {
          'maxConcurrency': '*',
          'memorySizeInMB': '*',
          'provisionedConcurrency': '*',
          'initialVariantWeight': '*',
          'model': {
            'modelArn': '*',
            'modelName': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'connections': '*'
          },
          'variantName': '*'
        }
      ],
      '_findInstanceProductionVariant': [
        '*'
      ]
    },
    'Endpoint': {
      'endpointName': '*',
      'endpointConfig': {
        'endpointConfigArn': '*',
        'endpointConfigName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'findInstanceProductionVariant': [
        '*'
      ]
    },
    'Model': {
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'modelName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'containers': {
        'image': '*',
        'environment': '*',
        'containerHostname': '*',
        'modelData': '*'
      },
      'allowAllOutbound': 'boolean',
      'networkIsolation': 'boolean',
      'addContainer': [
        {
          'image': '*',
          'environment': '*',
          'containerHostname': '*',
          'modelData': '*'
        }
      ]
    },
    'Pipeline': {
      'grantStartPipelineExecution': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    }
  },
  '@aws-cdk.aws-servicecatalogappregistry-alpha': {
    'Application': {
      'applicationName': '*',
      'description': '*'
    },
    'AttributeGroup': {
      'attributeGroupName': '*',
      'description': '*',
      'attributes': '*'
    }
  },
  '@aws-cdk.example-construct-library': {
    'ExampleResource': {
      'waitConditionHandleName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'bucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'removalPolicy': 'RemovalPolicy'
    }
  },
  'aws-cdk-lib.aws-apigateway': {
    'ApiKey': {
      'resources': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'stages': {
        'stageName': '*',
        'restApi': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        }
      },
      'customerId': '*',
      'enabled': 'boolean',
      'generateDistinctId': 'boolean',
      'apiKeyName': '*',
      'value': '*',
      'description': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      }
    },
    'RateLimitedApiKey': {
      'apiStages': {
        'api': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        },
        'throttle': {
          'method': '*',
          'throttle': {
            'rateLimit': '*',
            'burstLimit': '*'
          }
        }
      },
      'quota': {
        'limit': '*',
        'offset': '*',
        'period': 'Period'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'resources': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'stages': {
        'stageName': '*',
        'restApi': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        }
      },
      'customerId': '*',
      'enabled': 'boolean',
      'generateDistinctId': 'boolean',
      'apiKeyName': '*',
      'value': '*',
      'description': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      }
    },
    'BasePathMapping': {
      'domainName': '*',
      'restApi': '*',
      'basePath': '*',
      'stage': '*',
      'attachToStage': 'boolean'
    },
    'Deployment': {
      'api': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'description': '*',
      'retainDeployments': 'boolean',
      'stageName': '*',
      'addToLogicalId': [
        '*'
      ],
      '_addMethodDependency': [
        '*'
      ]
    },
    'DomainName': {
      'mapping': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'domainName': '*',
      'certificate': '*',
      'endpointType': 'EndpointType',
      'securityPolicy': 'SecurityPolicy',
      'endpointAccessMode': 'EndpointAccessMode',
      'mtls': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'key': '*',
        'version': '*'
      },
      'basePath': '*',
      'addBasePathMapping': [
        '*',
        {
          'basePath': '*',
          'stage': '*',
          'attachToStage': 'boolean'
        }
      ],
      'addApiMapping': [
        '*',
        {
          'basePath': '*'
        }
      ]
    },
    'GatewayResponse': {
      'restApi': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'type': '*',
      'statusCode': '*',
      'responseHeaders': '*',
      'templates': '*'
    },
    'LambdaRestApi': {
      'handler': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'integrationOptions': {
        'proxy': 'boolean',
        'allowTestInvoke': 'boolean',
        'scopePermissionToMethod': 'boolean',
        'cacheKeyParameters': '*',
        'cacheNamespace': '*',
        'contentHandling': 'ContentHandling',
        'credentialsRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'credentialsPassthrough': 'boolean',
        'passthroughBehavior': 'PassthroughBehavior',
        'requestParameters': '*',
        'requestTemplates': '*',
        'timeout': '*',
        'integrationResponses': {
          'selectionPattern': '*',
          'statusCode': '*',
          'contentHandling': 'ContentHandling',
          'responseParameters': '*',
          'responseTemplates': '*'
        },
        'connectionType': 'ConnectionType',
        'vpcLink': {
          'vpcLinkId': '*'
        },
        'responseTransferMode': 'ResponseTransferMode'
      },
      'proxy': 'boolean',
      'options': {
        'binaryMediaTypes': '*',
        'minimumCompressionSize': '*',
        'minCompressionSize': '*',
        'cloneFrom': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        },
        'apiKeySourceType': 'ApiKeySourceType',
        'deploy': 'boolean',
        'deployOptions': {
          'stageName': '*',
          'accessLogDestination': '*',
          'accessLogFormat': '*',
          'tracingEnabled': 'boolean',
          'cacheClusterEnabled': 'boolean',
          'cacheClusterSize': '*',
          'clientCertificateId': '*',
          'description': '*',
          'documentationVersion': '*',
          'variables': '*',
          'methodOptions': '*',
          'metricsEnabled': 'boolean',
          'loggingLevel': 'MethodLoggingLevel',
          'dataTraceEnabled': 'boolean',
          'throttlingBurstLimit': '*',
          'throttlingRateLimit': '*',
          'cachingEnabled': 'boolean',
          'cacheDataEncrypted': 'boolean'
        },
        'retainDeployments': 'boolean',
        'restApiName': '*',
        'parameters': '*',
        'policy': '*',
        'failOnWarnings': 'boolean',
        'domainName': {
          'domainName': '*',
          'certificate': '*',
          'endpointType': 'EndpointType',
          'securityPolicy': 'SecurityPolicy',
          'endpointAccessMode': 'EndpointAccessMode',
          'mtls': {
            'bucket': {
              'bucketArn': '*',
              'bucketName': '*',
              'bucketWebsiteUrl': '*',
              'bucketWebsiteDomainName': '*',
              'bucketDomainName': '*',
              'bucketDualStackDomainName': '*',
              'bucketRegionalDomainName': '*',
              'isWebsite': 'boolean',
              'encryptionKey': {
                'keyArn': '*',
                'keyId': '*'
              },
              'policy': '*',
              'replicationRoleArn': '*'
            },
            'key': '*',
            'version': '*'
          },
          'basePath': '*'
        },
        'cloudWatchRole': 'boolean',
        'cloudWatchRoleRemovalPolicy': 'RemovalPolicy',
        'endpointExportName': '*',
        'endpointTypes': 'EndpointType',
        'endpointConfiguration': {
          'types': 'EndpointType',
          'vpcEndpoints': {
            'vpcEndpointId': '*'
          },
          'ipAddressType': 'IpAddressType'
        },
        'disableExecuteApiEndpoint': 'boolean',
        'description': '*'
      },
      'binaryMediaTypes': '*',
      'minimumCompressionSize': '*',
      'minCompressionSize': '*',
      'cloneFrom': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'apiKeySourceType': 'ApiKeySourceType',
      'deploy': 'boolean',
      'deployOptions': {
        'stageName': '*',
        'accessLogDestination': '*',
        'accessLogFormat': '*',
        'tracingEnabled': 'boolean',
        'cacheClusterEnabled': 'boolean',
        'cacheClusterSize': '*',
        'clientCertificateId': '*',
        'description': '*',
        'documentationVersion': '*',
        'variables': '*',
        'methodOptions': '*',
        'metricsEnabled': 'boolean',
        'loggingLevel': 'MethodLoggingLevel',
        'dataTraceEnabled': 'boolean',
        'throttlingBurstLimit': '*',
        'throttlingRateLimit': '*',
        'cachingEnabled': 'boolean',
        'cacheTtl': '*',
        'cacheDataEncrypted': 'boolean'
      },
      'retainDeployments': 'boolean',
      'restApiName': '*',
      'parameters': '*',
      'policy': '*',
      'failOnWarnings': 'boolean',
      'domainName': {
        'domainName': '*',
        'certificate': '*',
        'endpointType': 'EndpointType',
        'securityPolicy': 'SecurityPolicy',
        'endpointAccessMode': 'EndpointAccessMode',
        'mtls': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'key': '*',
          'version': '*'
        },
        'basePath': '*'
      },
      'cloudWatchRole': 'boolean',
      'cloudWatchRoleRemovalPolicy': 'RemovalPolicy',
      'endpointExportName': '*',
      'endpointTypes': 'EndpointType',
      'endpointConfiguration': {
        'types': 'EndpointType',
        'vpcEndpoints': {
          'vpcEndpointId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'ipAddressType': 'IpAddressType'
      },
      'disableExecuteApiEndpoint': 'boolean',
      'description': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      }
    },
    'Method': {
      'resource': {
        'restApi': '*',
        'api': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'resourceId': '*',
        'path': '*',
        'defaultIntegration': '*',
        'defaultMethodOptions': {
          'operationName': '*',
          'authorizationType': 'AuthorizationType',
          'authorizer': {
            'authorizerId': '*',
            'authorizationType': 'AuthorizationType'
          },
          'apiKeyRequired': 'boolean',
          'methodResponses': {
            'statusCode': '*',
            'responseParameters': '*',
            'responseModels': '*'
          },
          'requestParameters': '*',
          'requestModels': '*',
          'requestValidator': {
            'requestValidatorId': '*'
          },
          'authorizationScopes': '*',
          'requestValidatorOptions': {
            'requestValidatorName': '*',
            'validateRequestBody': 'boolean',
            'validateRequestParameters': 'boolean'
          }
        },
        'defaultCorsPreflightOptions': {
          'statusCode': '*',
          'allowOrigins': '*',
          'allowHeaders': '*',
          'allowMethods': '*',
          'allowCredentials': 'boolean',
          'maxAge': '*',
          'disableCache': 'boolean',
          'exposeHeaders': '*'
        }
      },
      'httpMethod': '*',
      'integration': '*',
      'options': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'addMethodResponse': [
        {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        }
      ],
      'metric': [
        '*',
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricClientError': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricServerError': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricCacheHitCount': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricCacheMissCount': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricCount': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricIntegrationLatency': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricLatency': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'grantExecute': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'Model': {
      'restApi': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'contentType': '*',
      'description': '*',
      'modelName': '*',
      'schema': {
        'schema': 'JsonSchemaVersion',
        'id': '*',
        'ref': '*',
        'type': 'JsonSchemaType',
        'title': '*',
        'description': '*',
        'enum': '*',
        'default': '*',
        'format': '*',
        'definitions': '*',
        'multipleOf': '*',
        'maximum': '*',
        'exclusiveMaximum': 'boolean',
        'minimum': '*',
        'exclusiveMinimum': 'boolean',
        'maxLength': '*',
        'minLength': '*',
        'pattern': '*',
        'additionalItems': 'boolean',
        'maxItems': '*',
        'minItems': '*',
        'uniqueItems': 'boolean',
        'maxProperties': '*',
        'minProperties': '*',
        'required': '*',
        'properties': '*',
        'additionalProperties': 'boolean',
        'patternProperties': '*',
        'dependencies': '*'
      }
    },
    'RequestValidator': {
      'restApi': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'requestValidatorName': '*',
      'validateRequestBody': 'boolean',
      'validateRequestParameters': 'boolean'
    },
    'Resource': {
      'parent': {
        'restApi': '*',
        'api': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'resourceId': '*',
        'path': '*',
        'defaultIntegration': '*',
        'defaultMethodOptions': {
          'operationName': '*',
          'authorizationType': 'AuthorizationType',
          'authorizer': {
            'authorizerId': '*',
            'authorizationType': 'AuthorizationType'
          },
          'apiKeyRequired': 'boolean',
          'methodResponses': {
            'statusCode': '*',
            'responseParameters': '*',
            'responseModels': '*'
          },
          'requestParameters': '*',
          'requestModels': '*',
          'requestValidator': {
            'requestValidatorId': '*'
          },
          'authorizationScopes': '*',
          'requestValidatorOptions': {
            'requestValidatorName': '*',
            'validateRequestBody': 'boolean',
            'validateRequestParameters': 'boolean'
          }
        },
        'defaultCorsPreflightOptions': {
          'statusCode': '*',
          'allowOrigins': '*',
          'allowHeaders': '*',
          'allowMethods': '*',
          'allowCredentials': 'boolean',
          'maxAge': '*',
          'disableCache': 'boolean',
          'exposeHeaders': '*'
        }
      },
      'pathPart': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      }
    },
    'ProxyResource': {
      'parent': {
        'restApi': '*',
        'api': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'resourceId': '*',
        'path': '*',
        'defaultIntegration': '*',
        'defaultMethodOptions': {
          'operationName': '*',
          'authorizationType': 'AuthorizationType',
          'authorizer': {
            'authorizerId': '*',
            'authorizationType': 'AuthorizationType'
          },
          'apiKeyRequired': 'boolean',
          'methodResponses': {
            'statusCode': '*',
            'responseParameters': '*',
            'responseModels': '*'
          },
          'requestParameters': '*',
          'requestModels': '*',
          'requestValidator': {
            'requestValidatorId': '*'
          },
          'authorizationScopes': '*',
          'requestValidatorOptions': {
            'requestValidatorName': '*',
            'validateRequestBody': 'boolean',
            'validateRequestParameters': 'boolean'
          }
        },
        'defaultCorsPreflightOptions': {
          'statusCode': '*',
          'allowOrigins': '*',
          'allowHeaders': '*',
          'allowMethods': '*',
          'allowCredentials': 'boolean',
          'maxAge': '*',
          'disableCache': 'boolean',
          'exposeHeaders': '*'
        }
      },
      'anyMethod': 'boolean',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      },
      'addMethod': [
        '*',
        '*',
        {
          'operationName': '*',
          'authorizationType': 'AuthorizationType',
          'authorizer': {
            'authorizerId': '*',
            'authorizationType': 'AuthorizationType'
          },
          'apiKeyRequired': 'boolean',
          'methodResponses': {
            'statusCode': '*',
            'responseParameters': '*',
            'responseModels': '*'
          },
          'requestParameters': '*',
          'requestModels': '*',
          'requestValidator': {
            'requestValidatorId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'authorizationScopes': '*',
          'requestValidatorOptions': {
            'requestValidatorName': '*',
            'validateRequestBody': 'boolean',
            'validateRequestParameters': 'boolean'
          }
        }
      ]
    },
    'SpecRestApi': {
      'apiDefinition': '*',
      'binaryMediaTypes': '*',
      'minCompressionSize': '*',
      'mode': 'RestApiMode',
      'deploy': 'boolean',
      'deployOptions': {
        'stageName': '*',
        'accessLogDestination': '*',
        'accessLogFormat': '*',
        'tracingEnabled': 'boolean',
        'cacheClusterEnabled': 'boolean',
        'cacheClusterSize': '*',
        'clientCertificateId': '*',
        'description': '*',
        'documentationVersion': '*',
        'variables': '*',
        'methodOptions': '*',
        'metricsEnabled': 'boolean',
        'loggingLevel': 'MethodLoggingLevel',
        'dataTraceEnabled': 'boolean',
        'throttlingBurstLimit': '*',
        'throttlingRateLimit': '*',
        'cachingEnabled': 'boolean',
        'cacheTtl': '*',
        'cacheDataEncrypted': 'boolean'
      },
      'retainDeployments': 'boolean',
      'restApiName': '*',
      'parameters': '*',
      'policy': '*',
      'failOnWarnings': 'boolean',
      'domainName': {
        'domainName': '*',
        'certificate': '*',
        'endpointType': 'EndpointType',
        'securityPolicy': 'SecurityPolicy',
        'endpointAccessMode': 'EndpointAccessMode',
        'mtls': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'key': '*',
          'version': '*'
        },
        'basePath': '*'
      },
      'cloudWatchRole': 'boolean',
      'cloudWatchRoleRemovalPolicy': 'RemovalPolicy',
      'endpointExportName': '*',
      'endpointTypes': 'EndpointType',
      'endpointConfiguration': {
        'types': 'EndpointType',
        'vpcEndpoints': {
          'vpcEndpointId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'ipAddressType': 'IpAddressType'
      },
      'disableExecuteApiEndpoint': 'boolean',
      'description': '*',
      'addToResourcePolicy': [
        '*'
      ]
    },
    'RestApi': {
      'binaryMediaTypes': '*',
      'minimumCompressionSize': '*',
      'minCompressionSize': '*',
      'cloneFrom': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'apiKeySourceType': 'ApiKeySourceType',
      'deploy': 'boolean',
      'deployOptions': {
        'stageName': '*',
        'accessLogDestination': '*',
        'accessLogFormat': '*',
        'tracingEnabled': 'boolean',
        'cacheClusterEnabled': 'boolean',
        'cacheClusterSize': '*',
        'clientCertificateId': '*',
        'description': '*',
        'documentationVersion': '*',
        'variables': '*',
        'methodOptions': '*',
        'metricsEnabled': 'boolean',
        'loggingLevel': 'MethodLoggingLevel',
        'dataTraceEnabled': 'boolean',
        'throttlingBurstLimit': '*',
        'throttlingRateLimit': '*',
        'cachingEnabled': 'boolean',
        'cacheTtl': '*',
        'cacheDataEncrypted': 'boolean'
      },
      'retainDeployments': 'boolean',
      'restApiName': '*',
      'parameters': '*',
      'policy': '*',
      'failOnWarnings': 'boolean',
      'domainName': {
        'domainName': '*',
        'certificate': '*',
        'endpointType': 'EndpointType',
        'securityPolicy': 'SecurityPolicy',
        'endpointAccessMode': 'EndpointAccessMode',
        'mtls': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'key': '*',
          'version': '*'
        },
        'basePath': '*'
      },
      'cloudWatchRole': 'boolean',
      'cloudWatchRoleRemovalPolicy': 'RemovalPolicy',
      'endpointExportName': '*',
      'endpointTypes': 'EndpointType',
      'endpointConfiguration': {
        'types': 'EndpointType',
        'vpcEndpoints': {
          'vpcEndpointId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'ipAddressType': 'IpAddressType'
      },
      'disableExecuteApiEndpoint': 'boolean',
      'description': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      },
      'addToResourcePolicy': [
        '*'
      ],
      'addModel': [
        '*',
        {
          'contentType': '*',
          'description': '*',
          'modelName': '*',
          'schema': {
            'schema': 'JsonSchemaVersion',
            'id': '*',
            'ref': '*',
            'type': 'JsonSchemaType',
            'title': '*',
            'description': '*',
            'enum': '*',
            'default': '*',
            'format': '*',
            'definitions': '*',
            'multipleOf': '*',
            'maximum': '*',
            'exclusiveMaximum': 'boolean',
            'minimum': '*',
            'exclusiveMinimum': 'boolean',
            'maxLength': '*',
            'minLength': '*',
            'pattern': '*',
            'additionalItems': 'boolean',
            'maxItems': '*',
            'minItems': '*',
            'uniqueItems': 'boolean',
            'maxProperties': '*',
            'minProperties': '*',
            'required': '*',
            'properties': '*',
            'additionalProperties': 'boolean',
            'patternProperties': '*',
            'dependencies': '*'
          }
        }
      ],
      'addRequestValidator': [
        '*',
        {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      ],
      '_attachMethod': [
        '*'
      ],
      '_attachDeployment': [
        '*'
      ]
    },
    'RootResource': {},
    'Stage': {
      'deployment': '*',
      'stageName': '*',
      'accessLogDestination': '*',
      'accessLogFormat': '*',
      'tracingEnabled': 'boolean',
      'cacheClusterEnabled': 'boolean',
      'cacheClusterSize': '*',
      'clientCertificateId': '*',
      'description': '*',
      'documentationVersion': '*',
      'variables': '*',
      'methodOptions': '*',
      'metricsEnabled': 'boolean',
      'loggingLevel': 'MethodLoggingLevel',
      'dataTraceEnabled': 'boolean',
      'throttlingBurstLimit': '*',
      'throttlingRateLimit': '*',
      'cachingEnabled': 'boolean',
      'cacheTtl': '*',
      'cacheDataEncrypted': 'boolean'
    },
    'StepFunctionsRestApi': {
      'stateMachine': {
        'stateMachineArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      },
      'requestContext': {
        'accountId': 'boolean',
        'apiId': 'boolean',
        'apiKey': 'boolean',
        'authorizerPrincipalId': 'boolean',
        'caller': 'boolean',
        'cognitoAuthenticationProvider': 'boolean',
        'cognitoAuthenticationType': 'boolean',
        'cognitoIdentityId': 'boolean',
        'cognitoIdentityPoolId': 'boolean',
        'httpMethod': 'boolean',
        'stage': 'boolean',
        'sourceIp': 'boolean',
        'user': 'boolean',
        'userAgent': 'boolean',
        'userArn': 'boolean',
        'requestId': 'boolean',
        'resourceId': 'boolean',
        'resourcePath': 'boolean'
      },
      'querystring': 'boolean',
      'path': 'boolean',
      'headers': 'boolean',
      'authorizer': 'boolean',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'useDefaultMethodResponses': 'boolean',
      'binaryMediaTypes': '*',
      'minimumCompressionSize': '*',
      'minCompressionSize': '*',
      'cloneFrom': {
        'restApiId': '*',
        'restApiName': '*',
        'restApiRootResourceId': '*',
        'latestDeployment': '*',
        'deploymentStage': '*',
        'root': {
          'restApi': '*',
          'resourceId': '*',
          'path': '*',
          'defaultIntegration': '*',
          'defaultMethodOptions': {
            'operationName': '*',
            'authorizationType': 'AuthorizationType',
            'authorizer': {
              'authorizerId': '*',
              'authorizationType': 'AuthorizationType'
            },
            'apiKeyRequired': 'boolean',
            'methodResponses': {
              'statusCode': '*',
              'responseParameters': '*',
              'responseModels': '*'
            },
            'requestParameters': '*',
            'requestModels': '*',
            'requestValidator': {
              'requestValidatorId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'authorizationScopes': '*',
            'requestValidatorOptions': {
              'requestValidatorName': '*',
              'validateRequestBody': 'boolean',
              'validateRequestParameters': 'boolean'
            }
          },
          'defaultCorsPreflightOptions': {
            'statusCode': '*',
            'allowOrigins': '*',
            'allowHeaders': '*',
            'allowMethods': '*',
            'allowCredentials': 'boolean',
            'maxAge': '*',
            'disableCache': 'boolean',
            'exposeHeaders': '*'
          }
        }
      },
      'apiKeySourceType': 'ApiKeySourceType',
      'deploy': 'boolean',
      'deployOptions': {
        'stageName': '*',
        'accessLogDestination': '*',
        'accessLogFormat': '*',
        'tracingEnabled': 'boolean',
        'cacheClusterEnabled': 'boolean',
        'cacheClusterSize': '*',
        'clientCertificateId': '*',
        'description': '*',
        'documentationVersion': '*',
        'variables': '*',
        'methodOptions': '*',
        'metricsEnabled': 'boolean',
        'loggingLevel': 'MethodLoggingLevel',
        'dataTraceEnabled': 'boolean',
        'throttlingBurstLimit': '*',
        'throttlingRateLimit': '*',
        'cachingEnabled': 'boolean',
        'cacheTtl': '*',
        'cacheDataEncrypted': 'boolean'
      },
      'retainDeployments': 'boolean',
      'restApiName': '*',
      'parameters': '*',
      'policy': '*',
      'failOnWarnings': 'boolean',
      'domainName': {
        'domainName': '*',
        'certificate': '*',
        'endpointType': 'EndpointType',
        'securityPolicy': 'SecurityPolicy',
        'endpointAccessMode': 'EndpointAccessMode',
        'mtls': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'key': '*',
          'version': '*'
        },
        'basePath': '*'
      },
      'cloudWatchRole': 'boolean',
      'cloudWatchRoleRemovalPolicy': 'RemovalPolicy',
      'endpointExportName': '*',
      'endpointTypes': 'EndpointType',
      'endpointConfiguration': {
        'types': 'EndpointType',
        'vpcEndpoints': {
          'vpcEndpointId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'ipAddressType': 'IpAddressType'
      },
      'disableExecuteApiEndpoint': 'boolean',
      'description': '*',
      'defaultIntegration': '*',
      'defaultMethodOptions': {
        'operationName': '*',
        'authorizationType': 'AuthorizationType',
        'authorizer': {
          'authorizerId': '*',
          'authorizationType': 'AuthorizationType'
        },
        'apiKeyRequired': 'boolean',
        'methodResponses': {
          'statusCode': '*',
          'responseParameters': '*',
          'responseModels': '*'
        },
        'requestParameters': '*',
        'requestModels': '*',
        'requestValidator': {
          'requestValidatorId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'authorizationScopes': '*',
        'requestValidatorOptions': {
          'requestValidatorName': '*',
          'validateRequestBody': 'boolean',
          'validateRequestParameters': 'boolean'
        }
      },
      'defaultCorsPreflightOptions': {
        'statusCode': '*',
        'allowOrigins': '*',
        'allowHeaders': '*',
        'allowMethods': '*',
        'allowCredentials': 'boolean',
        'maxAge': '*',
        'disableCache': 'boolean',
        'exposeHeaders': '*'
      }
    },
    'UsagePlan': {
      'apiStages': {
        'api': {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        },
        'throttle': {
          'method': '*',
          'throttle': {
            'rateLimit': '*',
            'burstLimit': '*'
          }
        }
      },
      'description': '*',
      'quota': {
        'limit': '*',
        'offset': '*',
        'period': 'Period'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'name': '*',
      'apiKey': {
        'keyId': '*',
        'keyArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addApiStage': [
        {
          'api': {
            'restApiId': '*',
            'restApiName': '*',
            'restApiRootResourceId': '*',
            'latestDeployment': '*',
            'deploymentStage': '*',
            'root': {
              'restApi': '*',
              'resourceId': '*',
              'path': '*',
              'defaultIntegration': '*',
              'defaultMethodOptions': {
                'operationName': '*',
                'authorizationType': 'AuthorizationType',
                'authorizer': {
                  'authorizerId': '*',
                  'authorizationType': 'AuthorizationType'
                },
                'apiKeyRequired': 'boolean',
                'methodResponses': {
                  'statusCode': '*',
                  'responseParameters': '*',
                  'responseModels': '*'
                },
                'requestParameters': '*',
                'requestModels': '*',
                'requestValidator': {
                  'requestValidatorId': '*',
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'authorizationScopes': '*',
                'requestValidatorOptions': {
                  'requestValidatorName': '*',
                  'validateRequestBody': 'boolean',
                  'validateRequestParameters': 'boolean'
                }
              },
              'defaultCorsPreflightOptions': {
                'statusCode': '*',
                'allowOrigins': '*',
                'allowHeaders': '*',
                'allowMethods': '*',
                'allowCredentials': 'boolean',
                'maxAge': '*',
                'disableCache': 'boolean',
                'exposeHeaders': '*'
              }
            }
          },
          'throttle': {
            'method': '*',
            'throttle': {
              'rateLimit': '*',
              'burstLimit': '*'
            }
          }
        }
      ]
    },
    'VpcLink': {
      'vpcLinkName': '*',
      'description': '*',
      'targets': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'metrics': '*',
        'securityGroups': '*',
        'ipAddressType': 'IpAddressType',
        'enforceSecurityGroupInboundRulesOnPrivateLinkTraffic': '*',
        'loadBalancerCanonicalHostedZoneId': '*',
        'loadBalancerDnsName': '*',
        'loadBalancerArn': '*',
        'connections': '*'
      },
      'addTargets': [
        {
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'metrics': '*',
          'securityGroups': '*',
          'ipAddressType': 'IpAddressType',
          'enforceSecurityGroupInboundRulesOnPrivateLinkTraffic': '*',
          'loadBalancerCanonicalHostedZoneId': '*',
          'loadBalancerDnsName': '*',
          'loadBalancerArn': '*',
          'connections': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-appconfig': {
    'Application': {
      'applicationName': '*',
      'description': '*'
    },
    'DeploymentStrategy': {
      'rolloutStrategy': '*',
      'deploymentStrategyName': '*',
      'description': '*'
    },
    'Environment': {
      'application': {
        'description': '*',
        'name': '*',
        'applicationId': '*',
        'applicationArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'environmentName': '*',
      'description': '*',
      'monitors': '*',
      'deletionProtectionCheck': 'DeletionProtectionCheck'
    },
    'Extension': {
      'actions': '*',
      'extensionName': '*',
      'description': '*',
      'latestVersionNumber': '*',
      'parameters': '*'
    }
  },
  'aws-cdk-lib.aws-applicationautoscaling': {
    'ScalableTarget': {
      'minCapacity': '*',
      'maxCapacity': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'resourceId': '*',
      'scalableDimension': '*',
      'serviceNamespace': 'ServiceNamespace',
      'addToRolePolicy': [
        '*'
      ],
      'scaleOnSchedule': [
        '*',
        {
          'schedule': '*',
          'startTime': '*',
          'minCapacity': '*',
          'maxCapacity': '*',
          'timeZone': '*'
        }
      ],
      'scaleOnMetric': [
        '*',
        {
          'metric': {
            'warnings': '*',
            'warningsV2': '*'
          },
          'scalingSteps': {
            'lower': '*',
            'upper': '*',
            'change': '*'
          },
          'adjustmentType': 'AdjustmentType',
          'cooldown': '*',
          'minAdjustmentMagnitude': '*',
          'evaluationPeriods': '*',
          'datapointsToAlarm': '*',
          'metricAggregationType': 'MetricAggregationType'
        }
      ],
      'scaleToTrackMetric': [
        '*',
        {
          'targetValue': '*',
          'predefinedMetric': 'PredefinedMetric',
          'resourceLabel': '*',
          'customMetric': {
            'warnings': '*',
            'warningsV2': '*'
          },
          'policyName': '*',
          'disableScaleIn': 'boolean',
          'scaleInCooldown': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-appmesh': {
    'GatewayRoute': {
      'virtualGateway': {
        'virtualGatewayName': '*',
        'virtualGatewayArn': '*',
        'mesh': {
          'meshName': '*',
          'meshArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'gatewayRouteName': '*',
      'routeSpec': '*'
    },
    'Mesh': {
      'meshName': '*',
      'egressFilter': 'MeshFilterType',
      'serviceDiscovery': {
        'ipPreference': 'IpPreference'
      }
    },
    'Route': {
      'mesh': {
        'meshName': '*',
        'meshArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'virtualRouter': {
        'virtualRouterName': '*',
        'virtualRouterArn': '*',
        'mesh': {
          'meshName': '*',
          'meshArn': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'routeName': '*',
      'routeSpec': '*'
    },
    'VirtualGateway': {
      'mesh': {
        'meshName': '*',
        'meshArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'virtualGatewayName': '*',
      'listeners': '*',
      'accessLog': '*',
      'backendDefaults': {
        'tlsClientPolicy': {
          'enforce': 'boolean',
          'ports': '*',
          'validation': {
            'trust': '*',
            'subjectAlternativeNames': '*'
          },
          'mutualTlsCertificate': '*'
        }
      }
    },
    'VirtualNode': {
      'mesh': {
        'meshName': '*',
        'meshArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'virtualNodeName': '*',
      'serviceDiscovery': '*',
      'backends': '*',
      'listeners': '*',
      'accessLog': '*',
      'backendDefaults': {
        'tlsClientPolicy': {
          'enforce': 'boolean',
          'ports': '*',
          'validation': {
            'trust': '*',
            'subjectAlternativeNames': '*'
          },
          'mutualTlsCertificate': '*'
        }
      },
      'addListener': [
        '*'
      ],
      'addBackend': [
        '*'
      ]
    },
    'VirtualRouter': {
      'mesh': {
        'meshName': '*',
        'meshArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'listeners': '*',
      'virtualRouterName': '*'
    },
    'VirtualService': {
      'virtualServiceName': '*',
      'virtualServiceProvider': '*'
    }
  },
  'aws-cdk-lib.aws-appsync': {
    'AppsyncFunction': {
      'api': {
        'apiId': '*',
        'arn': '*',
        'graphQLEndpointArn': '*',
        'visibility': 'Visibility',
        'modes': 'AuthorizationType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'dataSource': '*',
      'name': '*',
      'description': '*',
      'requestMappingTemplate': '*',
      'responseMappingTemplate': '*',
      'runtime': '*',
      'code': '*',
      'maxBatchSize': '*'
    },
    'ChannelNamespace': {
      'api': {
        'authProviderTypes': 'AppSyncAuthorizationType',
        'httpDns': '*',
        'realtimeDns': '*',
        'apiId': '*',
        'apiArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'channelNamespaceName': '*',
      'code': '*',
      'publishHandlerConfig': {
        'direct': 'boolean',
        'dataSource': '*',
        'lambdaInvokeType': 'LambdaInvokeType'
      },
      'subscribeHandlerConfig': {
        'direct': 'boolean',
        'dataSource': '*',
        'lambdaInvokeType': 'LambdaInvokeType'
      },
      'authorizationConfig': {
        'publishAuthModeTypes': 'AppSyncAuthorizationType',
        'subscribeAuthModeTypes': 'AppSyncAuthorizationType'
      },
      'grantSubscribe': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantPublish': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantPublishAndSubscribe': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'EventApi': {
      'apiName': '*',
      'authorizationConfig': {
        'authProviders': {
          'authorizationType': 'AppSyncAuthorizationType',
          'cognitoConfig': {
            'userPool': {
              'userPoolId': '*',
              'userPoolArn': '*',
              'userPoolProviderName': '*',
              'identityProviders': {
                'providerName': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              }
            },
            'appIdClientRegex': '*'
          },
          'apiKeyConfig': {
            'name': '*',
            'description': '*',
            'expires': '*'
          },
          'openIdConnectConfig': {
            'tokenExpiryFromAuth': '*',
            'tokenExpiryFromIssue': '*',
            'clientId': '*',
            'oidcProvider': '*'
          },
          'lambdaAuthorizerConfig': {
            'handler': {
              'functionName': '*',
              'functionArn': '*',
              'role': {
                'roleArn': '*',
                'roleName': '*',
                'assumeRoleAction': '*',
                'policyFragment': '*',
                'principalAccount': '*',
                'grantPrincipal': {
                  'assumeRoleAction': '*',
                  'principalAccount': '*'
                }
              },
              'isBoundToVpc': 'boolean',
              'latestVersion': {
                'version': '*',
                'edgeArn': '*',
                'functionName': '*',
                'functionArn': '*',
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'resourceArnsForGrantInvoke': '*'
            },
            'resultsCacheTtl': '*',
            'validationRegex': '*'
          }
        },
        'connectionAuthModeTypes': 'AppSyncAuthorizationType',
        'defaultPublishAuthModeTypes': 'AppSyncAuthorizationType',
        'defaultSubscribeAuthModeTypes': 'AppSyncAuthorizationType'
      },
      'logConfig': {
        'excludeVerboseContent': 'boolean',
        'fieldLogLevel': 'AppSyncFieldLogLevel',
        'role': '*',
        'retention': 'RetentionDays'
      },
      'ownerContact': '*',
      'domainName': {
        'certificate': '*',
        'domainName': '*'
      }
    },
    'GraphqlApi': {
      'name': '*',
      'authorizationConfig': {
        'defaultAuthorization': {
          'authorizationType': 'AuthorizationType',
          'userPoolConfig': {
            'userPool': {
              'userPoolId': '*',
              'userPoolArn': '*',
              'userPoolProviderName': '*',
              'identityProviders': {
                'providerName': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              }
            },
            'appIdClientRegex': '*',
            'defaultAction': 'UserPoolDefaultAction'
          },
          'apiKeyConfig': {
            'name': '*',
            'description': '*',
            'expires': '*'
          },
          'openIdConnectConfig': {
            'tokenExpiryFromAuth': '*',
            'tokenExpiryFromIssue': '*',
            'clientId': '*',
            'oidcProvider': '*'
          },
          'lambdaAuthorizerConfig': {
            'handler': {
              'functionName': '*',
              'functionArn': '*',
              'role': {
                'roleArn': '*',
                'roleName': '*',
                'assumeRoleAction': '*',
                'policyFragment': '*',
                'principalAccount': '*',
                'grantPrincipal': {
                  'assumeRoleAction': '*',
                  'principalAccount': '*'
                }
              },
              'isBoundToVpc': 'boolean',
              'latestVersion': {
                'version': '*',
                'edgeArn': '*',
                'functionName': '*',
                'functionArn': '*',
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'resourceArnsForGrantInvoke': '*'
            },
            'resultsCacheTtl': '*',
            'validationRegex': '*'
          }
        }
      },
      'logConfig': {
        'excludeVerboseContent': 'boolean',
        'fieldLogLevel': 'FieldLogLevel',
        'role': '*',
        'retention': 'RetentionDays'
      },
      'definition': '*',
      'schema': '*',
      'xrayEnabled': 'boolean',
      'visibility': 'Visibility',
      'domainName': {
        'certificate': '*',
        'domainName': '*'
      },
      'introspectionConfig': 'IntrospectionConfig',
      'queryDepthLimit': '*',
      'resolverCountLimit': '*',
      'environmentVariables': '*',
      'ownerContact': '*',
      'enhancedMetricsConfig': {
        'dataSourceLevelMetricsBehavior': 'DataSourceLevelMetricsBehavior',
        'operationLevelMetricsConfig': 'OperationLevelMetricsConfig',
        'resolverLevelMetricsBehavior': 'ResolverLevelMetricsBehavior'
      },
      'addSchemaDependency': [
        '*'
      ],
      'addEnvironmentVariable': [
        '*',
        '*'
      ]
    },
    'SourceApiAssociation': {
      'sourceApi': {
        'apiId': '*',
        'arn': '*',
        'graphQLEndpointArn': '*',
        'visibility': 'Visibility',
        'modes': 'AuthorizationType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'mergedApi': {
        'apiId': '*',
        'arn': '*',
        'graphQLEndpointArn': '*',
        'visibility': 'Visibility',
        'modes': 'AuthorizationType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'mergedApiExecutionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'mergeType': 'MergeType',
      'description': '*'
    }
  },
  'aws-cdk-lib.aws-autoscaling': {
    'AutoScalingGroup': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'launchTemplate': {
        'versionNumber': '*',
        'launchTemplateId': '*',
        'launchTemplateName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'migrateToLaunchTemplate': 'boolean',
      'mixedInstancesPolicy': {
        'instancesDistribution': {
          'onDemandAllocationStrategy': 'OnDemandAllocationStrategy',
          'onDemandBaseCapacity': '*',
          'onDemandPercentageAboveBaseCapacity': '*',
          'spotAllocationStrategy': 'SpotAllocationStrategy',
          'spotInstancePools': '*',
          'spotMaxPrice': '*'
        },
        'launchTemplate': {
          'versionNumber': '*',
          'launchTemplateId': '*',
          'launchTemplateName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'launchTemplateOverrides': {
          'instanceRequirements': '*',
          'instanceType': '*',
          'weightedCapacity': '*'
        }
      },
      'instanceType': '*',
      'machineImage': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'userData': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'init': '*',
      'initOptions': {
        'configSets': '*',
        'embedFingerprint': 'boolean',
        'printLog': 'boolean',
        'ignoreFailures': 'boolean',
        'includeUrl': 'boolean',
        'includeRole': 'boolean'
      },
      'requireImdsv2': 'boolean',
      'maxHealthyPercentage': '*',
      'minHealthyPercentage': '*',
      'minCapacity': '*',
      'maxCapacity': '*',
      'desiredCapacity': '*',
      'keyName': '*',
      'keyPair': {
        'keyPairName': '*',
        'type': 'KeyPairType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'notificationsTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'notifications': {
        'topic': {
          'topicArn': '*',
          'topicName': '*',
          'masterKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'contentBasedDeduplication': 'boolean',
          'fifo': 'boolean'
        },
        'scalingEvents': '*'
      },
      'allowAllOutbound': 'boolean',
      'updateType': 'UpdateType',
      'rollingUpdateConfiguration': {
        'maxBatchSize': '*',
        'minInstancesInService': '*',
        'minSuccessfulInstancesPercent': '*',
        'pauseTime': '*',
        'waitOnResourceSignals': 'boolean',
        'suspendProcesses': 'ScalingProcess'
      },
      'replacingUpdateMinSuccessfulInstancesPercent': '*',
      'ignoreUnmodifiedSizeProperties': 'boolean',
      'resourceSignalCount': '*',
      'resourceSignalTimeout': '*',
      'cooldown': '*',
      'associatePublicIpAddress': 'boolean',
      'spotPrice': '*',
      'healthCheck': '*',
      'healthChecks': '*',
      'blockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'maxInstanceLifetime': '*',
      'instanceMonitoring': 'Monitoring',
      'groupMetrics': '*',
      'signals': '*',
      'updatePolicy': '*',
      'newInstancesProtectedFromScaleIn': 'boolean',
      'autoScalingGroupName': '*',
      'terminationPolicies': 'TerminationPolicy',
      'terminationPolicyCustomLambdaFunctionArn': '*',
      'defaultInstanceWarmup': '*',
      'capacityRebalance': 'boolean',
      'ssmSessionPermissions': 'boolean',
      'azCapacityDistributionStrategy': 'CapacityDistributionStrategy',
      'deletionProtection': 'DeletionProtection',
      'instanceLifecyclePolicy': {
        'retentionTriggers': {
          'terminateHookAbandon': 'TerminateHookAbandonAction'
        }
      },
      'addSecurityGroup': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ],
      'attachToClassicLB': [
        '*'
      ],
      'attachToApplicationTargetGroup': [
        {
          'metrics': '*',
          'targetGroupName': '*',
          'targetGroupArn': '*',
          'loadBalancerArns': '*',
          'loadBalancerAttached': '*',
          'node': '*'
        }
      ],
      'attachToNetworkTargetGroup': [
        {
          'metrics': '*',
          'targetGroupName': '*',
          'targetGroupArn': '*',
          'loadBalancerArns': '*',
          'loadBalancerAttached': '*',
          'node': '*',
          'isNetworkTargetGroup': 'boolean'
        }
      ],
      'addUserData': [
        '*'
      ],
      'addToRolePolicy': [
        '*'
      ],
      'applyCloudFormationInit': [
        '*',
        {
          'configSets': '*',
          'embedFingerprint': 'boolean',
          'printLog': 'boolean',
          'ignoreFailures': 'boolean',
          'includeUrl': 'boolean',
          'includeRole': 'boolean'
        }
      ],
      'protectNewInstancesFromScaleIn': [],
      'areNewInstancesProtectedFromScaleIn': []
    },
    'LifecycleHook': {
      'autoScalingGroup': '*',
      'lifecycleHookName': '*',
      'defaultResult': 'DefaultResult',
      'heartbeatTimeout': '*',
      'lifecycleTransition': 'LifecycleTransition',
      'notificationMetadata': '*',
      'notificationTarget': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'ScheduledAction': {
      'autoScalingGroup': '*',
      'timeZone': '*',
      'schedule': '*',
      'startTime': '*',
      'endTime': '*',
      'minCapacity': '*',
      'maxCapacity': '*',
      'desiredCapacity': '*'
    },
    'WarmPool': {
      'autoScalingGroup': '*',
      'reuseOnScaleIn': 'boolean',
      'maxGroupPreparedCapacity': '*',
      'minSize': '*',
      'poolState': 'PoolState'
    }
  },
  'aws-cdk-lib.aws-backup': {
    'BackupPlan': {
      'backupPlanName': '*',
      'backupVault': '*',
      'backupPlanRules': '*',
      'windowsVss': 'boolean',
      'addRule': [
        '*'
      ],
      'addSelection': [
        '*',
        {
          'resources': '*',
          'backupSelectionName': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'disableDefaultBackupPolicy': 'boolean',
          'allowRestores': 'boolean'
        }
      ]
    },
    'BackupSelection': {
      'backupPlan': '*',
      'resources': '*',
      'backupSelectionName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'disableDefaultBackupPolicy': 'boolean',
      'allowRestores': 'boolean'
    },
    'BackupVault': {
      'backupVaultName': '*',
      'accessPolicy': '*',
      'encryptionKey': '*',
      'notificationTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'notificationEvents': 'BackupVaultEvents',
      'removalPolicy': 'RemovalPolicy',
      'blockRecoveryPointDeletion': [],
      'lockConfiguration': {
        'minRetention': '*'
      },
      'addToAccessPolicy': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-batch': {
    'EcsJobDefinition': {
      'container': {
        'image': '*',
        'cpu': '*',
        'memory': '*',
        'command': '*',
        'environment': '*',
        'executionRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'linuxParameters': '*',
        'logDriverConfig': {
          'logDriver': '*',
          'options': '*',
          'secretOptions': '*'
        },
        'readonlyRootFilesystem': 'boolean',
        'secrets': '*',
        'user': '*',
        'volumes': '*',
        'enableExecuteCommand': 'boolean'
      },
      'propagateTags': 'boolean',
      'jobDefinitionName': '*',
      'parameters': '*',
      'retryAttempts': '*',
      'retryStrategies': '*',
      'schedulingPriority': '*',
      'timeout': '*',
      'grantSubmitJob': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ]
    },
    'EksJobDefinition': {
      'container': '*',
      'dnsPolicy': 'DnsPolicy',
      'useHostNetwork': 'boolean',
      'serviceAccount': '*',
      'jobDefinitionName': '*',
      'parameters': '*',
      'retryAttempts': '*',
      'retryStrategies': '*',
      'schedulingPriority': '*',
      'timeout': '*'
    },
    'JobQueue': {},
    'ManagedEc2EcsComputeEnvironment': {
      'defaultInstanceClasses': 'DefaultInstanceClass',
      'useOptimalInstanceClasses': 'boolean',
      'images': {
        'imageType': 'EcsMachineImageType',
        'image': '*'
      },
      'allocationStrategy': 'AllocationStrategy',
      'spotBidPercentage': '*',
      'spotFleetRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'instanceTypes': '*',
      'instanceClasses': 'InstanceClass',
      'instanceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'launchTemplate': {
        'versionNumber': '*',
        'launchTemplateId': '*',
        'launchTemplateName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'minvCpus': '*',
      'placementGroup': '*',
      'maxvCpus': '*',
      'replaceComputeEnvironment': 'boolean',
      'spot': 'boolean',
      'updateTimeout': '*',
      'terminateOnUpdate': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'updateToLatestImageVersion': 'boolean',
      'computeEnvironmentName': '*',
      'serviceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enabled': 'boolean',
      'addInstanceType': [
        '*'
      ],
      'addInstanceClass': [
        'InstanceClass'
      ]
    },
    'ManagedEc2EksComputeEnvironment': {
      'kubernetesNamespace': '*',
      'eksCluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'kubectlRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          }
        },
        'kubectlEnvironment': '*',
        'kubectlLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProvider': {
          'serviceToken': '*',
          'roleArn': '*'
        },
        'kubectlMemory': '*',
        'prune': 'boolean',
        'authenticationMode': 'AuthenticationMode'
      },
      'defaultInstanceClasses': 'DefaultInstanceClass',
      'useOptimalInstanceClasses': 'boolean',
      'images': {
        'imageType': 'EksMachineImageType',
        'image': '*'
      },
      'allocationStrategy': 'AllocationStrategy',
      'spotBidPercentage': '*',
      'instanceTypes': '*',
      'instanceClasses': 'InstanceClass',
      'instanceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'launchTemplate': {
        'versionNumber': '*',
        'launchTemplateId': '*',
        'launchTemplateName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'minvCpus': '*',
      'placementGroup': '*',
      'maxvCpus': '*',
      'replaceComputeEnvironment': 'boolean',
      'spot': 'boolean',
      'updateTimeout': '*',
      'terminateOnUpdate': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'updateToLatestImageVersion': 'boolean',
      'computeEnvironmentName': '*',
      'serviceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enabled': 'boolean',
      'addInstanceType': [
        '*'
      ],
      'addInstanceClass': [
        'InstanceClass'
      ]
    },
    'FargateComputeEnvironment': {
      'maxvCpus': '*',
      'replaceComputeEnvironment': 'boolean',
      'spot': 'boolean',
      'updateTimeout': '*',
      'terminateOnUpdate': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'updateToLatestImageVersion': 'boolean',
      'computeEnvironmentName': '*',
      'serviceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enabled': 'boolean'
    },
    'MultiNodeJobDefinition': {
      'addContainer': [
        {
          'startNode': '*',
          'endNode': '*',
          'container': {
            'image': '*',
            'cpu': '*',
            'memory': '*',
            'command': '*',
            'environment': '*',
            'executionRole': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'linuxParameters': '*',
            'logDriverConfig': {
              'logDriver': '*',
              'options': '*',
              'secretOptions': '*'
            },
            'readonlyRootFilesystem': 'boolean',
            'secrets': '*',
            'user': '*',
            'volumes': '*',
            'enableExecuteCommand': 'boolean'
          }
        }
      ]
    },
    'FairshareSchedulingPolicy': {
      'addShare': [
        {
          'shareIdentifier': '*',
          'weightFactor': '*'
        }
      ]
    },
    'UnmanagedComputeEnvironment': {}
  },
  'aws-cdk-lib.aws-certificatemanager': {
    'Certificate': {
      'domainName': '*',
      'subjectAlternativeNames': '*',
      'validationDomains': '*',
      'validationMethod': 'ValidationMethod',
      'validation': '*',
      'allowExport': 'boolean',
      'transparencyLoggingEnabled': 'boolean',
      'certificateName': '*',
      'keyAlgorithm': '*'
    },
    'DnsValidatedCertificate': {
      'hostedZone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'region': '*',
      'route53Endpoint': '*',
      'customResourceRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cleanupRoute53Records': 'boolean',
      'domainName': '*',
      'subjectAlternativeNames': '*',
      'validationDomains': '*',
      'validationMethod': 'ValidationMethod',
      'validation': '*',
      'allowExport': 'boolean',
      'transparencyLoggingEnabled': 'boolean',
      'certificateName': '*',
      'keyAlgorithm': '*',
      'applyRemovalPolicy': [
        'RemovalPolicy'
      ]
    },
    'PrivateCertificate': {
      'domainName': '*',
      'subjectAlternativeNames': '*',
      'certificateAuthority': '*',
      'keyAlgorithm': '*',
      'allowExport': 'boolean'
    }
  },
  'aws-cdk-lib.aws-chatbot': {
    'SlackChannelConfiguration': {
      'slackChannelConfigurationName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'slackWorkspaceId': '*',
      'slackChannelId': '*',
      'notificationTopics': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'loggingLevel': 'LoggingLevel',
      'logRetention': 'RetentionDays',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'guardrailPolicies': {
        'managedPolicyArn': '*'
      },
      'userRoleRequired': 'boolean',
      'addNotificationTopic': [
        {
          'topicArn': '*',
          'topicName': '*',
          'masterKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'contentBasedDeduplication': 'boolean',
          'fifo': 'boolean'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-cloudformation': {
    'CustomResource': {
      'provider': '*',
      'properties': '*',
      'resourceType': '*',
      'removalPolicy': 'RemovalPolicy'
    }
  },
  'aws-cdk-lib.aws-cloudfront': {
    'CachePolicy': {
      'cachePolicyName': '*',
      'comment': '*',
      'defaultTtl': '*',
      'minTtl': '*',
      'maxTtl': '*',
      'cookieBehavior': '*',
      'headerBehavior': '*',
      'queryStringBehavior': '*',
      'enableAcceptEncodingGzip': 'boolean',
      'enableAcceptEncodingBrotli': 'boolean'
    },
    'Distribution': {
      'defaultBehavior': {
        'origin': '*',
        'allowedMethods': '*',
        'cachedMethods': '*',
        'cachePolicy': '*',
        'compress': 'boolean',
        'originRequestPolicy': '*',
        'realtimeLogConfig': '*',
        'responseHeadersPolicy': '*',
        'smoothStreaming': 'boolean',
        'viewerProtocolPolicy': 'ViewerProtocolPolicy',
        'functionAssociations': {
          'function': '*',
          'eventType': 'FunctionEventType'
        },
        'edgeLambdas': {
          'functionVersion': {
            'version': '*',
            'lambda': {
              'functionName': '*',
              'functionArn': '*',
              'role': {
                'roleArn': '*',
                'roleName': '*',
                'assumeRoleAction': '*',
                'policyFragment': '*',
                'principalAccount': '*',
                'grantPrincipal': {
                  'assumeRoleAction': '*',
                  'principalAccount': '*'
                },
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'isBoundToVpc': 'boolean',
              'tenancyConfig': '*',
              'architecture': '*',
              'resourceArnsForGrantInvoke': '*',
              'connections': '*'
            },
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'resourceArnsForGrantInvoke': '*'
          },
          'eventType': 'LambdaEdgeEventType',
          'includeBody': 'boolean'
        },
        'trustedKeyGroups': '*',
        'enableGrpc': 'boolean'
      },
      'additionalBehaviors': '*',
      'certificate': '*',
      'comment': '*',
      'defaultRootObject': '*',
      'domainNames': '*',
      'enabled': 'boolean',
      'enableIpv6': 'boolean',
      'enableLogging': 'boolean',
      'geoRestriction': '*',
      'httpVersion': 'HttpVersion',
      'logBucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'logIncludesCookies': 'boolean',
      'logFilePrefix': '*',
      'priceClass': 'PriceClass',
      'webAclId': '*',
      'errorResponses': {
        'ttl': '*',
        'httpStatus': '*',
        'responseHttpStatus': '*',
        'responsePagePath': '*'
      },
      'minimumProtocolVersion': 'SecurityPolicyProtocol',
      'sslSupportMethod': 'SSLMethod',
      'publishAdditionalMetrics': 'boolean',
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricRequests': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricBytesUploaded': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricBytesDownloaded': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTotalErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric4xxErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric5xxErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricOriginLatency': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricCacheHitRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric401ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric403ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric404ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric502ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric503ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric504ErrorRate': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'addBehavior': [
        '*',
        '*',
        {
          'allowedMethods': '*',
          'cachedMethods': '*',
          'cachePolicy': '*',
          'compress': 'boolean',
          'originRequestPolicy': '*',
          'realtimeLogConfig': '*',
          'responseHeadersPolicy': '*',
          'smoothStreaming': 'boolean',
          'viewerProtocolPolicy': 'ViewerProtocolPolicy',
          'functionAssociations': {
            'function': '*',
            'eventType': 'FunctionEventType'
          },
          'edgeLambdas': {
            'functionVersion': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'eventType': 'LambdaEdgeEventType',
            'includeBody': 'boolean'
          },
          'trustedKeyGroups': '*',
          'enableGrpc': 'boolean'
        }
      ],
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'grantCreateInvalidation': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'attachWebAclId': [
        '*'
      ]
    },
    'Function': {
      'functionName': '*',
      'comment': '*',
      'code': '*',
      'runtime': '*',
      'keyValueStore': '*',
      'autoPublish': 'boolean'
    },
    'KeyGroup': {
      'keyGroupName': '*',
      'comment': '*',
      'items': '*'
    },
    'KeyValueStore': {},
    'S3OriginAccessControl': {
      'description': '*',
      'originAccessControlName': '*',
      'signing': '*'
    },
    'FunctionUrlOriginAccessControl': {
      'description': '*',
      'originAccessControlName': '*',
      'signing': '*'
    },
    'OriginAccessIdentity': {},
    'OriginRequestPolicy': {
      'originRequestPolicyName': '*',
      'comment': '*',
      'cookieBehavior': '*',
      'headerBehavior': '*',
      'queryStringBehavior': '*'
    },
    'PublicKey': {
      'publicKeyName': '*',
      'comment': '*',
      'encodedKey': '*'
    },
    'RealtimeLogConfig': {
      'realtimeLogConfigName': '*',
      'fields': '*',
      'samplingRate': '*',
      'endPoints': '*'
    },
    'ResponseHeadersPolicy': {
      'responseHeadersPolicyName': '*',
      'comment': '*',
      'corsBehavior': {
        'accessControlAllowCredentials': 'boolean',
        'accessControlAllowHeaders': '*',
        'accessControlAllowMethods': '*',
        'accessControlAllowOrigins': '*',
        'accessControlExposeHeaders': '*',
        'accessControlMaxAge': '*',
        'originOverride': 'boolean'
      },
      'customHeadersBehavior': {
        'customHeaders': {
          'header': '*',
          'override': 'boolean',
          'value': '*'
        }
      },
      'securityHeadersBehavior': {
        'contentSecurityPolicy': {
          'contentSecurityPolicy': '*',
          'override': 'boolean'
        },
        'contentTypeOptions': {
          'override': 'boolean'
        },
        'frameOptions': {
          'frameOption': 'HeadersFrameOption',
          'override': 'boolean'
        },
        'referrerPolicy': {
          'referrerPolicy': 'HeadersReferrerPolicy',
          'override': 'boolean'
        },
        'strictTransportSecurity': {
          'accessControlMaxAge': '*',
          'includeSubdomains': 'boolean',
          'override': 'boolean',
          'preload': 'boolean'
        },
        'xssProtection': {
          'modeBlock': 'boolean',
          'override': 'boolean',
          'protection': 'boolean',
          'reportUri': '*'
        }
      },
      'removeHeaders': '*',
      'serverTimingSamplingRate': '*'
    },
    'VpcOrigin': {
      'endpoint': '*',
      'httpPort': '*',
      'httpsPort': '*',
      'vpcOriginName': '*',
      'protocolPolicy': 'OriginProtocolPolicy',
      'originSslProtocols': 'OriginSslPolicy'
    },
    'CloudFrontWebDistribution': {
      'aliasConfiguration': {
        'acmCertRef': '*',
        'names': '*',
        'sslMethod': 'SSLMethod',
        'securityPolicy': 'SecurityPolicyProtocol'
      },
      'comment': '*',
      'enabled': 'boolean',
      'defaultRootObject': '*',
      'enableIpV6': 'boolean',
      'httpVersion': 'HttpVersion',
      'priceClass': 'PriceClass',
      'viewerProtocolPolicy': 'ViewerProtocolPolicy',
      'originConfigs': {
        'connectionAttempts': '*',
        'connectionTimeout': '*',
        's3OriginSource': {
          's3BucketSource': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'originAccessIdentity': '*',
          'originPath': '*',
          'originHeaders': '*',
          'originShieldRegion': '*'
        },
        'customOriginSource': {
          'domainName': '*',
          'httpPort': '*',
          'httpsPort': '*',
          'originProtocolPolicy': 'OriginProtocolPolicy',
          'allowedOriginSSLVersions': 'OriginSslPolicy',
          'originPath': '*',
          'originHeaders': '*',
          'originShieldRegion': '*'
        },
        'failoverCriteriaStatusCodes': 'FailoverStatusCode',
        'behaviors': {
          'compress': 'boolean',
          'isDefaultBehavior': 'boolean',
          'trustedSigners': '*',
          'trustedKeyGroups': '*',
          'allowedMethods': 'CloudFrontAllowedMethods',
          'pathPattern': '*',
          'cachedMethods': 'CloudFrontAllowedCachedMethods',
          'forwardedValues': '*',
          'lambdaFunctionAssociations': {
            'eventType': 'LambdaEdgeEventType',
            'lambdaFunction': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'includeBody': 'boolean'
          },
          'functionAssociations': {
            'function': '*',
            'eventType': 'FunctionEventType'
          },
          'viewerProtocolPolicy': 'ViewerProtocolPolicy'
        },
        'originPath': '*',
        'originHeaders': '*',
        'originShieldRegion': '*'
      },
      'loggingConfig': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'includeCookies': 'boolean',
        'prefix': '*'
      },
      'errorConfigurations': '*',
      'webACLId': '*',
      'viewerCertificate': '*',
      'geoRestriction': '*',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-cloudtrail': {
    'Trail': {
      'includeGlobalServiceEvents': 'boolean',
      'isMultiRegionTrail': 'boolean',
      'managementEvents': 'ReadWriteType',
      'enableFileValidation': 'boolean',
      'sendToCloudWatchLogs': 'boolean',
      'cloudWatchLogsRetention': 'RetentionDays',
      'cloudWatchLogGroup': '*',
      'kmsKey': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'snsTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'trailName': '*',
      's3KeyPrefix': '*',
      'bucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'isOrganizationTrail': 'boolean',
      'orgId': '*',
      'insightTypes': '*',
      'addEventSelector': [
        'DataResourceType',
        '*',
        {
          'readWriteType': 'ReadWriteType',
          'includeManagementEvents': 'boolean',
          'excludeManagementEventSources': 'ManagementEventSources'
        }
      ],
      'addLambdaEventSelector': [
        {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        },
        {
          'readWriteType': 'ReadWriteType',
          'includeManagementEvents': 'boolean',
          'excludeManagementEventSources': 'ManagementEventSources'
        }
      ],
      'logAllLambdaDataEvents': [
        {
          'readWriteType': 'ReadWriteType',
          'includeManagementEvents': 'boolean',
          'excludeManagementEventSources': 'ManagementEventSources'
        }
      ],
      'addS3EventSelector': [
        {
          'bucket': '*',
          'objectPrefix': '*'
        },
        {
          'readWriteType': 'ReadWriteType',
          'includeManagementEvents': 'boolean',
          'excludeManagementEventSources': 'ManagementEventSources'
        }
      ],
      'logAllS3DataEvents': [
        {
          'readWriteType': 'ReadWriteType',
          'includeManagementEvents': 'boolean',
          'excludeManagementEventSources': 'ManagementEventSources'
        }
      ],
      'onCloudTrailEvent': [
        '*',
        {
          'target': '*',
          'description': '*',
          'ruleName': '*',
          'eventPattern': {
            'version': '*',
            'id': '*',
            'detailType': '*',
            'source': '*',
            'account': '*',
            'time': '*',
            'region': '*',
            'resources': '*',
            'detail': '*'
          },
          'crossStackScope': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-cloudwatch': {
    'Alarm': {
      'metric': {
        'warnings': '*',
        'warningsV2': '*'
      },
      'comparisonOperator': 'ComparisonOperator',
      'threshold': '*',
      'period': '*',
      'statistic': '*',
      'alarmName': '*',
      'alarmDescription': '*',
      'evaluationPeriods': '*',
      'evaluateLowSampleCountPercentile': '*',
      'treatMissingData': 'TreatMissingData',
      'actionsEnabled': 'boolean',
      'datapointsToAlarm': '*',
      'toAnnotation': [],
      'addAlarmAction': [
        '*'
      ]
    },
    'AnomalyDetectionAlarm': {
      'metric': {
        'warnings': '*',
        'warningsV2': '*'
      },
      'stdDevs': '*',
      'comparisonOperator': 'ComparisonOperator',
      'period': '*',
      'statistic': '*',
      'alarmName': '*',
      'alarmDescription': '*',
      'evaluationPeriods': '*',
      'evaluateLowSampleCountPercentile': '*',
      'treatMissingData': 'TreatMissingData',
      'actionsEnabled': 'boolean',
      'datapointsToAlarm': '*'
    },
    'CompositeAlarm': {
      'actionsEnabled': 'boolean',
      'alarmDescription': '*',
      'compositeAlarmName': '*',
      'alarmRule': '*',
      'actionsSuppressor': '*',
      'actionsSuppressorExtensionPeriod': '*',
      'actionsSuppressorWaitPeriod': '*'
    },
    'Dashboard': {
      'dashboardName': '*',
      'defaultInterval': '*',
      'start': '*',
      'end': '*',
      'periodOverride': 'PeriodOverride',
      'widgets': {
        'width': '*',
        'height': '*',
        'warnings': '*',
        'warningsV2': '*'
      },
      'variables': '*',
      'addWidgets': [
        {
          'width': '*',
          'height': '*',
          'warnings': '*',
          'warningsV2': '*'
        }
      ],
      'addVariable': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-codebuild': {
    'Fleet': {
      'fleetName': '*',
      'baseCapacity': '*',
      'computeType': 'FleetComputeType',
      'environmentType': 'EnvironmentType',
      'computeConfiguration': {
        'disk': '*',
        'machineType': 'MachineType',
        'vCpu': '*',
        'instanceType': '*'
      },
      'overflowBehavior': 'FleetOverflowBehavior',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      }
    },
    'PipelineProject': {},
    'Project': {
      'source': {
        'identifier': '*',
        'type': '*',
        'badgeSupported': 'boolean'
      },
      'artifacts': {
        'identifier': '*',
        'type': '*'
      },
      'secondarySources': {
        'identifier': '*',
        'type': '*',
        'badgeSupported': 'boolean'
      },
      'secondaryArtifacts': {
        'identifier': '*',
        'type': '*'
      },
      'description': '*',
      'buildSpec': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cache': '*',
      'environment': {
        'buildImage': {
          'type': '*',
          'imageId': '*',
          'defaultComputeType': 'ComputeType',
          'imagePullPrincipalType': 'ImagePullPrincipalType',
          'secretsManagerCredentials': {
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'secretArn': '*',
            'secretFullArn': '*',
            'secretName': '*',
            'secretValue': '*'
          },
          'repository': {
            'repositoryName': '*',
            'repositoryArn': '*',
            'repositoryUri': '*',
            'registryUri': '*'
          }
        },
        'computeType': 'ComputeType',
        'dockerServer': {
          'computeType': 'DockerServerComputeType',
          'securityGroups': {
            'securityGroupId': '*',
            'allowAllOutbound': 'boolean',
            'canInlineRule': 'boolean',
            'uniqueId': '*',
            'connections': '*'
          }
        },
        'fleet': {
          'fleetArn': '*',
          'fleetName': '*',
          'computeType': 'FleetComputeType',
          'environmentType': 'EnvironmentType',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        'privileged': 'boolean',
        'certificate': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'objectKey': '*'
        },
        'environmentVariables': '*'
      },
      'badge': 'boolean',
      'timeout': '*',
      'environmentVariables': '*',
      'checkSecretsInPlainTextEnvVariables': 'boolean',
      'projectName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'fileSystemLocations': '*',
      'grantReportGroupPermissions': 'boolean',
      'logging': {
        's3': {
          'encrypted': 'boolean',
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'prefix': '*',
          'enabled': 'boolean'
        },
        'cloudWatch': {
          'logGroup': {
            'logGroupArn': '*',
            'logGroupName': '*'
          },
          'prefix': '*',
          'enabled': 'boolean'
        }
      },
      'queuedTimeout': '*',
      'concurrentBuildLimit': '*',
      'ssmSessionPermissions': 'boolean',
      'visibility': 'ProjectVisibility',
      'autoRetryLimit': '*',
      'enableBatchBuilds': [],
      'addSecondarySource': [
        {
          'identifier': '*',
          'type': '*',
          'badgeSupported': 'boolean'
        }
      ],
      'addFileSystemLocation': [
        '*'
      ],
      'addSecondaryArtifact': [
        {
          'identifier': '*',
          'type': '*'
        }
      ],
      'bindToCodePipeline': [
        '*',
        {
          'artifactBucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          }
        }
      ]
    },
    'ReportGroup': {
      'reportGroupName': '*',
      'exportBucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'zipExport': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'type': 'ReportGroupType',
      'deleteReports': 'boolean'
    },
    'GitHubSourceCredentials': {
      'accessToken': '*'
    },
    'GitHubEnterpriseSourceCredentials': {
      'accessToken': '*'
    },
    'BitBucketSourceCredentials': {
      'username': '*',
      'password': '*'
    },
    'UntrustedCodeBoundaryPolicy': {
      'managedPolicyName': '*',
      'additionalStatements': '*'
    }
  },
  'aws-cdk-lib.aws-codecommit': {
    'Repository': {
      'repositoryName': '*',
      'description': '*',
      'code': '*',
      'kmsKey': '*',
      'notify': [
        '*',
        {
          'name': '*',
          'events': 'RepositoryEventTrigger',
          'branches': '*',
          'customData': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-codeguruprofiler': {
    'ProfilingGroup': {
      'profilingGroupName': '*',
      'computePlatform': 'ComputePlatform'
    }
  },
  'aws-cdk-lib.aws-codepipeline': {
    'Pipeline': {
      'artifactBucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'restartExecutionOnUpdate': 'boolean',
      'pipelineName': '*',
      'crossRegionReplicationBuckets': '*',
      'stages': {
        'stageName': '*',
        'actions': {
          'actionProperties': {
            'actionName': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'region': '*',
            'account': '*',
            'resource': '*',
            'category': 'ActionCategory',
            'provider': '*',
            'owner': '*',
            'version': '*',
            'runOrder': '*',
            'artifactBounds': {
              'minInputs': '*',
              'maxInputs': '*',
              'minOutputs': '*',
              'maxOutputs': '*'
            },
            'inputs': '*',
            'variablesNamespace': '*',
            'commands': '*',
            'outputVariables': '*',
            'timeout': '*'
          }
        },
        'transitionToEnabled': 'boolean',
        'transitionDisabledReason': '*',
        'beforeEntry': {
          'conditions': {
            'rules': '*',
            'result': 'Result'
          }
        },
        'onFailure': {
          'result': 'Result',
          'retryMode': 'RetryMode'
        }
      },
      'crossAccountKeys': 'boolean',
      'enableKeyRotation': 'boolean',
      'reuseCrossRegionSupportStacks': 'boolean',
      'pipelineType': 'PipelineType',
      'variables': '*',
      'triggers': {
        'providerType': 'ProviderType',
        'gitConfiguration': {
          'sourceAction': {
            'actionProperties': {
              'actionName': '*',
              'role': {
                'roleArn': '*',
                'roleName': '*',
                'assumeRoleAction': '*',
                'policyFragment': '*',
                'principalAccount': '*',
                'grantPrincipal': {
                  'assumeRoleAction': '*',
                  'principalAccount': '*'
                },
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'region': '*',
              'account': '*',
              'resource': '*',
              'category': 'ActionCategory',
              'provider': '*',
              'owner': '*',
              'version': '*',
              'runOrder': '*',
              'artifactBounds': {
                'minInputs': '*',
                'maxInputs': '*',
                'minOutputs': '*',
                'maxOutputs': '*'
              },
              'inputs': '*',
              'variablesNamespace': '*',
              'commands': '*',
              'outputVariables': '*',
              'timeout': '*'
            }
          },
          'pushFilter': {
            'tagsExcludes': '*',
            'tagsIncludes': '*',
            'branchesExcludes': '*',
            'branchesIncludes': '*',
            'filePathsExcludes': '*',
            'filePathsIncludes': '*'
          },
          'pullRequestFilter': {
            'events': 'GitPullRequestEvent',
            'branchesExcludes': '*',
            'branchesIncludes': '*',
            'filePathsExcludes': '*',
            'filePathsIncludes': '*'
          }
        }
      },
      'executionMode': 'ExecutionMode',
      'usePipelineRoleForActions': 'boolean',
      'addStage': [
        {
          'placement': {
            'rightBefore': {
              'stageName': '*',
              'pipeline': {
                'pipelineName': '*',
                'pipelineArn': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'actions': {
                'actionProperties': {
                  'actionName': '*',
                  'role': {
                    'roleArn': '*',
                    'roleName': '*',
                    'assumeRoleAction': '*',
                    'policyFragment': '*',
                    'principalAccount': '*',
                    'grantPrincipal': {
                      'assumeRoleAction': '*',
                      'principalAccount': '*'
                    }
                  },
                  'region': '*',
                  'account': '*',
                  'resource': '*',
                  'category': 'ActionCategory',
                  'provider': '*',
                  'owner': '*',
                  'version': '*',
                  'runOrder': '*',
                  'artifactBounds': {
                    'minInputs': '*',
                    'maxInputs': '*',
                    'minOutputs': '*',
                    'maxOutputs': '*'
                  },
                  'inputs': '*',
                  'variablesNamespace': '*',
                  'commands': '*',
                  'outputVariables': '*',
                  'timeout': '*'
                }
              }
            }
          },
          'stageName': '*',
          'transitionToEnabled': 'boolean',
          'transitionDisabledReason': '*',
          'beforeEntry': {
            'conditions': {
              'rules': '*',
              'result': 'Result'
            }
          },
          'onFailure': {
            'result': 'Result',
            'retryMode': 'RetryMode'
          }
        }
      ],
      'addToRolePolicy': [
        '*'
      ],
      'addVariable': [
        '*'
      ],
      'addTrigger': [
        {
          'providerType': 'ProviderType',
          'gitConfiguration': {
            'sourceAction': {
              'actionProperties': {
                'actionName': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'region': '*',
                'account': '*',
                'resource': '*',
                'category': 'ActionCategory',
                'provider': '*',
                'owner': '*',
                'version': '*',
                'runOrder': '*',
                'artifactBounds': {
                  'minInputs': '*',
                  'maxInputs': '*',
                  'minOutputs': '*',
                  'maxOutputs': '*'
                },
                'inputs': '*',
                'variablesNamespace': '*',
                'commands': '*',
                'outputVariables': '*',
                'timeout': '*'
              }
            },
            'pushFilter': {
              'tagsExcludes': '*',
              'tagsIncludes': '*',
              'branchesExcludes': '*',
              'branchesIncludes': '*',
              'filePathsExcludes': '*',
              'filePathsIncludes': '*'
            },
            'pullRequestFilter': {
              'events': 'GitPullRequestEvent',
              'branchesExcludes': '*',
              'branchesIncludes': '*',
              'filePathsExcludes': '*',
              'filePathsIncludes': '*'
            }
          }
        }
      ],
      'stage': [
        '*'
      ],
      '_attachActionToPipeline': [
        '*',
        {
          'actionProperties': {
            'actionName': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'region': '*',
            'account': '*',
            'resource': '*',
            'category': 'ActionCategory',
            'provider': '*',
            'owner': '*',
            'version': '*',
            'runOrder': '*',
            'artifactBounds': {
              'minInputs': '*',
              'maxInputs': '*',
              'minOutputs': '*',
              'maxOutputs': '*'
            },
            'inputs': '*',
            'variablesNamespace': '*',
            'commands': '*',
            'outputVariables': '*',
            'timeout': '*'
          }
        },
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-codestarnotifications': {
    'NotificationRule': {
      'events': '*',
      'source': '*',
      'targets': '*',
      'notificationRuleName': '*',
      'enabled': 'boolean',
      'detailType': 'DetailType',
      'createdBy': '*',
      'addTarget': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-cognito': {
    'UserPoolClient': {
      'userPool': '*',
      'userPoolClientName': '*',
      'generateSecret': 'boolean',
      'authFlows': {
        'adminUserPassword': 'boolean',
        'custom': 'boolean',
        'userPassword': 'boolean',
        'userSrp': 'boolean',
        'user': 'boolean'
      },
      'disableOAuth': 'boolean',
      'oAuth': {
        'flows': {
          'authorizationCodeGrant': 'boolean',
          'implicitCodeGrant': 'boolean',
          'clientCredentials': 'boolean'
        },
        'callbackUrls': '*',
        'logoutUrls': '*',
        'scopes': '*',
        'defaultRedirectUri': '*'
      },
      'authSessionValidity': '*',
      'preventUserExistenceErrors': 'boolean',
      'supportedIdentityProviders': '*',
      'idTokenValidity': '*',
      'refreshTokenValidity': '*',
      'accessTokenValidity': '*',
      'refreshTokenRotationGracePeriod': '*',
      'readAttributes': '*',
      'writeAttributes': '*',
      'enableTokenRevocation': 'boolean',
      'enablePropagateAdditionalUserContextData': 'boolean',
      'analytics': {
        'application': '*',
        'applicationId': '*',
        'externalId': '*',
        'role': '*',
        'shareUserData': 'boolean'
      }
    },
    'UserPoolDomain': {
      'userPool': '*',
      'customDomain': {
        'domainName': '*',
        'certificate': '*'
      },
      'cognitoDomain': {
        'domainPrefix': '*'
      },
      'managedLoginVersion': 'ManagedLoginVersion',
      'baseUrl': [
        {
          'fips': 'boolean'
        }
      ],
      'signInUrl': [
        '*',
        {
          'redirectUri': '*',
          'signInPath': '*',
          'fips': 'boolean'
        }
      ]
    },
    'UserPoolGroup': {
      'userPool': '*',
      'description': '*',
      'groupName': '*',
      'precedence': '*',
      'role': '*'
    },
    'UserPoolResourceServer': {
      'userPool': '*',
      'identifier': '*',
      'userPoolResourceServerName': '*',
      'scopes': '*'
    },
    'UserPool': {
      'userPoolName': '*',
      'selfSignUpEnabled': 'boolean',
      'userVerification': {
        'emailSubject': '*',
        'emailBody': '*',
        'emailStyle': 'VerificationEmailStyle',
        'smsMessage': '*'
      },
      'userInvitation': {
        'emailSubject': '*',
        'emailBody': '*',
        'smsMessage': '*'
      },
      'smsRole': '*',
      'smsRoleExternalId': '*',
      'snsRegion': '*',
      'enableSmsRole': 'boolean',
      'signInAliases': {
        'username': 'boolean',
        'email': 'boolean',
        'phone': 'boolean',
        'preferredUsername': 'boolean'
      },
      'autoVerify': {
        'email': 'boolean',
        'phone': 'boolean'
      },
      'keepOriginal': {
        'email': 'boolean',
        'phone': 'boolean'
      },
      'standardAttributes': {
        'address': {
          'mutable': 'boolean',
          'required': 'boolean'
        }
      },
      'customAttributes': '*',
      'mfa': 'Mfa',
      'mfaMessage': '*',
      'mfaSecondFactor': {
        'sms': 'boolean',
        'otp': 'boolean',
        'email': 'boolean'
      },
      'passwordPolicy': {
        'tempPasswordValidity': '*',
        'minLength': '*',
        'requireLowercase': 'boolean',
        'requireUppercase': 'boolean',
        'requireDigits': 'boolean',
        'requireSymbols': 'boolean',
        'passwordHistorySize': '*'
      },
      'signInPolicy': {
        'allowedFirstAuthFactors': {
          'password': 'boolean',
          'emailOtp': 'boolean',
          'smsOtp': 'boolean',
          'passkey': 'boolean'
        }
      },
      'passkeyRelyingPartyId': '*',
      'passkeyUserVerification': 'PasskeyUserVerification',
      'emailSettings': {
        'from': '*',
        'replyTo': '*'
      },
      'email': '*',
      'lambdaTriggers': {
        'createAuthChallenge': {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        }
      },
      'signInCaseSensitive': 'boolean',
      'accountRecovery': 'AccountRecovery',
      'removalPolicy': 'RemovalPolicy',
      'deletionProtection': 'boolean',
      'deviceTracking': {
        'challengeRequiredOnNewDevice': 'boolean',
        'deviceOnlyRememberedOnUserPrompt': 'boolean'
      },
      'customSenderKmsKey': '*',
      'advancedSecurityMode': 'AdvancedSecurityMode',
      'featurePlan': 'FeaturePlan',
      'standardThreatProtectionMode': 'StandardThreatProtectionMode',
      'customThreatProtectionMode': 'CustomThreatProtectionMode',
      'addTrigger': [
        '*',
        {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        },
        'LambdaVersion'
      ]
    }
  },
  'aws-cdk-lib.aws-cognito-identitypool': {
    'IdentityPool': {
      'identityPoolName': '*',
      'authenticatedRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'unauthenticatedRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'allowUnauthenticatedIdentities': 'boolean',
      'roleMappings': {
        'providerUrl': '*',
        'mappingKey': '*',
        'useToken': 'boolean',
        'resolveAmbiguousRoles': 'boolean',
        'rules': {
          'claim': '*',
          'mappedRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'claimValue': '*',
          'matchType': 'RoleMappingMatchType'
        }
      },
      'allowClassicFlow': 'boolean',
      'authenticationProviders': {
        'facebook': {
          'appId': '*'
        },
        'google': {
          'clientId': '*'
        },
        'amazon': {
          'appId': '*'
        },
        'apple': {
          'servicesId': '*'
        },
        'twitter': {
          'consumerKey': '*',
          'consumerSecret': '*'
        },
        'userPools': '*',
        'openIdConnectProviders': '*',
        'samlProviders': '*',
        'customProvider': '*'
      },
      'addUserPoolAuthentication': [
        '*'
      ]
    },
    'IdentityPoolRoleAttachment': {
      'identityPool': {
        'identityPoolId': '*',
        'identityPoolArn': '*',
        'identityPoolName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'authenticatedRole': '*',
      'unauthenticatedRole': '*',
      'roleMappings': {
        'providerUrl': '*',
        'mappingKey': '*',
        'useToken': 'boolean',
        'resolveAmbiguousRoles': 'boolean',
        'rules': {
          'claim': '*',
          'mappedRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'claimValue': '*',
          'matchType': 'RoleMappingMatchType'
        }
      }
    }
  },
  'aws-cdk-lib.aws-config': {
    'AccessKeysRotated': {
      'maxAge': '*',
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    },
    'CloudFormationStackDriftDetectionCheck': {
      'ownStackOnly': 'boolean',
      'role': '*',
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    },
    'CloudFormationStackNotificationCheck': {
      'topics': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    },
    'ManagedRule': {
      'identifier': '*',
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    },
    'CustomRule': {
      'lambdaFunction': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'configurationChanges': 'boolean',
      'periodic': 'boolean',
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    },
    'CustomPolicy': {
      'policyText': '*',
      'enableDebugLog': 'boolean',
      'configRuleName': '*',
      'description': '*',
      'inputParameters': '*',
      'maximumExecutionFrequency': 'MaximumExecutionFrequency',
      'ruleScope': '*',
      'evaluationModes': '*'
    }
  },
  'aws-cdk-lib.aws-docdb': {
    'DatabaseCluster': {
      'engineVersion': '*',
      'port': '*',
      'masterUser': {
        'username': '*',
        'password': '*',
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'excludeCharacters': '*',
        'secretName': '*'
      },
      'backup': {
        'retention': '*',
        'preferredWindow': '*'
      },
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'storageEncrypted': 'boolean',
      'dbClusterName': '*',
      'instanceIdentifierBase': '*',
      'instanceType': '*',
      'instances': '*',
      'serverlessV2ScalingConfiguration': {
        'minCapacity': '*',
        'maxCapacity': '*'
      },
      'caCertificate': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'parameterGroup': '*',
      'preferredMaintenanceWindow': '*',
      'removalPolicy': 'RemovalPolicy',
      'deletionProtection': 'boolean',
      'exportProfilerLogsToCloudWatch': 'boolean',
      'exportAuditLogsToCloudWatch': 'boolean',
      'cloudWatchLogsRetention': 'RetentionDays',
      'cloudWatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enablePerformanceInsights': 'boolean',
      'instanceRemovalPolicy': 'RemovalPolicy',
      'securityGroupRemovalPolicy': 'RemovalPolicy',
      'copyTagsToSnapshot': 'boolean',
      'storageType': 'StorageType',
      'addRotationSingleUser': [
        '*'
      ],
      'addRotationMultiUser': [
        '*',
        {
          'secret': {
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'secretArn': '*',
            'secretFullArn': '*',
            'secretName': '*',
            'secretValue': '*'
          },
          'automaticallyAfter': '*'
        }
      ],
      'addSecurityGroups': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ]
    },
    'DatabaseSecret': {
      'username': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'secretName': '*',
      'masterSecret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'excludeCharacters': '*'
    },
    'DatabaseInstance': {
      'cluster': '*',
      'instanceType': '*',
      'availabilityZone': '*',
      'dbInstanceName': '*',
      'autoMinorVersionUpgrade': 'boolean',
      'preferredMaintenanceWindow': '*',
      'removalPolicy': 'RemovalPolicy',
      'enablePerformanceInsights': 'boolean',
      'caCertificate': '*'
    },
    'ClusterParameterGroup': {
      'description': '*',
      'family': '*',
      'dbClusterParameterGroupName': '*',
      'parameters': '*'
    }
  },
  'aws-cdk-lib.aws-dynamodb': {
    'TableV2': {
      'partitionKey': {
        'name': '*',
        'type': 'AttributeType'
      },
      'sortKey': {
        'name': '*',
        'type': 'AttributeType'
      },
      'tableName': '*',
      'timeToLiveAttribute': '*',
      'dynamoStream': 'StreamViewType',
      'removalPolicy': 'RemovalPolicy',
      'billing': '*',
      'replicas': {
        'region': '*',
        'readCapacity': '*',
        'maxReadRequestUnits': '*',
        'globalSecondaryIndexOptions': '*',
        'contributorInsights': 'boolean',
        'contributorInsightsSpecification': {
          'enabled': 'boolean',
          'mode': 'ContributorInsightsMode'
        },
        'deletionProtection': 'boolean',
        'pointInTimeRecovery': 'boolean',
        'pointInTimeRecoverySpecification': {
          'pointInTimeRecoveryEnabled': 'boolean',
          'recoveryPeriodInDays': '*'
        },
        'tableClass': 'TableClass',
        'kinesisStream': {
          'streamArn': '*',
          'streamName': '*',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        },
        'tags': {
          'key': '*',
          'value': '*'
        },
        'resourcePolicy': '*'
      },
      'globalTableSettingsReplicationMode': 'GlobalTableSettingsReplicationMode',
      'witnessRegion': '*',
      'multiRegionConsistency': 'MultiRegionConsistency',
      'globalSecondaryIndexes': {
        'partitionKey': {
          'name': '*',
          'type': 'AttributeType'
        },
        'readCapacity': '*',
        'maxReadRequestUnits': '*',
        'maxWriteRequestUnits': '*',
        'warmThroughput': {
          'readUnitsPerSecond': '*',
          'writeUnitsPerSecond': '*'
        },
        'indexName': '*',
        'projectionType': 'ProjectionType',
        'nonKeyAttributes': '*'
      },
      'localSecondaryIndexes': {
        'sortKey': {
          'name': '*',
          'type': 'AttributeType'
        },
        'indexName': '*',
        'projectionType': 'ProjectionType',
        'nonKeyAttributes': '*'
      },
      'encryption': '*',
      'warmThroughput': {
        'readUnitsPerSecond': '*',
        'writeUnitsPerSecond': '*'
      },
      'contributorInsights': 'boolean',
      'contributorInsightsSpecification': {
        'enabled': 'boolean',
        'mode': 'ContributorInsightsMode'
      },
      'deletionProtection': 'boolean',
      'pointInTimeRecovery': 'boolean',
      'pointInTimeRecoverySpecification': {
        'pointInTimeRecoveryEnabled': 'boolean',
        'recoveryPeriodInDays': '*'
      },
      'tableClass': 'TableClass',
      'kinesisStream': {
        'streamArn': '*',
        'streamName': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'tags': {
        'key': '*',
        'value': '*'
      },
      'resourcePolicy': '*',
      'addToResourcePolicy': [
        '*'
      ],
      'addReplica': [
        {
          'region': '*',
          'readCapacity': '*',
          'maxReadRequestUnits': '*',
          'globalSecondaryIndexOptions': '*',
          'contributorInsights': 'boolean',
          'contributorInsightsSpecification': {
            'enabled': 'boolean',
            'mode': 'ContributorInsightsMode'
          },
          'deletionProtection': 'boolean',
          'pointInTimeRecovery': 'boolean',
          'pointInTimeRecoverySpecification': {
            'pointInTimeRecoveryEnabled': 'boolean',
            'recoveryPeriodInDays': '*'
          },
          'tableClass': 'TableClass',
          'kinesisStream': {
            'streamArn': '*',
            'streamName': '*',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          },
          'tags': {
            'key': '*',
            'value': '*'
          },
          'resourcePolicy': '*'
        }
      ],
      'addGlobalSecondaryIndex': [
        {
          'partitionKey': {
            'name': '*',
            'type': 'AttributeType'
          },
          'readCapacity': '*',
          'maxReadRequestUnits': '*',
          'maxWriteRequestUnits': '*',
          'warmThroughput': {
            'readUnitsPerSecond': '*',
            'writeUnitsPerSecond': '*'
          },
          'indexName': '*',
          'projectionType': 'ProjectionType',
          'nonKeyAttributes': '*'
        }
      ],
      'addLocalSecondaryIndex': [
        {
          'sortKey': {
            'name': '*',
            'type': 'AttributeType'
          },
          'indexName': '*',
          'projectionType': 'ProjectionType',
          'nonKeyAttributes': '*'
        }
      ],
      'replica': [
        '*'
      ]
    },
    'TableV2MultiAccountReplica': {
      'replicaSourceTable': {
        'tableId': '*',
        'grants': '*',
        'tableArn': '*',
        'tableName': '*',
        'tableStreamArn': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'tableName': '*',
      'encryption': '*',
      'removalPolicy': 'RemovalPolicy',
      'globalTableSettingsReplicationMode': 'GlobalTableSettingsReplicationMode',
      'grantIndexPermissions': 'boolean',
      'contributorInsights': 'boolean',
      'contributorInsightsSpecification': {
        'enabled': 'boolean',
        'mode': 'ContributorInsightsMode'
      },
      'deletionProtection': 'boolean',
      'pointInTimeRecovery': 'boolean',
      'pointInTimeRecoverySpecification': {
        'pointInTimeRecoveryEnabled': 'boolean',
        'recoveryPeriodInDays': '*'
      },
      'tableClass': 'TableClass',
      'kinesisStream': {
        'streamArn': '*',
        'streamName': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'tags': {
        'key': '*',
        'value': '*'
      },
      'resourcePolicy': '*',
      'addToResourcePolicy': [
        '*'
      ]
    },
    'Table': {
      'tableName': '*',
      'kinesisStream': {
        'streamArn': '*',
        'streamName': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'kinesisPrecisionTimestamp': 'ApproximateCreationDateTimePrecision',
      'readCapacity': '*',
      'writeCapacity': '*',
      'maxReadRequestUnits': '*',
      'maxWriteRequestUnits': '*',
      'billingMode': 'BillingMode',
      'warmThroughput': {
        'readUnitsPerSecond': '*',
        'writeUnitsPerSecond': '*'
      },
      'pointInTimeRecovery': 'boolean',
      'pointInTimeRecoverySpecification': {
        'pointInTimeRecoveryEnabled': 'boolean',
        'recoveryPeriodInDays': '*'
      },
      'serverSideEncryption': 'boolean',
      'tableClass': 'TableClass',
      'encryption': 'TableEncryption',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'timeToLiveAttribute': '*',
      'stream': 'StreamViewType',
      'removalPolicy': 'RemovalPolicy',
      'replicaRemovalPolicy': 'RemovalPolicy',
      'replicationRegions': '*',
      'replicationTimeout': '*',
      'waitForReplicationToFinish': 'boolean',
      'contributorInsightsEnabled': 'boolean',
      'contributorInsightsSpecification': {
        'enabled': 'boolean',
        'mode': 'ContributorInsightsMode'
      },
      'deletionProtection': 'boolean',
      'importSource': {
        'compressionType': 'InputCompressionType',
        'inputFormat': '*',
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'bucketOwner': '*',
        'keyPrefix': '*'
      },
      'resourcePolicy': '*',
      'partitionKey': {
        'name': '*',
        'type': 'AttributeType'
      },
      'sortKey': {
        'name': '*',
        'type': 'AttributeType'
      },
      'addToResourcePolicy': [
        '*'
      ],
      'addGlobalSecondaryIndex': [
        {
          'partitionKeys': {
            'name': '*',
            'type': 'AttributeType'
          },
          'readCapacity': '*',
          'writeCapacity': '*',
          'maxReadRequestUnits': '*',
          'maxWriteRequestUnits': '*',
          'warmThroughput': {
            'readUnitsPerSecond': '*',
            'writeUnitsPerSecond': '*'
          },
          'contributorInsightsEnabled': 'boolean',
          'contributorInsightsSpecification': {
            'enabled': 'boolean',
            'mode': 'ContributorInsightsMode'
          },
          'indexName': '*',
          'projectionType': 'ProjectionType',
          'nonKeyAttributes': '*'
        }
      ],
      'addLocalSecondaryIndex': [
        {
          'sortKey': {
            'name': '*',
            'type': 'AttributeType'
          },
          'indexName': '*',
          'projectionType': 'ProjectionType',
          'nonKeyAttributes': '*'
        }
      ],
      'autoScaleReadCapacity': [
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ],
      'autoScaleWriteCapacity': [
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ],
      'autoScaleGlobalSecondaryIndexReadCapacity': [
        '*',
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ],
      'autoScaleGlobalSecondaryIndexWriteCapacity': [
        '*',
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ],
      'schema': [
        '*'
      ],
      'schemaV2': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-ec2': {
    'BastionHostLinux': {
      'availabilityZone': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'instanceName': '*',
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'instanceType': '*',
      'machineImage': '*',
      'blockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'init': '*',
      'initOptions': {
        'configSets': '*',
        'timeout': '*',
        'embedFingerprint': 'boolean',
        'printLog': 'boolean',
        'ignoreFailures': 'boolean',
        'includeUrl': 'boolean',
        'includeRole': 'boolean'
      },
      'requireImdsv2': 'boolean',
      'userDataCausesReplacement': 'boolean',
      'allowSshAccessFrom': [
        {
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ]
    },
    'ClientVpnAuthorizationRule': {
      'clientVpnEndpoint': '*',
      'clientVpnEndoint': '*',
      'cidr': '*',
      'groupId': '*',
      'description': '*'
    },
    'ClientVpnEndpoint': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'cidr': '*',
      'clientCertificateArn': '*',
      'userBasedAuthentication': '*',
      'logging': 'boolean',
      'logGroup': '*',
      'logStream': '*',
      'clientConnectionHandler': {
        'functionName': '*',
        'functionArn': '*'
      },
      'description': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'selfServicePortal': 'boolean',
      'serverCertificateArn': '*',
      'splitTunnel': 'boolean',
      'transportProtocol': 'TransportProtocol',
      'port': 'VpnPort',
      'dnsServers': '*',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'authorizeAllUsersToVpcCidr': 'boolean',
      'sessionTimeout': 'ClientVpnSessionTimeout',
      'disconnectOnSessionTimeout': 'boolean',
      'clientLoginBanner': '*',
      'clientRouteEnforcementOptions': {
        'enforced': 'boolean'
      },
      'addAuthorizationRule': [
        '*',
        {
          'cidr': '*',
          'groupId': '*',
          'description': '*'
        }
      ],
      'addRoute': [
        '*',
        {
          'cidr': '*',
          'description': '*',
          'target': '*'
        }
      ]
    },
    'ClientVpnRoute': {
      'clientVpnEndpoint': {
        'endpointId': '*',
        'targetNetworksAssociated': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'clientVpnEndoint': {
        'endpointId': '*',
        'targetNetworksAssociated': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'cidr': '*',
      'description': '*',
      'target': '*'
    },
    'Instance': {
      'keyName': '*',
      'keyPair': {
        'keyPairName': '*',
        'type': 'KeyPairType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'availabilityZone': '*',
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'resourceSignalTimeout': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'instanceType': '*',
      'machineImage': '*',
      'userData': '*',
      'userDataCausesReplacement': 'boolean',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'instanceProfile': {
        'instanceProfileName': '*',
        'instanceProfileArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'instanceName': '*',
      'sourceDestCheck': 'boolean',
      'blockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'privateIpAddress': '*',
      'propagateTagsToVolumeOnCreation': 'boolean',
      'init': '*',
      'initOptions': {
        'configSets': '*',
        'timeout': '*',
        'embedFingerprint': 'boolean',
        'printLog': 'boolean',
        'ignoreFailures': 'boolean',
        'includeUrl': 'boolean',
        'includeRole': 'boolean'
      },
      'requireImdsv2': 'boolean',
      'httpEndpoint': 'boolean',
      'httpProtocolIpv6': 'boolean',
      'httpPutResponseHopLimit': '*',
      'httpTokens': 'HttpTokens',
      'instanceMetadataTags': 'boolean',
      'detailedMonitoring': 'boolean',
      'ssmSessionPermissions': 'boolean',
      'associatePublicIpAddress': 'boolean',
      'creditSpecification': 'CpuCredits',
      'ebsOptimized': 'boolean',
      'disableApiTermination': 'boolean',
      'instanceInitiatedShutdownBehavior': 'InstanceInitiatedShutdownBehavior',
      'placementGroup': '*',
      'enclaveEnabled': 'boolean',
      'hibernationEnabled': 'boolean',
      'ipv6AddressCount': '*',
      'addSecurityGroup': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ],
      'addUserData': [
        '*'
      ],
      'addToRolePolicy': [
        '*'
      ],
      'applyCloudFormationInit': [
        '*',
        {
          'configSets': '*',
          'timeout': '*',
          'embedFingerprint': 'boolean',
          'printLog': 'boolean',
          'ignoreFailures': 'boolean',
          'includeUrl': 'boolean',
          'includeRole': 'boolean'
        }
      ]
    },
    'KeyPair': {
      '_isOsCompatible': [
        'OperatingSystemType'
      ]
    },
    'LaunchTemplate': {
      'launchTemplateName': '*',
      'versionDescription': '*',
      'instanceType': '*',
      'machineImage': '*',
      'userData': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'blockDevices': {
        'deviceName': '*',
        'volume': '*',
        'mappingEnabled': 'boolean'
      },
      'cpuCredits': 'CpuCredits',
      'disableApiTermination': 'boolean',
      'ebsOptimized': 'boolean',
      'nitroEnclaveEnabled': 'boolean',
      'hibernationConfigured': 'boolean',
      'instanceInitiatedShutdownBehavior': 'InstanceInitiatedShutdownBehavior',
      'spotOptions': {
        'blockDuration': '*',
        'interruptionBehavior': 'SpotInstanceInterruption',
        'maxPrice': '*',
        'requestType': 'SpotRequestType',
        'validUntil': '*'
      },
      'keyName': '*',
      'keyPair': {
        'keyPairName': '*',
        'type': 'KeyPairType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'detailedMonitoring': 'boolean',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'requireImdsv2': 'boolean',
      'httpEndpoint': 'boolean',
      'httpProtocolIpv6': 'boolean',
      'httpPutResponseHopLimit': '*',
      'httpTokens': 'LaunchTemplateHttpTokens',
      'instanceMetadataTags': 'boolean',
      'associatePublicIpAddress': 'boolean',
      'instanceProfile': {
        'instanceProfileName': '*',
        'instanceProfileArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'placementGroup': '*',
      'addSecurityGroup': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ]
    },
    'NetworkAcl': {
      'networkAclName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'associateWithSubnet': [
        '*',
        {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*',
          'subnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      ]
    },
    'NetworkAclEntry': {
      'networkAcl': {
        'networkAclId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'networkAclEntryName': '*',
      'cidr': '*',
      'traffic': '*',
      'direction': 'TrafficDirection',
      'ruleAction': 'Action',
      'ruleNumber': '*'
    },
    'SubnetNetworkAclAssociation': {
      'subnetNetworkAclAssociationName': '*',
      'networkAcl': '*',
      'subnet': {
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'PlacementGroup': {},
    'PrefixList': {},
    'SecurityGroup': {
      'securityGroupName': '*',
      'description': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'disableInlineRules': 'boolean',
      'addIngressRule': [
        {
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        '*',
        '*',
        'boolean'
      ],
      'addEgressRule': [
        {
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        '*',
        '*',
        'boolean'
      ]
    },
    'Volume': {
      'volumeName': '*',
      'availabilityZone': '*',
      'size': '*',
      'snapshotId': '*',
      'enableMultiAttach': 'boolean',
      'encrypted': 'boolean',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoEnableIo': 'boolean',
      'volumeType': 'EbsDeviceVolumeType',
      'iops': '*',
      'removalPolicy': 'RemovalPolicy',
      'throughput': '*',
      'volumeInitializationRate': '*'
    },
    'VpcEndpointService': {
      'vpcEndpointServiceName': '*',
      'vpcEndpointServiceLoadBalancers': {
        'loadBalancerArn': '*'
      },
      'acceptanceRequired': 'boolean',
      'contributorInsights': 'boolean',
      'whitelistedPrincipals': '*',
      'allowedPrincipals': '*',
      'supportedIpAddressTypes': 'IpAddressType',
      'allowedRegions': '*'
    },
    'GatewayVpcEndpoint': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'service': {
        'name': '*'
      },
      'subnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      }
    },
    'InterfaceVpcEndpoint': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'service': {
        'name': '*',
        'port': '*',
        'privateDnsDefault': 'boolean'
      },
      'privateDnsEnabled': 'boolean',
      'subnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'open': 'boolean',
      'lookupSupportedAzs': 'boolean',
      'ipAddressType': 'VpcEndpointIpAddressType',
      'dnsRecordIpType': 'VpcEndpointDnsRecordIpType',
      'privateDnsOnlyForInboundResolverEndpoint': 'VpcEndpointPrivateDnsOnlyForInboundResolverEndpoint',
      'serviceRegion': '*'
    },
    'FlowLog': {
      'flowLogName': '*',
      'resourceType': '*',
      'trafficType': 'FlowLogTrafficType',
      'destination': '*',
      'logFormat': '*',
      'maxAggregationInterval': 'FlowLogMaxAggregationInterval'
    },
    'Vpc': {
      'ipProtocol': 'IpProtocol',
      'ipAddresses': '*',
      'cidr': '*',
      'enableDnsHostnames': 'boolean',
      'enableDnsSupport': 'boolean',
      'defaultInstanceTenancy': 'DefaultInstanceTenancy',
      'maxAzs': '*',
      'reservedAzs': '*',
      'availabilityZones': '*',
      'natGateways': '*',
      'natGatewaySubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'natGatewayProvider': '*',
      'subnetConfiguration': {
        'cidrMask': '*',
        'subnetType': 'SubnetType',
        'name': '*',
        'reserved': 'boolean',
        'mapPublicIpOnLaunch': 'boolean',
        'ipv6AssignAddressOnCreation': 'boolean'
      },
      'vpnGateway': 'boolean',
      'vpnGatewayAsn': '*',
      'vpnConnections': '*',
      'vpnRoutePropagation': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'gatewayEndpoints': '*',
      'flowLogs': '*',
      'vpcName': '*',
      'restrictDefaultSecurityGroup': 'boolean',
      'createInternetGateway': 'boolean',
      'ipv6Addresses': {
        'amazonProvided': 'boolean'
      },
      'addS3Endpoint': [
        '*',
        {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*',
          'subnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      ],
      'addDynamoDbEndpoint': [
        '*',
        {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*',
          'subnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      ]
    },
    'Subnet': {
      'availabilityZone': '*',
      'vpcId': '*',
      'cidrBlock': '*',
      'mapPublicIpOnLaunch': 'boolean',
      'ipv6CidrBlock': '*',
      'assignIpv6AddressOnCreation': 'boolean',
      'addDefaultInternetRoute': [
        '*',
        '*'
      ],
      'addIpv6DefaultInternetRoute': [
        '*'
      ],
      'addIpv6DefaultEgressOnlyInternetRoute': [
        '*'
      ],
      'addDefaultNatRoute': [
        '*'
      ],
      'addIpv6Nat64Route': [
        '*'
      ],
      'addRoute': [
        '*',
        {
          'destinationCidrBlock': '*',
          'destinationIpv6CidrBlock': '*',
          'routerType': 'RouterType',
          'routerId': '*',
          'enablesInternetConnectivity': 'boolean'
        }
      ],
      'associateNetworkAcl': [
        '*',
        {
          'networkAclId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'PublicSubnet': {
      'availabilityZone': '*',
      'vpcId': '*',
      'cidrBlock': '*',
      'mapPublicIpOnLaunch': 'boolean',
      'ipv6CidrBlock': '*',
      'assignIpv6AddressOnCreation': 'boolean',
      'addNatGateway': [
        '*'
      ]
    },
    'PrivateSubnet': {
      'availabilityZone': '*',
      'vpcId': '*',
      'cidrBlock': '*',
      'mapPublicIpOnLaunch': 'boolean',
      'ipv6CidrBlock': '*',
      'assignIpv6AddressOnCreation': 'boolean'
    },
    'ImportedVpc': {
      'vpcId': '*',
      'vpcCidrBlock': '*',
      'availabilityZones': '*',
      'publicSubnetIds': '*',
      'publicSubnetNames': '*',
      'publicSubnetRouteTableIds': '*',
      'publicSubnetIpv4CidrBlocks': '*',
      'privateSubnetIds': '*',
      'privateSubnetNames': '*',
      'privateSubnetRouteTableIds': '*',
      'privateSubnetIpv4CidrBlocks': '*',
      'isolatedSubnetIds': '*',
      'isolatedSubnetNames': '*',
      'isolatedSubnetRouteTableIds': '*',
      'isolatedSubnetIpv4CidrBlocks': '*',
      'vpnGatewayId': '*',
      'region': '*'
    },
    'LookedUpVpc': {
      'vpcId': '*',
      'vpcCidrBlock': '*',
      'availabilityZones': '*',
      'publicSubnetIds': '*',
      'publicSubnetNames': '*',
      'publicSubnetRouteTableIds': '*',
      'privateSubnetIds': '*',
      'privateSubnetNames': '*',
      'privateSubnetRouteTableIds': '*',
      'isolatedSubnetIds': '*',
      'isolatedSubnetNames': '*',
      'isolatedSubnetRouteTableIds': '*',
      'vpnGatewayId': '*',
      'subnetGroups': {
        'name': '*',
        'type': 'VpcSubnetGroupType',
        'subnets': {
          'subnetId': '*',
          'availabilityZone': '*',
          'routeTableId': '*',
          'cidr': '*'
        }
      },
      'region': '*',
      'ownerAccountId': '*'
    },
    'ImportedSubnet': {
      'availabilityZone': '*',
      'ipv4CidrBlock': '*',
      'routeTableId': '*',
      'subnetId': '*',
      'associateNetworkAcl': [
        '*',
        {
          'networkAclId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'VpnGateway': {
      'type': '*',
      'amazonSideAsn': '*'
    },
    'VpnConnection': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ip': '*',
      'asn': '*',
      'staticRoutes': '*',
      'tunnelOptions': {
        'preSharedKey': '*',
        'preSharedKeySecret': '*',
        'tunnelInsideCidr': '*'
      }
    }
  },
  'aws-cdk-lib.aws-ecr': {
    'Repository': {
      'repositoryName': '*',
      'encryption': '*',
      'encryptionKey': '*',
      'lifecycleRules': {
        'rulePriority': '*',
        'description': '*',
        'tagStatus': 'TagStatus',
        'tagPrefixList': '*',
        'tagPatternList': '*',
        'maxImageCount': '*',
        'maxImageAge': '*'
      },
      'lifecycleRegistryId': '*',
      'removalPolicy': 'RemovalPolicy',
      'imageScanOnPush': 'boolean',
      'imageTagMutability': 'TagMutability',
      'imageTagMutabilityExclusionFilters': '*',
      'autoDeleteImages': 'boolean',
      'emptyOnDelete': 'boolean',
      'addToResourcePolicy': [
        '*'
      ],
      'addLifecycleRule': [
        {
          'rulePriority': '*',
          'description': '*',
          'tagStatus': 'TagStatus',
          'tagPrefixList': '*',
          'tagPatternList': '*',
          'maxImageCount': '*',
          'maxImageAge': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-ecs': {
    'Cluster': {
      'clusterName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'defaultCloudMapNamespace': {
        'name': '*',
        'type': 'NamespaceType',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'useForServiceConnect': 'boolean'
      },
      'capacity': {
        'instanceType': '*',
        'machineImage': '*',
        'taskDrainTime': '*',
        'spotInstanceDraining': 'boolean',
        'topicEncryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'machineImageType': 'MachineImageType',
        'minCapacity': '*',
        'maxCapacity': '*',
        'desiredCapacity': '*',
        'keyName': '*',
        'keyPair': {
          'keyPairName': '*',
          'type': 'KeyPairType'
        },
        'vpcSubnets': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*',
          'subnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            }
          }
        },
        'notificationsTopic': {
          'topicArn': '*',
          'topicName': '*',
          'contentBasedDeduplication': 'boolean',
          'fifo': 'boolean'
        },
        'notifications': {
          'scalingEvents': '*'
        },
        'allowAllOutbound': 'boolean',
        'updateType': 'UpdateType',
        'rollingUpdateConfiguration': {
          'maxBatchSize': '*',
          'minInstancesInService': '*',
          'minSuccessfulInstancesPercent': '*',
          'waitOnResourceSignals': 'boolean',
          'suspendProcesses': 'ScalingProcess'
        },
        'replacingUpdateMinSuccessfulInstancesPercent': '*',
        'ignoreUnmodifiedSizeProperties': 'boolean',
        'resourceSignalCount': '*',
        'associatePublicIpAddress': 'boolean',
        'spotPrice': '*',
        'healthCheck': '*',
        'healthChecks': '*',
        'blockDevices': {
          'deviceName': '*',
          'volume': '*',
          'mappingEnabled': 'boolean'
        },
        'instanceMonitoring': 'Monitoring',
        'groupMetrics': '*',
        'signals': '*',
        'updatePolicy': '*',
        'newInstancesProtectedFromScaleIn': 'boolean',
        'autoScalingGroupName': '*',
        'terminationPolicies': 'TerminationPolicy',
        'terminationPolicyCustomLambdaFunctionArn': '*',
        'capacityRebalance': 'boolean',
        'ssmSessionPermissions': 'boolean',
        'azCapacityDistributionStrategy': 'CapacityDistributionStrategy',
        'deletionProtection': 'DeletionProtection',
        'instanceLifecyclePolicy': {
          'retentionTriggers': {
            'terminateHookAbandon': 'TerminateHookAbandonAction'
          }
        }
      },
      'capacityProviders': '*',
      'enableFargateCapacityProviders': [],
      'containerInsights': 'boolean',
      'containerInsightsV2': 'ContainerInsights',
      'executeCommandConfiguration': {
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'logConfiguration': {
          'cloudWatchEncryptionEnabled': 'boolean',
          'cloudWatchLogGroup': '*',
          's3Bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'policy': '*',
            'replicationRoleArn': '*'
          },
          's3EncryptionEnabled': 'boolean',
          's3KeyPrefix': '*'
        },
        'logging': 'ExecuteCommandLogging'
      },
      'managedStorageConfiguration': {
        'fargateEphemeralStorageKmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'kmsKey': '*'
      },
      'addDefaultCapacityProviderStrategy': [
        {
          'capacityProvider': '*',
          'base': '*',
          'weight': '*'
        }
      ],
      'addDefaultCloudMapNamespace': [
        {
          'name': '*',
          'type': 'NamespaceType',
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'useForServiceConnect': 'boolean'
        }
      ],
      'addCapacity': [
        '*',
        {
          'instanceType': '*',
          'machineImage': '*',
          'taskDrainTime': '*',
          'spotInstanceDraining': 'boolean',
          'topicEncryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'machineImageType': 'MachineImageType',
          'minCapacity': '*',
          'maxCapacity': '*',
          'desiredCapacity': '*',
          'keyName': '*',
          'keyPair': {
            'keyPairName': '*',
            'type': 'KeyPairType'
          },
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            }
          },
          'notificationsTopic': {
            'topicArn': '*',
            'topicName': '*',
            'contentBasedDeduplication': 'boolean',
            'fifo': 'boolean'
          },
          'notifications': {
            'scalingEvents': '*'
          },
          'allowAllOutbound': 'boolean',
          'updateType': 'UpdateType',
          'rollingUpdateConfiguration': {
            'maxBatchSize': '*',
            'minInstancesInService': '*',
            'minSuccessfulInstancesPercent': '*',
            'waitOnResourceSignals': 'boolean',
            'suspendProcesses': 'ScalingProcess'
          },
          'replacingUpdateMinSuccessfulInstancesPercent': '*',
          'ignoreUnmodifiedSizeProperties': 'boolean',
          'resourceSignalCount': '*',
          'associatePublicIpAddress': 'boolean',
          'spotPrice': '*',
          'healthCheck': '*',
          'healthChecks': '*',
          'blockDevices': {
            'deviceName': '*',
            'volume': '*',
            'mappingEnabled': 'boolean'
          },
          'instanceMonitoring': 'Monitoring',
          'groupMetrics': '*',
          'signals': '*',
          'updatePolicy': '*',
          'newInstancesProtectedFromScaleIn': 'boolean',
          'autoScalingGroupName': '*',
          'terminationPolicies': 'TerminationPolicy',
          'terminationPolicyCustomLambdaFunctionArn': '*',
          'capacityRebalance': 'boolean',
          'ssmSessionPermissions': 'boolean',
          'azCapacityDistributionStrategy': 'CapacityDistributionStrategy',
          'deletionProtection': 'DeletionProtection',
          'instanceLifecyclePolicy': {
            'retentionTriggers': {
              'terminateHookAbandon': 'TerminateHookAbandonAction'
            }
          }
        }
      ],
      'addAsgCapacityProvider': [
        '*',
        {
          'taskDrainTime': '*',
          'spotInstanceDraining': 'boolean',
          'topicEncryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'machineImageType': 'MachineImageType'
        }
      ],
      'addManagedInstancesCapacityProvider': [
        '*'
      ],
      'addAutoScalingGroup': [
        '*',
        {
          'taskDrainTime': '*',
          'spotInstanceDraining': 'boolean',
          'topicEncryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'machineImageType': 'MachineImageType'
        }
      ],
      'addCapacityProvider': [
        '*'
      ],
      'arnForTasks': [
        '*'
      ],
      'grantTaskProtection': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'metricCpuReservation': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricCpuUtilization': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricMemoryReservation': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricMemoryUtilization': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    },
    'ImportedCluster': {
      'clusterName': '*',
      'clusterArn': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'hasEc2Capacity': 'boolean',
      'defaultCloudMapNamespace': {
        'namespaceName': '*',
        'namespaceId': '*',
        'namespaceArn': '*',
        'type': 'NamespaceType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoscalingGroup': {
        'autoScalingGroupName': '*',
        'autoScalingGroupArn': '*',
        'osType': 'OperatingSystemType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      },
      'executeCommandConfiguration': {
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'logConfiguration': {
          'cloudWatchEncryptionEnabled': 'boolean',
          'cloudWatchLogGroup': '*',
          's3Bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'policy': '*',
            'replicationRoleArn': '*'
          },
          's3EncryptionEnabled': 'boolean',
          's3KeyPrefix': '*'
        },
        'logging': 'ExecuteCommandLogging'
      }
    }
  },
  'aws-cdk-lib.aws-efs': {
    'AccessPoint': {
      'fileSystem': '*',
      'createAcl': {
        'ownerUid': '*',
        'ownerGid': '*',
        'permissions': '*'
      },
      'path': '*',
      'posixUser': {
        'uid': '*',
        'gid': '*',
        'secondaryGids': '*'
      },
      'clientToken': '*'
    },
    'ImportedAccessPoint': {
      'accessPointId': '*',
      'accessPointArn': '*',
      'fileSystem': '*'
    },
    'FileSystem': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'encrypted': 'boolean',
      'fileSystemName': '*',
      'kmsKey': '*',
      'lifecyclePolicy': 'LifecyclePolicy',
      'outOfInfrequentAccessPolicy': 'OutOfInfrequentAccessPolicy',
      'transitionToArchivePolicy': 'LifecyclePolicy',
      'performanceMode': 'PerformanceMode',
      'throughputMode': 'ThroughputMode',
      'provisionedThroughputPerSecond': '*',
      'removalPolicy': 'RemovalPolicy',
      'enableAutomaticBackups': 'boolean',
      'fileSystemPolicy': '*',
      'allowAnonymousAccess': 'boolean',
      'oneZone': 'boolean',
      'replicationOverwriteProtection': 'ReplicationOverwriteProtection',
      'replicationConfiguration': '*',
      'addAccessPoint': [
        '*',
        {
          'createAcl': {
            'ownerUid': '*',
            'ownerGid': '*',
            'permissions': '*'
          },
          'path': '*',
          'posixUser': {
            'uid': '*',
            'gid': '*',
            'secondaryGids': '*'
          },
          'clientToken': '*'
        }
      ]
    },
    'ImportedFileSystem': {
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'fileSystemId': '*',
      'fileSystemArn': '*'
    }
  },
  'aws-cdk-lib.aws-eks': {
    'AccessEntry': {
      'accessEntryName': '*',
      'accessEntryType': 'AccessEntryType',
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'kubectlRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          }
        },
        'kubectlEnvironment': '*',
        'kubectlLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProvider': {
          'serviceToken': '*',
          'roleArn': '*'
        },
        'kubectlMemory': '*',
        'prune': 'boolean',
        'authenticationMode': 'AuthenticationMode'
      },
      'accessPolicies': {
        'accessScope': {
          'namespaces': '*',
          'type': 'AccessScopeType'
        },
        'policy': '*'
      },
      'principal': '*',
      'removalPolicy': 'RemovalPolicy',
      'addAccessPolicies': [
        {
          'accessScope': {
            'namespaces': '*',
            'type': 'AccessScopeType'
          },
          'policy': '*'
        }
      ]
    },
    'Addon': {
      'addonName': '*',
      'addonVersion': '*',
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'kubectlRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          }
        },
        'kubectlEnvironment': '*',
        'kubectlLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProvider': {
          'serviceToken': '*',
          'roleArn': '*'
        },
        'kubectlMemory': '*',
        'prune': 'boolean',
        'authenticationMode': 'AuthenticationMode'
      },
      'preserveOnDelete': 'boolean',
      'configurationValues': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'Cluster': {
      'defaultCapacity': '*',
      'defaultCapacityInstance': '*',
      'defaultCapacityType': 'DefaultCapacityType',
      'kubectlLambdaRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'bootstrapClusterCreatorAdminPermissions': 'boolean',
      'bootstrapSelfManagedAddons': 'boolean',
      'tags': '*',
      'mastersRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'coreDnsComputeType': 'CoreDnsComputeType',
      'outputMastersRoleArn': 'boolean',
      'endpointAccess': '*',
      'kubectlEnvironment': '*',
      'kubectlLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'awscliLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlMemory': '*',
      'clusterHandlerEnvironment': '*',
      'clusterHandlerSecurityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'onEventLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'prune': 'boolean',
      'placeClusterHandlerInVpc': 'boolean',
      'secretsEncryptionKey': '*',
      'ipFamily': 'IpFamily',
      'serviceIpv4Cidr': '*',
      'albController': {
        'version': '*',
        'repository': '*',
        'policy': '*',
        'additionalHelmChartValues': {
          'enableWafv2': 'boolean',
          'enableWaf': 'boolean'
        },
        'overwriteServiceAccount': 'boolean',
        'removalPolicy': 'RemovalPolicy'
      },
      'clusterLogging': 'ClusterLoggingTypes',
      'authenticationMode': 'AuthenticationMode',
      'remoteNodeNetworks': {
        'cidrs': '*'
      },
      'remotePodNetworks': {
        'cidrs': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'clusterName': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'version': '*',
      'outputClusterName': 'boolean',
      'outputConfigCommand': 'boolean',
      'grantAccess': [
        '*',
        '*',
        {
          'accessScope': {
            'namespaces': '*',
            'type': 'AccessScopeType'
          },
          'policy': '*'
        },
        {
          'accessEntryType': 'AccessEntryType'
        }
      ],
      'getServiceLoadBalancerAddress': [
        '*',
        {
          'timeout': '*',
          'namespace': '*'
        }
      ],
      'getIngressLoadBalancerAddress': [
        '*',
        {
          'timeout': '*',
          'namespace': '*'
        }
      ],
      'addAutoScalingGroupCapacity': [
        '*',
        {
          'instanceType': '*',
          'mapRole': 'boolean',
          'bootstrapEnabled': 'boolean',
          'bootstrapOptions': {
            'useMaxPods': 'boolean',
            'enableDockerBridge': 'boolean',
            'awsApiRetryAttempts': '*',
            'dockerConfigJson': '*',
            'dnsClusterIp': '*',
            'kubeletExtraArgs': '*',
            'additionalArgs': '*'
          },
          'machineImageType': 'MachineImageType',
          'spotInterruptHandler': 'boolean',
          'minCapacity': '*',
          'maxCapacity': '*',
          'desiredCapacity': '*',
          'keyName': '*',
          'keyPair': {
            'keyPairName': '*',
            'type': 'KeyPairType',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            }
          },
          'notificationsTopic': {
            'topicArn': '*',
            'topicName': '*',
            'masterKey': {
              'keyArn': '*',
              'keyId': '*'
            },
            'contentBasedDeduplication': 'boolean',
            'fifo': 'boolean'
          },
          'notifications': {
            'scalingEvents': '*'
          },
          'allowAllOutbound': 'boolean',
          'updateType': 'UpdateType',
          'rollingUpdateConfiguration': {
            'maxBatchSize': '*',
            'minInstancesInService': '*',
            'minSuccessfulInstancesPercent': '*',
            'pauseTime': '*',
            'waitOnResourceSignals': 'boolean',
            'suspendProcesses': 'ScalingProcess'
          },
          'replacingUpdateMinSuccessfulInstancesPercent': '*',
          'ignoreUnmodifiedSizeProperties': 'boolean',
          'resourceSignalCount': '*',
          'associatePublicIpAddress': 'boolean',
          'spotPrice': '*',
          'healthCheck': '*',
          'healthChecks': '*',
          'blockDevices': {
            'deviceName': '*',
            'volume': '*',
            'mappingEnabled': 'boolean'
          },
          'instanceMonitoring': 'Monitoring',
          'groupMetrics': '*',
          'signals': '*',
          'updatePolicy': '*',
          'newInstancesProtectedFromScaleIn': 'boolean',
          'autoScalingGroupName': '*',
          'terminationPolicies': 'TerminationPolicy',
          'terminationPolicyCustomLambdaFunctionArn': '*',
          'capacityRebalance': 'boolean',
          'ssmSessionPermissions': 'boolean',
          'azCapacityDistributionStrategy': 'CapacityDistributionStrategy',
          'deletionProtection': 'DeletionProtection',
          'instanceLifecyclePolicy': {
            'retentionTriggers': {
              'terminateHookAbandon': 'TerminateHookAbandonAction'
            }
          }
        }
      ],
      'addNodegroupCapacity': [
        '*',
        {
          'nodegroupName': '*',
          'subnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          },
          'amiType': 'NodegroupAmiType',
          'diskSize': '*',
          'desiredSize': '*',
          'maxSize': '*',
          'minSize': '*',
          'forceUpdate': 'boolean',
          'instanceType': '*',
          'labels': '*',
          'taints': {
            'effect': 'TaintEffect',
            'key': '*',
            'value': '*'
          },
          'nodeRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            }
          },
          'releaseVersion': '*',
          'remoteAccess': {
            'sshKeyName': '*',
            'sourceSecurityGroups': {
              'securityGroupId': '*',
              'allowAllOutbound': 'boolean',
              'canInlineRule': 'boolean',
              'uniqueId': '*',
              'connections': '*'
            }
          },
          'tags': '*',
          'launchTemplateSpec': {
            'id': '*',
            'version': '*'
          },
          'capacityType': 'CapacityType',
          'maxUnavailable': '*',
          'maxUnavailablePercentage': '*',
          'enableNodeAutoRepair': 'boolean',
          'removalPolicy': 'RemovalPolicy'
        }
      ],
      'addFargateProfile': [
        '*',
        {
          'fargateProfileName': '*',
          'podExecutionRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'selectors': {
            'namespace': '*',
            'labels': '*'
          },
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'subnetSelection': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*'
          },
          'removalPolicy': 'RemovalPolicy'
        }
      ],
      '_attachFargateProfile': [
        '*'
      ],
      '_attachKubectlResourceScope': [
        '*'
      ]
    },
    'ImportedCluster': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'clusterName': '*',
      'clusterEndpoint': '*',
      'clusterCertificateAuthorityData': '*',
      'clusterSecurityGroupId': '*',
      'clusterEncryptionConfigKeyArn': '*',
      'ipFamily': 'IpFamily',
      'securityGroupIds': '*',
      'kubectlRoleArn': '*',
      'kubectlLambdaRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlEnvironment': '*',
      'kubectlSecurityGroupId': '*',
      'kubectlPrivateSubnetIds': '*',
      'openIdConnectProvider': {
        'openIdConnectProviderArn': '*',
        'openIdConnectProviderIssuer': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'awscliLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlProvider': {
        'serviceToken': '*',
        'roleArn': '*',
        'handlerRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'kubectlMemory': '*',
      'clusterHandlerSecurityGroupId': '*',
      'onEventLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'prune': 'boolean'
    },
    'FargateCluster': {
      'defaultProfile': {
        'fargateProfileName': '*',
        'podExecutionRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'selectors': {
          'namespace': '*',
          'labels': '*'
        },
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'subnetSelection': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*'
        },
        'removalPolicy': 'RemovalPolicy'
      },
      'mastersRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'coreDnsComputeType': 'CoreDnsComputeType',
      'outputMastersRoleArn': 'boolean',
      'endpointAccess': '*',
      'kubectlEnvironment': '*',
      'kubectlLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'awscliLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlMemory': '*',
      'clusterHandlerEnvironment': '*',
      'clusterHandlerSecurityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'onEventLayer': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'prune': 'boolean',
      'placeClusterHandlerInVpc': 'boolean',
      'secretsEncryptionKey': '*',
      'ipFamily': 'IpFamily',
      'serviceIpv4Cidr': '*',
      'albController': {
        'version': '*',
        'repository': '*',
        'policy': '*',
        'additionalHelmChartValues': {
          'enableWafv2': 'boolean',
          'enableWaf': 'boolean'
        },
        'overwriteServiceAccount': 'boolean',
        'removalPolicy': 'RemovalPolicy'
      },
      'clusterLogging': 'ClusterLoggingTypes',
      'authenticationMode': 'AuthenticationMode',
      'remoteNodeNetworks': {
        'cidrs': '*'
      },
      'remotePodNetworks': {
        'cidrs': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'clusterName': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'version': '*',
      'outputClusterName': 'boolean',
      'outputConfigCommand': 'boolean'
    },
    'Nodegroup': {
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'kubectlRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          }
        },
        'kubectlEnvironment': '*',
        'kubectlLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProvider': {
          'serviceToken': '*',
          'roleArn': '*'
        },
        'kubectlMemory': '*',
        'prune': 'boolean',
        'authenticationMode': 'AuthenticationMode'
      },
      'nodegroupName': '*',
      'subnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'amiType': 'NodegroupAmiType',
      'diskSize': '*',
      'desiredSize': '*',
      'maxSize': '*',
      'minSize': '*',
      'forceUpdate': 'boolean',
      'instanceType': '*',
      'instanceTypes': '*',
      'labels': '*',
      'taints': {
        'effect': 'TaintEffect',
        'key': '*',
        'value': '*'
      },
      'nodeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'releaseVersion': '*',
      'remoteAccess': {
        'sshKeyName': '*',
        'sourceSecurityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      },
      'tags': '*',
      'launchTemplateSpec': {
        'id': '*',
        'version': '*'
      },
      'capacityType': 'CapacityType',
      'maxUnavailable': '*',
      'maxUnavailablePercentage': '*',
      'enableNodeAutoRepair': 'boolean',
      'removalPolicy': 'RemovalPolicy'
    },
    'OpenIdConnectProvider': {
      'url': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'OidcProviderNative': {
      'url': '*',
      'removalPolicy': 'RemovalPolicy'
    }
  },
  'aws-cdk-lib.aws-eks-v2': {
    'AccessEntry': {
      'accessEntryName': '*',
      'accessEntryType': 'AccessEntryType',
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProviderOptions': {
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            }
          },
          'awscliLayer': {
            'layerVersionArn': '*',
            'compatibleRuntimes': '*'
          },
          'environment': '*',
          'memory': '*',
          'removalPolicy': 'RemovalPolicy'
        },
        'kubectlProvider': {
          'serviceToken': '*'
        },
        'prune': 'boolean'
      },
      'accessPolicies': {
        'accessScope': {
          'namespaces': '*',
          'type': 'AccessScopeType'
        },
        'policy': '*'
      },
      'principal': '*',
      'removalPolicy': 'RemovalPolicy',
      'addAccessPolicies': [
        {
          'accessScope': {
            'namespaces': '*',
            'type': 'AccessScopeType'
          },
          'policy': '*'
        }
      ]
    },
    'Addon': {
      'addonName': '*',
      'addonVersion': '*',
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProviderOptions': {
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            }
          },
          'awscliLayer': {
            'layerVersionArn': '*',
            'compatibleRuntimes': '*'
          },
          'environment': '*',
          'memory': '*',
          'removalPolicy': 'RemovalPolicy'
        },
        'kubectlProvider': {
          'serviceToken': '*'
        },
        'prune': 'boolean'
      },
      'preserveOnDelete': 'boolean',
      'configurationValues': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'Cluster': {
      'compute': {
        'nodePools': '*',
        'nodeRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'defaultCapacity': '*',
      'defaultCapacityInstance': '*',
      'defaultCapacityType': 'DefaultCapacityType',
      'bootstrapClusterCreatorAdminPermissions': 'boolean',
      'bootstrapSelfManagedAddons': 'boolean',
      'outputConfigCommand': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'clusterName': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'version': '*',
      'mastersRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'coreDnsComputeType': 'CoreDnsComputeType',
      'endpointAccess': '*',
      'prune': 'boolean',
      'secretsEncryptionKey': '*',
      'ipFamily': 'IpFamily',
      'serviceIpv4Cidr': '*',
      'albController': {
        'version': '*',
        'repository': '*',
        'policy': '*',
        'additionalHelmChartValues': '*',
        'overwriteServiceAccount': 'boolean',
        'removalPolicy': 'RemovalPolicy'
      },
      'clusterLogging': 'ClusterLoggingTypes',
      'tags': '*',
      'kubectlProviderOptions': {
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'awscliLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'environment': '*',
        'securityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'memory': '*',
        'privateSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          }
        },
        'removalPolicy': 'RemovalPolicy'
      },
      'remoteNodeNetworks': {
        'cidrs': '*'
      },
      'remotePodNetworks': {
        'cidrs': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'grantAccess': [
        '*',
        '*',
        {
          'accessScope': {
            'namespaces': '*',
            'type': 'AccessScopeType'
          },
          'policy': '*'
        },
        {
          'accessEntryType': 'AccessEntryType'
        }
      ],
      'grantClusterAdmin': [
        '*',
        '*'
      ],
      'getServiceLoadBalancerAddress': [
        '*',
        {
          'timeout': '*',
          'namespace': '*'
        }
      ],
      'getIngressLoadBalancerAddress': [
        '*',
        {
          'timeout': '*',
          'namespace': '*'
        }
      ],
      'addAutoScalingGroupCapacity': [
        '*',
        {
          'instanceType': '*',
          'bootstrapEnabled': 'boolean',
          'bootstrapOptions': {
            'useMaxPods': 'boolean',
            'enableDockerBridge': 'boolean',
            'awsApiRetryAttempts': '*',
            'dockerConfigJson': '*',
            'dnsClusterIp': '*',
            'kubeletExtraArgs': '*',
            'additionalArgs': '*'
          },
          'machineImageType': 'MachineImageType',
          'minCapacity': '*',
          'maxCapacity': '*',
          'desiredCapacity': '*',
          'keyName': '*',
          'keyPair': {
            'keyPairName': '*',
            'type': 'KeyPairType',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            }
          },
          'notificationsTopic': {
            'topicArn': '*',
            'topicName': '*',
            'masterKey': {
              'keyArn': '*',
              'keyId': '*'
            },
            'contentBasedDeduplication': 'boolean',
            'fifo': 'boolean'
          },
          'notifications': {
            'scalingEvents': '*'
          },
          'allowAllOutbound': 'boolean',
          'updateType': 'UpdateType',
          'rollingUpdateConfiguration': {
            'maxBatchSize': '*',
            'minInstancesInService': '*',
            'minSuccessfulInstancesPercent': '*',
            'pauseTime': '*',
            'waitOnResourceSignals': 'boolean',
            'suspendProcesses': 'ScalingProcess'
          },
          'replacingUpdateMinSuccessfulInstancesPercent': '*',
          'ignoreUnmodifiedSizeProperties': 'boolean',
          'resourceSignalCount': '*',
          'associatePublicIpAddress': 'boolean',
          'spotPrice': '*',
          'healthCheck': '*',
          'healthChecks': '*',
          'blockDevices': {
            'deviceName': '*',
            'volume': '*',
            'mappingEnabled': 'boolean'
          },
          'instanceMonitoring': 'Monitoring',
          'groupMetrics': '*',
          'signals': '*',
          'updatePolicy': '*',
          'newInstancesProtectedFromScaleIn': 'boolean',
          'autoScalingGroupName': '*',
          'terminationPolicies': 'TerminationPolicy',
          'terminationPolicyCustomLambdaFunctionArn': '*',
          'capacityRebalance': 'boolean',
          'ssmSessionPermissions': 'boolean',
          'azCapacityDistributionStrategy': 'CapacityDistributionStrategy',
          'deletionProtection': 'DeletionProtection',
          'instanceLifecyclePolicy': {
            'retentionTriggers': {
              'terminateHookAbandon': 'TerminateHookAbandonAction'
            }
          }
        }
      ],
      'addNodegroupCapacity': [
        '*',
        {
          'nodegroupName': '*',
          'subnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          },
          'amiType': 'NodegroupAmiType',
          'diskSize': '*',
          'desiredSize': '*',
          'maxSize': '*',
          'minSize': '*',
          'forceUpdate': 'boolean',
          'instanceTypes': '*',
          'labels': '*',
          'taints': {
            'effect': 'TaintEffect',
            'key': '*',
            'value': '*'
          },
          'nodeRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            }
          },
          'releaseVersion': '*',
          'remoteAccess': {
            'sshKeyName': '*',
            'sourceSecurityGroups': {
              'securityGroupId': '*',
              'allowAllOutbound': 'boolean',
              'canInlineRule': 'boolean',
              'uniqueId': '*',
              'connections': '*'
            }
          },
          'tags': '*',
          'launchTemplateSpec': {
            'id': '*',
            'version': '*'
          },
          'capacityType': 'CapacityType',
          'maxUnavailable': '*',
          'maxUnavailablePercentage': '*',
          'enableNodeAutoRepair': 'boolean',
          'removalPolicy': 'RemovalPolicy'
        }
      ],
      'addFargateProfile': [
        '*',
        {
          'fargateProfileName': '*',
          'podExecutionRole': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'selectors': {
            'namespace': '*',
            'labels': '*'
          },
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'subnetSelection': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*'
          },
          'removalPolicy': 'RemovalPolicy'
        }
      ],
      '_attachFargateProfile': [
        '*'
      ],
      '_dependOnKubectlBarrier': [
        '*'
      ]
    },
    'ImportedCluster': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'clusterName': '*',
      'clusterEndpoint': '*',
      'clusterCertificateAuthorityData': '*',
      'clusterSecurityGroupId': '*',
      'clusterEncryptionConfigKeyArn': '*',
      'ipFamily': 'IpFamily',
      'securityGroupIds': '*',
      'openIdConnectProvider': {
        'openIdConnectProviderArn': '*',
        'openIdConnectProviderIssuer': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'kubectlProvider': {
        'serviceToken': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'kubectlProviderOptions': {
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'awscliLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'environment': '*',
        'securityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'memory': '*',
        'privateSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          }
        },
        'removalPolicy': 'RemovalPolicy'
      },
      'prune': 'boolean'
    },
    'FargateCluster': {
      'defaultProfile': {
        'fargateProfileName': '*',
        'podExecutionRole': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'selectors': {
          'namespace': '*',
          'labels': '*'
        },
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'subnetSelection': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*'
        },
        'removalPolicy': 'RemovalPolicy'
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'clusterName': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'version': '*',
      'mastersRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'coreDnsComputeType': 'CoreDnsComputeType',
      'endpointAccess': '*',
      'prune': 'boolean',
      'secretsEncryptionKey': '*',
      'ipFamily': 'IpFamily',
      'serviceIpv4Cidr': '*',
      'albController': {
        'version': '*',
        'repository': '*',
        'policy': '*',
        'additionalHelmChartValues': '*',
        'overwriteServiceAccount': 'boolean',
        'removalPolicy': 'RemovalPolicy'
      },
      'clusterLogging': 'ClusterLoggingTypes',
      'tags': '*',
      'kubectlProviderOptions': {
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'awscliLayer': {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*'
        },
        'environment': '*',
        'securityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'memory': '*',
        'privateSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          }
        },
        'removalPolicy': 'RemovalPolicy'
      },
      'remoteNodeNetworks': {
        'cidrs': '*'
      },
      'remotePodNetworks': {
        'cidrs': '*'
      },
      'removalPolicy': 'RemovalPolicy'
    },
    'Nodegroup': {
      'cluster': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'clusterName': '*',
        'clusterArn': '*',
        'clusterEndpoint': '*',
        'clusterCertificateAuthorityData': '*',
        'clusterSecurityGroupId': '*',
        'clusterSecurityGroup': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'clusterEncryptionConfigKeyArn': '*',
        'openIdConnectProvider': {
          'openIdConnectProviderArn': '*',
          'openIdConnectProviderIssuer': '*'
        },
        'eksPodIdentityAgent': {
          'addonName': '*',
          'addonArn': '*'
        },
        'ipFamily': 'IpFamily',
        'kubectlProviderOptions': {
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            }
          },
          'awscliLayer': {
            'layerVersionArn': '*',
            'compatibleRuntimes': '*'
          },
          'environment': '*',
          'memory': '*',
          'removalPolicy': 'RemovalPolicy'
        },
        'kubectlProvider': {
          'serviceToken': '*'
        },
        'prune': 'boolean'
      },
      'nodegroupName': '*',
      'subnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'amiType': 'NodegroupAmiType',
      'diskSize': '*',
      'desiredSize': '*',
      'maxSize': '*',
      'minSize': '*',
      'forceUpdate': 'boolean',
      'instanceTypes': '*',
      'labels': '*',
      'taints': {
        'effect': 'TaintEffect',
        'key': '*',
        'value': '*'
      },
      'nodeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'releaseVersion': '*',
      'remoteAccess': {
        'sshKeyName': '*',
        'sourceSecurityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      },
      'tags': '*',
      'launchTemplateSpec': {
        'id': '*',
        'version': '*'
      },
      'capacityType': 'CapacityType',
      'maxUnavailable': '*',
      'maxUnavailablePercentage': '*',
      'enableNodeAutoRepair': 'boolean',
      'removalPolicy': 'RemovalPolicy'
    },
    'OpenIdConnectProvider': {
      'url': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'OidcProviderNative': {
      'url': '*',
      'removalPolicy': 'RemovalPolicy'
    }
  },
  'aws-cdk-lib.aws-elasticloadbalancing': {
    'LoadBalancer': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'internetFacing': 'boolean',
      'listeners': {
        'externalPort': '*',
        'externalProtocol': 'LoadBalancingProtocol',
        'internalPort': '*',
        'internalProtocol': 'LoadBalancingProtocol',
        'policyNames': '*',
        'sslCertificateId': '*',
        'sslCertificateArn': '*',
        'allowConnectionsFrom': {
          'connections': '*'
        }
      },
      'targets': {
        'connections': '*'
      },
      'healthCheck': {
        'port': '*',
        'protocol': 'LoadBalancingProtocol',
        'path': '*',
        'healthyThreshold': '*',
        'unhealthyThreshold': '*',
        'interval': '*'
      },
      'crossZone': 'boolean',
      'subnetSelection': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'accessLoggingPolicy': '*',
      'addListener': [
        {
          'externalPort': '*',
          'externalProtocol': 'LoadBalancingProtocol',
          'internalPort': '*',
          'internalProtocol': 'LoadBalancingProtocol',
          'policyNames': '*',
          'sslCertificateId': '*',
          'sslCertificateArn': '*',
          'allowConnectionsFrom': {
            'connections': '*'
          }
        }
      ],
      'addTarget': [
        {
          'connections': '*'
        }
      ],
      '_addInstanceId': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-elasticsearch': {
    'Domain': {
      'accessPolicies': '*',
      'advancedOptions': '*',
      'cognitoKibanaAuth': {
        'identityPoolId': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'userPoolId': '*'
      },
      'domainName': '*',
      'ebs': {
        'enabled': 'boolean',
        'iops': '*',
        'volumeSize': '*',
        'volumeType': 'EbsDeviceVolumeType'
      },
      'capacity': {
        'masterNodes': '*',
        'masterNodeInstanceType': '*',
        'dataNodes': '*',
        'dataNodeInstanceType': '*',
        'warmNodes': '*',
        'warmInstanceType': '*'
      },
      'zoneAwareness': {
        'enabled': 'boolean',
        'availabilityZoneCount': '*'
      },
      'version': '*',
      'encryptionAtRest': {
        'enabled': 'boolean',
        'kmsKey': '*'
      },
      'logging': {
        'slowSearchLogEnabled': 'boolean',
        'slowSearchLogGroup': '*',
        'slowIndexLogEnabled': 'boolean',
        'slowIndexLogGroup': '*',
        'appLogEnabled': 'boolean',
        'appLogGroup': '*',
        'auditLogEnabled': 'boolean',
        'auditLogGroup': '*'
      },
      'nodeToNodeEncryption': 'boolean',
      'automatedSnapshotStartHour': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'enforceHttps': 'boolean',
      'tlsSecurityPolicy': 'TLSSecurityPolicy',
      'fineGrainedAccessControl': {
        'masterUserArn': '*',
        'masterUserName': '*',
        'masterUserPassword': '*'
      },
      'useUnsignedBasicAuth': 'boolean',
      'enableVersionUpgrade': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'customEndpoint': {
        'domainName': '*',
        'certificate': '*',
        'hostedZone': {
          'hostedZoneId': '*',
          'zoneName': '*',
          'hostedZoneArn': '*',
          'hostedZoneNameServers': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'name': '*'
        }
      },
      'addAccessPolicies': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-events': {
    'ApiDestination': {
      'apiDestinationName': '*',
      'description': '*',
      'connection': '*',
      'endpoint': '*',
      'httpMethod': 'HttpMethod',
      'rateLimitPerSecond': '*'
    },
    'Archive': {
      'sourceEventBus': '*',
      'archiveName': '*',
      'description': '*',
      'eventPattern': {
        'version': '*',
        'id': '*',
        'detailType': '*',
        'source': '*',
        'account': '*',
        'time': '*',
        'region': '*',
        'resources': '*',
        'detail': '*'
      },
      'retention': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'Connection': {
      'connectionName': '*',
      'description': '*',
      'authorization': '*',
      'bodyParameters': '*',
      'headerParameters': '*',
      'queryStringParameters': '*'
    },
    'ImportedConnection': {
      'connectionName': '*',
      'connectionArn': '*',
      'connectionSecretArn': '*'
    },
    'EventBus': {
      'addToResourcePolicy': [
        '*'
      ]
    },
    'ImportedEventBus': {
      'eventBusName': '*',
      'eventBusArn': '*',
      'eventBusPolicy': '*',
      'eventSourceName': '*',
      'addToResourcePolicy': [
        '*'
      ]
    },
    'EventBusPolicy': {
      'eventBus': {
        'eventBusName': '*',
        'eventBusArn': '*',
        'eventBusPolicy': '*',
        'eventSourceName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'statement': '*',
      'statementId': '*'
    },
    'Rule': {
      'enabled': 'boolean',
      'schedule': '*',
      'targets': '*',
      'eventBus': '*',
      'role': '*',
      'description': '*',
      'ruleName': '*',
      'eventPattern': {
        'version': '*',
        'id': '*',
        'detailType': '*',
        'source': '*',
        'account': '*',
        'time': '*',
        'region': '*',
        'resources': '*',
        'detail': '*'
      },
      'crossStackScope': '*',
      'addTarget': [
        '*'
      ],
      'addEventPattern': [
        {
          'version': '*',
          'id': '*',
          'detailType': '*',
          'source': '*',
          'account': '*',
          'time': '*',
          'region': '*',
          'resources': '*',
          'detail': '*'
        }
      ],
      '_renderEventPattern': []
    },
    'MirrorRule': {
      'enabled': 'boolean',
      'schedule': '*',
      'targets': '*',
      'eventBus': '*',
      'role': '*',
      'description': '*',
      'ruleName': '*',
      'eventPattern': {
        'version': '*',
        'id': '*',
        'detailType': '*',
        'source': '*',
        'account': '*',
        'time': '*',
        'region': '*',
        'resources': '*',
        'detail': '*'
      },
      'crossStackScope': '*',
      '_renderEventPattern': []
    }
  },
  'aws-cdk-lib.aws-fsx': {
    'LustreFileSystem': {
      'lustreConfiguration': {
        'deploymentType': 'LustreDeploymentType',
        'exportPath': '*',
        'importedFileChunkSizeMiB': '*',
        'importPath': '*',
        'autoImportPolicy': 'LustreAutoImportPolicy',
        'dataCompressionType': 'LustreDataCompressionType',
        'perUnitStorageThroughput': '*',
        'weeklyMaintenanceStartTime': '*',
        'automaticBackupRetention': '*',
        'copyTagsToBackups': 'boolean',
        'dailyAutomaticBackupStartTime': '*',
        'driveCacheType': 'DriveCacheType'
      },
      'fileSystemTypeVersion': 'FileSystemTypeVersion',
      'vpcSubnet': {
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'backupId': '*',
      'kmsKey': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'storageCapacityGiB': '*',
      'removalPolicy': 'RemovalPolicy',
      'storageType': 'StorageType'
    }
  },
  'aws-cdk-lib.aws-globalaccelerator': {
    'Accelerator': {
      'acceleratorName': '*',
      'enabled': 'boolean',
      'ipAddresses': '*',
      'ipAddressType': 'IpAddressType',
      'addListener': [
        '*',
        {
          'listenerName': '*',
          'portRanges': {
            'fromPort': '*',
            'toPort': '*'
          },
          'protocol': 'ConnectionProtocol',
          'clientAffinity': 'ClientAffinity'
        }
      ]
    },
    'EndpointGroup': {
      'listener': '*',
      'endpointGroupName': '*',
      'region': '*',
      'healthCheckInterval': '*',
      'healthCheckPath': '*',
      'healthCheckPort': '*',
      'healthCheckProtocol': 'HealthCheckProtocol',
      'healthCheckThreshold': '*',
      'trafficDialPercentage': '*',
      'portOverrides': {
        'listenerPort': '*',
        'endpointPort': '*'
      },
      'endpoints': {
        'region': '*'
      },
      'addEndpoint': [
        {
          'region': '*'
        }
      ],
      'connectionsPeer': [
        '*',
        {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        }
      ]
    },
    'Listener': {
      'accelerator': '*',
      'listenerName': '*',
      'portRanges': {
        'fromPort': '*',
        'toPort': '*'
      },
      'protocol': 'ConnectionProtocol',
      'clientAffinity': 'ClientAffinity',
      'addEndpointGroup': [
        '*',
        {
          'endpointGroupName': '*',
          'region': '*',
          'healthCheckInterval': '*',
          'healthCheckPath': '*',
          'healthCheckPort': '*',
          'healthCheckProtocol': 'HealthCheckProtocol',
          'healthCheckThreshold': '*',
          'trafficDialPercentage': '*',
          'portOverrides': {
            'listenerPort': '*',
            'endpointPort': '*'
          },
          'endpoints': {
            'region': '*'
          }
        }
      ]
    }
  },
  'aws-cdk-lib.aws-iam': {
    'AccessKey': {
      'serial': '*',
      'status': 'AccessKeyStatus',
      'user': {
        'userName': '*',
        'userArn': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'Group': {
      'groupName': '*',
      'managedPolicies': {
        'managedPolicyArn': '*'
      },
      'path': '*',
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ]
    },
    'InstanceProfile': {
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'instanceProfileName': '*',
      'path': '*'
    },
    'LazyRole': {
      'assumedBy': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'externalId': '*',
      'externalIds': '*',
      'managedPolicies': {
        'managedPolicyArn': '*'
      },
      'inlinePolicies': '*',
      'path': '*',
      'permissionsBoundary': {
        'managedPolicyArn': '*'
      },
      'roleName': '*',
      'maxSessionDuration': '*',
      'description': '*',
      'addToPrincipalPolicy': [
        '*'
      ],
      'addToPolicy': [
        '*'
      ],
      'attachInlinePolicy': [
        '*'
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'grant': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        '*'
      ],
      'grantPassRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grantAssumeRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ]
    },
    'ManagedPolicy': {
      'managedPolicyName': '*',
      'description': '*',
      'path': '*',
      'users': {
        'userName': '*',
        'userArn': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'roles': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'groups': '*',
      'statements': '*',
      'document': '*',
      'addStatements': [
        '*'
      ],
      'attachToUser': [
        '*'
      ],
      'attachToRole': [
        {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'attachToGroup': [
        '*'
      ]
    },
    'OidcProviderNative': {
      'oidcProviderName': '*',
      'url': '*',
      'clientIds': '*',
      'thumbprints': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'OpenIdConnectProvider': {
      'url': '*',
      'clientIds': '*',
      'thumbprints': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'Policy': {
      'policyName': '*',
      'users': {
        'userName': '*',
        'userArn': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'roles': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'groups': {
        'groupName': '*',
        'groupArn': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'statements': '*',
      'force': 'boolean',
      'document': '*',
      'addStatements': [
        '*'
      ],
      'attachToUser': [
        {
          'userName': '*',
          'userArn': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'attachToRole': [
        {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'attachToGroup': [
        {
          'groupName': '*',
          'groupArn': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ]
    },
    'Role': {
      'assumedBy': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'externalId': '*',
      'externalIds': '*',
      'managedPolicies': {
        'managedPolicyArn': '*'
      },
      'inlinePolicies': '*',
      'path': '*',
      'permissionsBoundary': {
        'managedPolicyArn': '*'
      },
      'roleName': '*',
      'maxSessionDuration': '*',
      'description': '*',
      'addToPrincipalPolicy': [
        '*'
      ],
      'addToPolicy': [
        '*'
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'attachInlinePolicy': [
        '*'
      ],
      'grant': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        '*'
      ],
      'grantPassRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grantAssumeRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'withoutPolicyUpdates': [
        {
          'addGrantsToResources': 'boolean'
        }
      ],
      'applyRemovalPolicy': [
        'RemovalPolicy'
      ]
    },
    'SamlProvider': {
      'name': '*',
      'metadataDocument': '*'
    },
    'User': {
      'groups': {
        'groupName': '*',
        'groupArn': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'managedPolicies': {
        'managedPolicyArn': '*'
      },
      'path': '*',
      'permissionsBoundary': {
        'managedPolicyArn': '*'
      },
      'userName': '*',
      'password': '*',
      'passwordResetRequired': 'boolean',
      'addToGroup': [
        {
          'groupName': '*',
          'groupArn': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'attachInlinePolicy': [
        '*'
      ],
      'addToPrincipalPolicy': [
        '*'
      ],
      'addToPolicy': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-inspector': {
    'AssessmentTemplate': {}
  },
  'aws-cdk-lib.aws-kinesis': {
    'ResourcePolicy': {
      'stream': {
        'streamArn': '*',
        'streamName': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'streamConsumer': {
        'streamConsumerArn': '*',
        'streamConsumerName': '*',
        'stream': {
          'streamArn': '*',
          'streamName': '*',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          }
        }
      },
      'policyDocument': '*'
    },
    'StreamConsumer': {
      'streamConsumerName': '*',
      'stream': {
        'streamArn': '*',
        'streamName': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      }
    },
    'Stream': {
      'streamName': '*',
      'retentionPeriod': '*',
      'shardCount': '*',
      'encryption': 'StreamEncryption',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'streamMode': 'StreamMode',
      'removalPolicy': 'RemovalPolicy',
      'shardLevelMetrics': 'ShardLevelMetrics'
    }
  },
  'aws-cdk-lib.aws-kinesisfirehose': {
    'DeliveryStream': {
      'destination': '*',
      'deliveryStreamName': '*',
      'source': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'encryption': '*'
    }
  },
  'aws-cdk-lib.aws-kms': {
    'Alias': {
      'aliasName': '*',
      'targetKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'removalPolicy': 'RemovalPolicy'
    },
    'Key': {
      'description': '*',
      'alias': '*',
      'enableKeyRotation': 'boolean',
      'rotationPeriod': '*',
      'enabled': 'boolean',
      'keySpec': 'KeySpec',
      'keyUsage': 'KeyUsage',
      'multiRegion': 'boolean',
      'policy': '*',
      'admins': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'trustAccountIdentities': 'boolean',
      'pendingWindow': '*',
      'grantAdmin': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'ReferencedKey': {
      'environmentFromArn': '*',
      'keyArn': '*',
      'keyId': '*',
      'policy': '*',
      'trustAccountIdentities': 'boolean'
    }
  },
  'aws-cdk-lib.aws-lambda': {
    'Alias': {
      'aliasName': '*',
      'version': {
        'version': '*',
        'lambda': {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'edgeArn': '*',
        'functionName': '*',
        'functionArn': '*',
        'isBoundToVpc': 'boolean',
        'resourceArnsForGrantInvoke': '*'
      },
      'description': '*',
      'additionalVersions': {
        'version': {
          'version': '*',
          'lambda': {
            'functionName': '*',
            'functionArn': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'resourceArnsForGrantInvoke': '*'
        },
        'weight': '*'
      },
      'provisionedConcurrentExecutions': '*',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'addAutoScaling': [
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ]
    },
    'CapacityProvider': {
      'capacityProviderName': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'subnets': {
        'availabilityZone': '*',
        'subnetId': '*',
        'internetConnectivityEstablished': '*',
        'ipv4CidrBlock': '*',
        'routeTable': {
          'routeTableId': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'operatorRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'architectures': '*',
      'instanceTypeFilter': '*',
      'maxVCpuCount': '*',
      'scalingOptions': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'addFunction': [
        {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        },
        {
          'perExecutionEnvironmentMaxConcurrency': '*',
          'executionEnvironmentMemoryGiBPerVCpu': '*',
          'publishToLatestPublished': 'boolean',
          'latestPublishedScalingConfig': {
            'minExecutionEnvironments': '*',
            'maxExecutionEnvironments': '*'
          }
        }
      ]
    },
    'CodeSigningConfig': {
      'signingProfiles': {
        'signingProfileArn': '*',
        'signingProfileName': '*',
        'signingProfileVersion': '*',
        'signingProfileVersionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'untrustedArtifactOnDeployment': 'UntrustedArtifactOnDeployment',
      'description': '*'
    },
    'EventInvokeConfig': {
      'function': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'qualifier': '*',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*'
    },
    'EventSourceMapping': {
      'target': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'eventSourceArn': '*',
      'batchSize': '*',
      'bisectBatchOnError': 'boolean',
      'onFailure': '*',
      'enabled': 'boolean',
      'startingPosition': 'StartingPosition',
      'startingPositionTimestamp': '*',
      'reportBatchItemFailures': 'boolean',
      'maxBatchingWindow': '*',
      'maxConcurrency': '*',
      'maxRecordAge': '*',
      'retryAttempts': '*',
      'parallelizationFactor': '*',
      'kafkaTopic': '*',
      'tumblingWindow': '*',
      'kafkaBootstrapServers': '*',
      'kafkaConsumerGroupId': '*',
      'sourceAccessConfigurations': {
        'type': '*',
        'uri': '*'
      },
      'filters': '*',
      'filterEncryption': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'supportS3OnFailureDestination': 'boolean',
      'provisionedPollerConfig': {
        'minimumPollers': '*',
        'maximumPollers': '*',
        'pollerGroupName': '*'
      },
      'metricsConfig': {
        'metrics': 'MetricType'
      },
      'logLevel': 'EventSourceMappingLogLevel',
      'schemaRegistryConfig': '*'
    },
    'LatestVersion': {
      'addAlias': [
        '*',
        {
          'description': '*',
          'additionalVersions': {
            'version': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'weight': '*'
          },
          'provisionedConcurrentExecutions': '*',
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ]
    },
    'FunctionUrl': {
      'function': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'authType': 'FunctionUrlAuthType',
      'cors': {
        'allowCredentials': 'boolean',
        'allowedHeaders': '*',
        'allowedMethods': 'HttpMethod',
        'allowedOrigins': '*',
        'exposedHeaders': '*',
        'maxAge': '*'
      },
      'invokeMode': 'InvokeMode',
      'grantInvokeUrl': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'Function': {
      'runtime': '*',
      'code': '*',
      'handler': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'addEnvironment': [
        '*',
        '*',
        {
          'removeInEdge': 'boolean'
        }
      ],
      'invalidateVersionBasedOn': [
        '*'
      ],
      'addLayers': [
        {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'addVersion': [
        '*',
        '*',
        '*',
        '*',
        {
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ],
      'addAlias': [
        '*',
        {
          'description': '*',
          'additionalVersions': {
            'version': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'weight': '*'
          },
          'provisionedConcurrentExecutions': '*',
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ],
      '_checkEdgeCompatibility': []
    },
    'DockerImageFunction': {
      'code': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*'
    },
    'Version': {
      'lambda': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'codeSha256': '*',
      'description': '*',
      'provisionedConcurrentExecutions': '*',
      'removalPolicy': 'RemovalPolicy',
      'minExecutionEnvironments': '*',
      'maxExecutionEnvironments': '*',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'addAlias': [
        '*',
        {
          'description': '*',
          'additionalVersions': {
            'version': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'weight': '*'
          },
          'provisionedConcurrentExecutions': '*',
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ]
    },
    'LayerVersion': {
      'compatibleRuntimes': '*',
      'compatibleArchitectures': '*',
      'code': '*',
      'description': '*',
      'license': '*',
      'layerVersionName': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'SingletonFunction': {
      'uuid': '*',
      'lambdaPurpose': '*',
      'runtime': '*',
      'code': '*',
      'handler': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'addEnvironment': [
        '*',
        '*',
        {
          'removeInEdge': 'boolean'
        }
      ],
      'addLayers': [
        {
          'layerVersionArn': '*',
          'compatibleRuntimes': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      ],
      'addPermission': [
        '*',
        {
          'action': '*',
          'eventSourceToken': '*',
          'principal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          },
          'scope': '*',
          'sourceAccount': '*',
          'sourceArn': '*',
          'organizationId': '*',
          'functionUrlAuthType': 'FunctionUrlAuthType',
          'invokedViaFunctionUrl': 'boolean'
        }
      ],
      'addDependency': [
        '*'
      ],
      'addMetadata': [
        '*',
        '*',
        {
          'stackTrace': 'boolean',
          'traceFromFunction': '*'
        }
      ],
      'dependOn': [
        {
          'node': '*'
        }
      ],
      '_checkEdgeCompatibility': []
    }
  },
  'aws-cdk-lib.aws-lambda-nodejs': {
    'NodejsFunction': {
      'entry': '*',
      'handler': '*',
      'runtime': '*',
      'awsSdkConnectionReuse': 'boolean',
      'depsLockFilePath': '*',
      'bundling': {
        'minify': 'boolean',
        'sourceMap': 'boolean',
        'sourceMapMode': 'SourceMapMode',
        'sourcesContent': 'boolean',
        'target': '*',
        'loader': '*',
        'logLevel': 'LogLevel',
        'keepNames': 'boolean',
        'tsconfig': '*',
        'metafile': 'boolean',
        'banner': '*',
        'footer': '*',
        'charset': 'Charset',
        'define': '*',
        'externalModules': '*',
        'bundleAwsSDK': 'boolean',
        'nodeModules': '*',
        'esbuildVersion': '*',
        'esbuildArgs': '*',
        'buildArgs': '*',
        'forceDockerBundling': 'boolean',
        'preCompilation': 'boolean',
        'dockerImage': '*',
        'commandHooks': '*',
        'assetHash': '*',
        'format': 'OutputFormat',
        'mainFields': '*',
        'inject': '*',
        'bundlingFileAccess': 'BundlingFileAccess',
        'entrypoint': '*',
        'command': '*',
        'volumes': {
          'hostPath': '*',
          'containerPath': '*',
          'consistency': 'DockerVolumeConsistency'
        },
        'volumesFrom': '*',
        'environment': '*',
        'workingDirectory': '*',
        'user': '*',
        'securityOpt': '*',
        'network': '*',
        'platform': '*'
      },
      'projectRoot': '*',
      'code': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*'
    }
  },
  'aws-cdk-lib.aws-logs': {
    'CrossAccountDestination': {
      'destinationName': '*',
      'role': '*',
      'targetArn': '*',
      'addToPolicy': [
        '*'
      ],
      'bind': [
        '*',
        '*'
      ]
    },
    'LogGroup': {
      'encryptionKey': '*',
      'logGroupName': '*',
      'dataProtectionPolicy': '*',
      'deletionProtectionEnabled': 'boolean',
      'fieldIndexPolicies': '*',
      'retention': 'RetentionDays',
      'logGroupClass': 'LogGroupClass',
      'removalPolicy': 'RemovalPolicy'
    },
    'LogStream': {
      'logGroup': '*',
      'logStreamName': '*',
      'removalPolicy': 'RemovalPolicy'
    },
    'MetricFilter': {
      'logGroup': '*',
      'filterPattern': {
        'logPatternString': '*'
      },
      'metricNamespace': '*',
      'metricName': '*',
      'metricValue': '*',
      'defaultValue': '*',
      'dimensions': '*',
      'unit': 'Unit',
      'filterName': '*',
      'applyOnTransformedLogs': 'boolean',
      'metric': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    },
    'ResourcePolicy': {},
    'QueryDefinition': {
      'queryDefinitionName': '*',
      'queryString': '*',
      'logGroups': '*'
    },
    'SubscriptionFilter': {
      'logGroup': '*',
      'destination': '*',
      'filterPattern': {
        'logPatternString': '*'
      },
      'filterName': '*',
      'distribution': 'Distribution'
    },
    'Transformer': {
      'transformerName': '*',
      'logGroup': '*',
      'transformerConfig': '*'
    }
  },
  'aws-cdk-lib.aws-opensearchservice': {
    'Domain': {
      'accessPolicies': '*',
      'advancedOptions': '*',
      'cognitoDashboardsAuth': {
        'identityPoolId': '*',
        'role': '*',
        'userPoolId': '*'
      },
      'domainName': '*',
      'ebs': {
        'enabled': 'boolean',
        'iops': '*',
        'throughput': '*',
        'volumeSize': '*',
        'volumeType': 'EbsDeviceVolumeType'
      },
      'capacity': {
        'masterNodes': '*',
        'masterNodeInstanceType': '*',
        'dataNodes': '*',
        'dataNodeInstanceType': '*',
        'warmNodes': '*',
        'warmInstanceType': '*',
        'multiAzWithStandbyEnabled': 'boolean',
        'nodeOptions': {
          'nodeType': 'NodeType',
          'nodeConfig': {
            'enabled': 'boolean',
            'type': '*',
            'count': '*'
          }
        }
      },
      'zoneAwareness': {
        'enabled': 'boolean',
        'availabilityZoneCount': '*'
      },
      'version': '*',
      'encryptionAtRest': {
        'enabled': 'boolean',
        'kmsKey': '*'
      },
      'logging': {
        'slowSearchLogEnabled': 'boolean',
        'slowSearchLogGroup': '*',
        'slowIndexLogEnabled': 'boolean',
        'slowIndexLogGroup': '*',
        'appLogEnabled': 'boolean',
        'appLogGroup': '*',
        'auditLogEnabled': 'boolean',
        'auditLogGroup': '*'
      },
      'nodeToNodeEncryption': 'boolean',
      'automatedSnapshotStartHour': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'enforceHttps': 'boolean',
      'tlsSecurityPolicy': 'TLSSecurityPolicy',
      'fineGrainedAccessControl': {
        'masterUserArn': '*',
        'masterUserName': '*',
        'masterUserPassword': '*',
        'samlAuthenticationEnabled': 'boolean',
        'samlAuthenticationOptions': {
          'idpEntityId': '*',
          'idpMetadataContent': '*',
          'masterUserName': '*',
          'masterBackendRole': '*',
          'rolesKey': '*',
          'subjectKey': '*',
          'sessionTimeoutMinutes': '*'
        }
      },
      'useUnsignedBasicAuth': 'boolean',
      'enableVersionUpgrade': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'customEndpoint': {
        'domainName': '*',
        'certificate': '*',
        'hostedZone': {
          'hostedZoneId': '*',
          'zoneName': '*',
          'hostedZoneArn': '*',
          'hostedZoneNameServers': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'name': '*'
        }
      },
      'offPeakWindowEnabled': 'boolean',
      'offPeakWindowStart': {
        'hours': '*',
        'minutes': '*'
      },
      'enableAutoSoftwareUpdate': 'boolean',
      'ipAddressType': 'IpAddressType',
      'suppressLogsResourcePolicy': 'boolean',
      'coldStorageEnabled': 'boolean',
      's3VectorsEngineEnabled': 'boolean',
      'addAccessPolicies': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-rds': {
    'AuroraClusterInstance': {
      'cluster': {
        'clusterIdentifier': '*',
        'clusterResourceIdentifier': '*',
        'instanceIdentifiers': '*',
        'clusterEndpoint': '*',
        'engine': {
          'singleUserRotationApplication': '*',
          'supportedLogTypes': '*',
          'combineImportAndExportRoles': 'boolean',
          'engineType': '*',
          'engineVersion': {
            'fullVersion': '*',
            'majorVersion': '*'
          },
          'parameterGroupFamily': '*',
          'engineFamily': '*',
          'defaultUsername': '*'
        },
        'clusterArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'instanceType': '*',
      'promotionTier': '*',
      'instanceIdentifier': '*',
      'autoMinorVersionUpgrade': 'boolean',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'publiclyAccessible': 'boolean',
      'availabilityZone': '*',
      'preferredMaintenanceWindow': '*',
      'parameters': '*',
      'allowMajorVersionUpgrade': 'boolean',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'isFromLegacyInstanceProps': 'boolean',
      'caCertificate': '*',
      'applyImmediately': 'boolean',
      'monitoringInterval': '*',
      'monitoringRole': '*',
      'removalPolicy': 'RemovalPolicy',
      'subnetGroup': '*'
    },
    'ImportedDatabaseCluster': {
      'clusterIdentifier': '*',
      'clusterResourceIdentifier': '*',
      'port': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'instanceIdentifiers': '*',
      'clusterEndpointAddress': '*',
      'readerEndpointAddress': '*',
      'instanceEndpointAddresses': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportedLogTypes': '*',
        'combineImportAndExportRoles': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'secret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'dataApiEnabled': 'boolean'
    },
    'DatabaseCluster': {
      'credentials': '*',
      'replicationSourceIdentifier': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportedLogTypes': '*',
        'combineImportAndExportRoles': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'instances': '*',
      'instanceProps': {
        'instanceType': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'vpcSubnets': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*'
        },
        'securityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'parameterGroup': '*',
        'parameters': '*',
        'enablePerformanceInsights': 'boolean',
        'performanceInsightRetention': 'PerformanceInsightRetention',
        'performanceInsightEncryptionKey': {
          'keyArn': '*',
          'keyId': '*'
        },
        'autoMinorVersionUpgrade': 'boolean',
        'allowMajorVersionUpgrade': 'boolean',
        'deleteAutomatedBackups': 'boolean',
        'publiclyAccessible': 'boolean',
        'preferredMaintenanceWindow': '*'
      },
      'writer': '*',
      'readers': '*',
      'serverlessV2MaxCapacity': '*',
      'serverlessV2MinCapacity': '*',
      'serverlessV2AutoPauseDuration': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'instanceUpdateBehaviour': 'InstanceUpdateBehaviour',
      'backtrackWindow': '*',
      'backup': {
        'retention': '*',
        'preferredWindow': '*'
      },
      'port': '*',
      'clusterIdentifier': '*',
      'instanceIdentifierBase': '*',
      'defaultDatabaseName': '*',
      'deletionProtection': 'boolean',
      'preferredMaintenanceWindow': '*',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'parameters': '*',
      'removalPolicy': 'RemovalPolicy',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'monitoringInterval': '*',
      'monitoringRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enableClusterLevelEnhancedMonitoring': 'boolean',
      's3ImportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ImportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3ExportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ExportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'subnetGroup': '*',
      'iamAuthentication': 'boolean',
      'storageEncrypted': 'boolean',
      'storageEncryptionKey': '*',
      'storageType': 'DBClusterStorageType',
      'copyTagsToSnapshot': 'boolean',
      'networkType': 'NetworkType',
      'domain': '*',
      'domainRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enableDataApi': 'boolean',
      'enableLocalWriteForwarding': 'boolean',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'databaseInsightsMode': 'DatabaseInsightsMode',
      'autoMinorVersionUpgrade': 'boolean',
      'clusterScalabilityType': 'ClusterScalabilityType',
      'clusterScailabilityType': 'ClusterScailabilityType',
      'engineLifecycleSupport': 'EngineLifecycleSupport',
      'deleteAutomatedBackups': 'boolean'
    },
    'DatabaseClusterFromSnapshot': {
      'snapshotIdentifier': '*',
      'credentials': '*',
      'snapshotCredentials': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportedLogTypes': '*',
        'combineImportAndExportRoles': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'instances': '*',
      'instanceProps': {
        'instanceType': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'vpcSubnets': {
          'subnetType': 'SubnetType',
          'availabilityZones': '*',
          'subnetGroupName': '*',
          'subnetName': '*',
          'onePerAz': 'boolean',
          'subnetFilters': '*'
        },
        'securityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        },
        'parameterGroup': '*',
        'parameters': '*',
        'enablePerformanceInsights': 'boolean',
        'performanceInsightRetention': 'PerformanceInsightRetention',
        'performanceInsightEncryptionKey': {
          'keyArn': '*',
          'keyId': '*'
        },
        'autoMinorVersionUpgrade': 'boolean',
        'allowMajorVersionUpgrade': 'boolean',
        'deleteAutomatedBackups': 'boolean',
        'publiclyAccessible': 'boolean',
        'preferredMaintenanceWindow': '*'
      },
      'writer': '*',
      'readers': '*',
      'serverlessV2MaxCapacity': '*',
      'serverlessV2MinCapacity': '*',
      'serverlessV2AutoPauseDuration': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'instanceUpdateBehaviour': 'InstanceUpdateBehaviour',
      'backtrackWindow': '*',
      'backup': {
        'retention': '*',
        'preferredWindow': '*'
      },
      'port': '*',
      'clusterIdentifier': '*',
      'instanceIdentifierBase': '*',
      'defaultDatabaseName': '*',
      'deletionProtection': 'boolean',
      'preferredMaintenanceWindow': '*',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'parameters': '*',
      'removalPolicy': 'RemovalPolicy',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'monitoringInterval': '*',
      'monitoringRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enableClusterLevelEnhancedMonitoring': 'boolean',
      's3ImportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ImportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3ExportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ExportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'subnetGroup': '*',
      'iamAuthentication': 'boolean',
      'storageEncrypted': 'boolean',
      'storageEncryptionKey': '*',
      'storageType': 'DBClusterStorageType',
      'copyTagsToSnapshot': 'boolean',
      'networkType': 'NetworkType',
      'domain': '*',
      'domainRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enableDataApi': 'boolean',
      'enableLocalWriteForwarding': 'boolean',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'databaseInsightsMode': 'DatabaseInsightsMode',
      'autoMinorVersionUpgrade': 'boolean',
      'clusterScalabilityType': 'ClusterScalabilityType',
      'clusterScailabilityType': 'ClusterScailabilityType',
      'engineLifecycleSupport': 'EngineLifecycleSupport',
      'deleteAutomatedBackups': 'boolean'
    },
    'DatabaseSecret': {
      'username': '*',
      'dbname': '*',
      'secretName': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'masterSecret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'excludeCharacters': '*',
      'replaceOnPasswordCriteriaChanges': 'boolean',
      'replicaRegions': {
        'region': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      }
    },
    'DatabaseInstance': {
      'credentials': '*',
      'characterSetName': '*',
      'storageEncrypted': 'boolean',
      'storageEncryptionKey': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportsReadReplicaBackups': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'instanceType': '*',
      'licenseModel': 'LicenseModel',
      'allowMajorVersionUpgrade': 'boolean',
      'timezone': '*',
      'allocatedStorage': '*',
      'databaseName': '*',
      'parameters': '*',
      'multiAz': 'boolean',
      'availabilityZone': '*',
      'storageType': 'StorageType',
      'storageThroughput': '*',
      'iops': '*',
      'processorFeatures': {
        'coreCount': '*',
        'threadsPerCore': '*'
      },
      'instanceIdentifier': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcPlacement': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'port': '*',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'optionGroup': {
        'optionGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'iamAuthentication': 'boolean',
      'backupRetention': '*',
      'preferredBackupWindow': '*',
      'copyTagsToSnapshot': 'boolean',
      'deleteAutomatedBackups': 'boolean',
      'monitoringInterval': '*',
      'monitoringRole': '*',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': '*',
      'databaseInsightsMode': 'DatabaseInsightsMode',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoMinorVersionUpgrade': 'boolean',
      'preferredMaintenanceWindow': '*',
      'deletionProtection': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'maxAllocatedStorage': '*',
      'domain': '*',
      'domainRole': '*',
      'subnetGroup': '*',
      's3ImportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ImportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3ExportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ExportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'publiclyAccessible': 'boolean',
      'networkType': 'NetworkType',
      'caCertificate': '*',
      'applyImmediately': 'boolean',
      'engineLifecycleSupport': 'EngineLifecycleSupport'
    },
    'DatabaseInstanceFromSnapshot': {
      'snapshotIdentifier': '*',
      'clusterSnapshotIdentifier': '*',
      'credentials': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportsReadReplicaBackups': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'instanceType': '*',
      'licenseModel': 'LicenseModel',
      'allowMajorVersionUpgrade': 'boolean',
      'timezone': '*',
      'allocatedStorage': '*',
      'databaseName': '*',
      'parameters': '*',
      'multiAz': 'boolean',
      'availabilityZone': '*',
      'storageType': 'StorageType',
      'storageThroughput': '*',
      'iops': '*',
      'processorFeatures': {
        'coreCount': '*',
        'threadsPerCore': '*'
      },
      'instanceIdentifier': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcPlacement': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'port': '*',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'optionGroup': {
        'optionGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'iamAuthentication': 'boolean',
      'backupRetention': '*',
      'preferredBackupWindow': '*',
      'copyTagsToSnapshot': 'boolean',
      'deleteAutomatedBackups': 'boolean',
      'monitoringInterval': '*',
      'monitoringRole': '*',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': '*',
      'databaseInsightsMode': 'DatabaseInsightsMode',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoMinorVersionUpgrade': 'boolean',
      'preferredMaintenanceWindow': '*',
      'deletionProtection': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'maxAllocatedStorage': '*',
      'domain': '*',
      'domainRole': '*',
      'subnetGroup': '*',
      's3ImportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ImportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3ExportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ExportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'publiclyAccessible': 'boolean',
      'networkType': 'NetworkType',
      'caCertificate': '*',
      'applyImmediately': 'boolean',
      'engineLifecycleSupport': 'EngineLifecycleSupport'
    },
    'DatabaseInstanceReadReplica': {
      'instanceType': '*',
      'sourceDatabaseInstance': {
        'instanceIdentifier': '*',
        'instanceArn': '*',
        'dbInstanceEndpointAddress': '*',
        'dbInstanceEndpointPort': '*',
        'instanceResourceId': '*',
        'instanceEndpoint': '*',
        'engine': {
          'singleUserRotationApplication': '*',
          'supportsReadReplicaBackups': 'boolean',
          'engineType': '*',
          'engineVersion': {
            'fullVersion': '*',
            'majorVersion': '*'
          },
          'parameterGroupFamily': '*',
          'engineFamily': '*',
          'defaultUsername': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'connections': '*'
      },
      'storageEncrypted': 'boolean',
      'storageEncryptionKey': '*',
      'allocatedStorage': '*',
      'multiAz': 'boolean',
      'availabilityZone': '*',
      'storageType': 'StorageType',
      'storageThroughput': '*',
      'iops': '*',
      'processorFeatures': {
        'coreCount': '*',
        'threadsPerCore': '*'
      },
      'instanceIdentifier': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcPlacement': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'port': '*',
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'optionGroup': {
        'optionGroupName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'iamAuthentication': 'boolean',
      'backupRetention': '*',
      'preferredBackupWindow': '*',
      'copyTagsToSnapshot': 'boolean',
      'deleteAutomatedBackups': 'boolean',
      'monitoringInterval': '*',
      'monitoringRole': '*',
      'enablePerformanceInsights': 'boolean',
      'performanceInsightRetention': 'PerformanceInsightRetention',
      'performanceInsightEncryptionKey': '*',
      'databaseInsightsMode': 'DatabaseInsightsMode',
      'cloudwatchLogsExports': '*',
      'cloudwatchLogsRetention': 'RetentionDays',
      'cloudwatchLogsRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'autoMinorVersionUpgrade': 'boolean',
      'preferredMaintenanceWindow': '*',
      'deletionProtection': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'maxAllocatedStorage': '*',
      'domain': '*',
      'domainRole': '*',
      'subnetGroup': '*',
      's3ImportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ImportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      's3ExportRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      's3ExportBuckets': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'publiclyAccessible': 'boolean',
      'networkType': 'NetworkType',
      'caCertificate': '*',
      'applyImmediately': 'boolean',
      'engineLifecycleSupport': 'EngineLifecycleSupport'
    },
    'OptionGroup': {
      'engine': {
        'singleUserRotationApplication': '*',
        'supportsReadReplicaBackups': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'description': '*',
      'configurations': {
        'name': '*',
        'settings': '*',
        'version': '*',
        'port': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'securityGroups': {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      },
      'optionGroupName': '*',
      'addConfiguration': [
        {
          'name': '*',
          'settings': '*',
          'version': '*',
          'port': '*',
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'securityGroups': {
            'securityGroupId': '*',
            'allowAllOutbound': 'boolean',
            'canInlineRule': 'boolean',
            'uniqueId': '*',
            'connections': '*'
          }
        }
      ]
    },
    'ParameterGroup': {
      'engine': {
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'name': '*',
      'description': '*',
      'parameters': '*',
      'removalPolicy': 'RemovalPolicy',
      'bindToCluster': [
        '*'
      ],
      'bindToInstance': [
        '*'
      ],
      'addParameter': [
        '*',
        '*'
      ]
    },
    'DatabaseProxyEndpoint': {
      'dbProxy': '*',
      'dbProxyEndpointName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'targetRole': 'ProxyEndpointTargetRole'
    },
    'DatabaseProxy': {
      'proxyTarget': '*',
      'dbProxyName': '*',
      'borrowTimeout': '*',
      'initQuery': '*',
      'maxConnectionsPercent': '*',
      'maxIdleConnectionsPercent': '*',
      'sessionPinningFilters': '*',
      'debugLogging': 'boolean',
      'iamAuth': 'boolean',
      'idleClientTimeout': '*',
      'requireTLS': 'boolean',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'secrets': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'clientPasswordAuthType': 'ClientPasswordAuthType',
      'defaultAuthScheme': 'DefaultAuthScheme',
      'addEndpoint': [
        '*',
        {
          'dbProxyEndpointName': '*',
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'securityGroups': {
            'securityGroupId': '*',
            'allowAllOutbound': 'boolean',
            'canInlineRule': 'boolean',
            'uniqueId': '*',
            'connections': '*'
          },
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*'
          },
          'targetRole': 'ProxyEndpointTargetRole'
        }
      ],
      'asSecretAttachmentTarget': [],
      'grantConnect': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ]
    },
    'ServerlessCluster': {
      'credentials': '*',
      'storageEncryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'engine': {
        'singleUserRotationApplication': '*',
        'supportedLogTypes': '*',
        'combineImportAndExportRoles': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'clusterIdentifier': '*',
      'backupRetention': '*',
      'defaultDatabaseName': '*',
      'deletionProtection': 'boolean',
      'enableDataApi': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'scaling': {
        'minCapacity': 'AuroraCapacityUnit',
        'maxCapacity': 'AuroraCapacityUnit',
        'autoPause': '*',
        'timeoutAction': 'TimeoutAction'
      },
      'removalPolicy': 'RemovalPolicy',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'subnetGroup': '*',
      'copyTagsToSnapshot': 'boolean',
      'addRotationSingleUser': [
        {
          'automaticallyAfter': '*',
          'excludeCharacters': '*',
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          },
          'endpoint': {
            'vpcEndpointId': '*',
            'connections': '*'
          },
          'securityGroup': {
            'securityGroupId': '*',
            'allowAllOutbound': 'boolean',
            'canInlineRule': 'boolean',
            'uniqueId': '*'
          },
          'rotateImmediatelyOnUpdate': 'boolean'
        }
      ],
      'addRotationMultiUser': [
        '*',
        {
          'secret': {
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'secretArn': '*',
            'secretFullArn': '*',
            'secretName': '*',
            'secretValue': '*'
          },
          'automaticallyAfter': '*',
          'excludeCharacters': '*',
          'vpcSubnets': {
            'subnetType': 'SubnetType',
            'availabilityZones': '*',
            'subnetGroupName': '*',
            'subnetName': '*',
            'onePerAz': 'boolean',
            'subnetFilters': '*',
            'subnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              }
            }
          },
          'endpoint': {
            'vpcEndpointId': '*',
            'connections': '*'
          },
          'securityGroup': {
            'securityGroupId': '*',
            'allowAllOutbound': 'boolean',
            'canInlineRule': 'boolean',
            'uniqueId': '*'
          },
          'rotateImmediatelyOnUpdate': 'boolean'
        }
      ]
    },
    'ImportedServerlessCluster': {
      'clusterIdentifier': '*',
      'port': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'clusterEndpointAddress': '*',
      'readerEndpointAddress': '*',
      'secret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      }
    },
    'ServerlessClusterFromSnapshot': {
      'snapshotIdentifier': '*',
      'credentials': '*',
      'engine': {
        'singleUserRotationApplication': '*',
        'supportedLogTypes': '*',
        'combineImportAndExportRoles': 'boolean',
        'engineType': '*',
        'engineVersion': {
          'fullVersion': '*',
          'majorVersion': '*'
        },
        'parameterGroupFamily': '*',
        'engineFamily': '*',
        'defaultUsername': '*'
      },
      'clusterIdentifier': '*',
      'backupRetention': '*',
      'defaultDatabaseName': '*',
      'deletionProtection': 'boolean',
      'enableDataApi': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'scaling': {
        'minCapacity': 'AuroraCapacityUnit',
        'maxCapacity': 'AuroraCapacityUnit',
        'autoPause': '*',
        'timeoutAction': 'TimeoutAction'
      },
      'removalPolicy': 'RemovalPolicy',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'parameterGroup': {
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'subnetGroup': '*',
      'copyTagsToSnapshot': 'boolean'
    },
    'SubnetGroup': {
      'description': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'subnetGroupName': '*',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'removalPolicy': 'RemovalPolicy'
    }
  },
  'aws-cdk-lib.aws-route53': {
    'HealthCheck': {
      'type': 'HealthCheckType',
      'alarmIdentifier': {
        'region': '*',
        'name': '*'
      },
      'childHealthChecks': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enableSNI': 'boolean',
      'failureThreshold': '*',
      'fqdn': '*',
      'healthThreshold': '*',
      'insufficientDataHealthStatus': 'InsufficientDataHealthStatusEnum',
      'inverted': 'boolean',
      'ipAddress': '*',
      'measureLatency': 'boolean',
      'port': '*',
      'regions': '*',
      'requestInterval': '*',
      'resourcePath': '*',
      'routingControl': '*',
      'searchString': '*'
    },
    'HostedZone': {
      'vpcs': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'zoneName': '*',
      'addTrailingDot': 'boolean',
      'comment': '*',
      'queryLogsLogGroupArn': '*',
      'addVpc': [
        {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        }
      ],
      'grantDelegation': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        {
          'delegatedZoneNames': '*'
        }
      ],
      'enableDnssec': [
        {
          'kmsKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'keySigningKeyName': '*'
        }
      ]
    },
    'PublicHostedZone': {
      'caaAmazon': 'boolean',
      'crossAccountZoneDelegationPrincipal': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'crossAccountZoneDelegationRoleName': '*',
      'zoneName': '*',
      'addTrailingDot': 'boolean',
      'comment': '*',
      'queryLogsLogGroupArn': '*',
      'addVpc': [
        {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        }
      ],
      'addDelegation': [
        {
          'hostedZoneId': '*',
          'zoneName': '*',
          'hostedZoneArn': '*',
          'hostedZoneNameServers': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'name': '*'
        },
        {
          'comment': '*',
          'ttl': '*'
        }
      ]
    },
    'PrivateHostedZone': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'zoneName': '*',
      'addTrailingDot': 'boolean',
      'comment': '*',
      'queryLogsLogGroupArn': '*'
    },
    'KeySigningKey': {
      'hostedZone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'keySigningKeyName': '*',
      'status': 'KeySigningKeyStatus'
    },
    'RecordSet': {
      'recordType': 'RecordType',
      'target': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'ARecord': {
      'target': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'AaaaRecord': {
      'target': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'CnameRecord': {
      'domainName': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'TxtRecord': {
      'values': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'SrvRecord': {
      'values': {
        'priority': '*',
        'weight': '*',
        'port': '*',
        'hostName': '*'
      },
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'CaaRecord': {
      'values': {
        'flag': '*',
        'tag': 'CaaTag',
        'value': '*'
      },
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'CaaAmazonRecord': {
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'MxRecord': {
      'values': {
        'priority': '*',
        'hostName': '*'
      },
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'NsRecord': {
      'values': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'DsRecord': {
      'values': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'SvcbRecord': {
      'values': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'HttpsRecord': {
      'values': '*',
      'target': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    },
    'ZoneDelegationRecord': {
      'nameServers': '*',
      'zone': {
        'hostedZoneId': '*',
        'zoneName': '*',
        'hostedZoneArn': '*',
        'hostedZoneNameServers': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'name': '*'
      },
      'geoLocation': '*',
      'recordName': '*',
      'ttl': '*',
      'comment': '*',
      'deleteExisting': 'boolean',
      'weight': '*',
      'region': '*',
      'multiValueAnswer': 'boolean',
      'setIdentifier': '*',
      'healthCheck': {
        'healthCheckId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'cidrRoutingConfig': '*',
      'failover': 'Failover'
    }
  },
  'aws-cdk-lib.aws-s3': {
    'BucketPolicy': {
      'bucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'removalPolicy': 'RemovalPolicy',
      'document': '*',
      'applyRemovalPolicy': [
        'RemovalPolicy'
      ]
    },
    'Bucket': {
      'encryption': 'BucketEncryption',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'blockedEncryptionTypes': '*',
      'enforceSSL': 'boolean',
      'bucketKeyEnabled': 'boolean',
      'bucketName': '*',
      'removalPolicy': 'RemovalPolicy',
      'autoDeleteObjects': 'boolean',
      'versioned': 'boolean',
      'objectLockEnabled': 'boolean',
      'abacStatus': 'boolean',
      'objectLockDefaultRetention': '*',
      'eventBridgeEnabled': 'boolean',
      'lifecycleRules': {
        'id': '*',
        'enabled': 'boolean',
        'abortIncompleteMultipartUploadAfter': '*',
        'expirationDate': '*',
        'noncurrentVersionsToRetain': '*',
        'noncurrentVersionTransitions': {
          'storageClass': '*',
          'noncurrentVersionsToRetain': '*'
        },
        'transitions': '*',
        'prefix': '*',
        'tagFilters': '*',
        'expiredObjectDeleteMarker': 'boolean',
        'objectSizeLessThan': '*',
        'objectSizeGreaterThan': '*'
      },
      'transitionDefaultMinimumObjectSize': 'TransitionDefaultMinimumObjectSize',
      'websiteIndexDocument': '*',
      'websiteErrorDocument': '*',
      'websiteRedirect': {
        'hostName': '*',
        'protocol': 'RedirectProtocol'
      },
      'websiteRoutingRules': {
        'hostName': '*',
        'httpRedirectCode': '*',
        'protocol': 'RedirectProtocol',
        'replaceKey': '*',
        'condition': {
          'httpErrorCodeReturnedEquals': '*',
          'keyPrefixEquals': '*'
        }
      },
      'accessControl': 'BucketAccessControl',
      'publicReadAccess': 'boolean',
      'blockPublicAccess': '*',
      'metrics': {
        'id': '*',
        'prefix': '*',
        'tagFilters': '*'
      },
      'cors': {
        'id': '*',
        'maxAge': '*',
        'allowedHeaders': '*',
        'allowedMethods': 'HttpMethods',
        'allowedOrigins': '*',
        'exposedHeaders': '*'
      },
      'serverAccessLogsBucket': {
        'bucketArn': '*',
        'bucketName': '*',
        'bucketWebsiteUrl': '*',
        'bucketWebsiteDomainName': '*',
        'bucketDomainName': '*',
        'bucketDualStackDomainName': '*',
        'bucketRegionalDomainName': '*',
        'isWebsite': 'boolean',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'policy': '*',
        'replicationRoleArn': '*'
      },
      'serverAccessLogsPrefix': '*',
      'targetObjectKeyFormat': '*',
      'inventories': {
        'destination': {
          'bucket': {
            'bucketArn': '*',
            'bucketName': '*',
            'bucketWebsiteUrl': '*',
            'bucketWebsiteDomainName': '*',
            'bucketDomainName': '*',
            'bucketDualStackDomainName': '*',
            'bucketRegionalDomainName': '*',
            'isWebsite': 'boolean',
            'encryptionKey': {
              'keyArn': '*',
              'keyId': '*',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'policy': '*',
            'replicationRoleArn': '*'
          },
          'prefix': '*',
          'bucketOwner': '*'
        },
        'objectsPrefix': '*',
        'format': 'InventoryFormat',
        'enabled': 'boolean',
        'inventoryId': '*',
        'frequency': 'InventoryFrequency',
        'includeObjectVersions': 'InventoryObjectVersion',
        'optionalFields': '*'
      },
      'objectOwnership': 'ObjectOwnership',
      'transferAcceleration': 'boolean',
      'notificationsHandlerRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'notificationsSkipDestinationValidation': 'boolean',
      'intelligentTieringConfigurations': {
        'name': '*',
        'prefix': '*',
        'tags': {
          'key': '*',
          'value': '*'
        },
        'archiveAccessTierTime': '*'
      },
      'minimumTLSVersion': '*',
      'replicationRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'replicationRules': {
        'destination': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'accessControlTransition': 'boolean',
        'replicationTimeControl': '*',
        'storageClass': '*',
        'sseKmsEncryptedObjects': 'boolean',
        'replicaModifications': 'boolean',
        'priority': '*',
        'deleteMarkerReplication': 'boolean',
        'id': '*',
        'filter': {
          'prefix': '*',
          'tags': {
            'key': '*',
            'value': '*'
          }
        }
      },
      'addLifecycleRule': [
        {
          'id': '*',
          'enabled': 'boolean',
          'abortIncompleteMultipartUploadAfter': '*',
          'expirationDate': '*',
          'noncurrentVersionsToRetain': '*',
          'noncurrentVersionTransitions': {
            'storageClass': '*',
            'noncurrentVersionsToRetain': '*'
          },
          'transitions': '*',
          'prefix': '*',
          'tagFilters': '*',
          'expiredObjectDeleteMarker': 'boolean',
          'objectSizeLessThan': '*',
          'objectSizeGreaterThan': '*'
        }
      ],
      'addMetric': [
        {
          'id': '*',
          'prefix': '*',
          'tagFilters': '*'
        }
      ],
      'addCorsRule': [
        {
          'id': '*',
          'maxAge': '*',
          'allowedHeaders': '*',
          'allowedMethods': 'HttpMethods',
          'allowedOrigins': '*',
          'exposedHeaders': '*'
        }
      ],
      'addInventory': [
        {
          'destination': {
            'bucket': {
              'bucketArn': '*',
              'bucketName': '*',
              'bucketWebsiteUrl': '*',
              'bucketWebsiteDomainName': '*',
              'bucketDomainName': '*',
              'bucketDualStackDomainName': '*',
              'bucketRegionalDomainName': '*',
              'isWebsite': 'boolean',
              'encryptionKey': {
                'keyArn': '*',
                'keyId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'policy': '*',
              'replicationRoleArn': '*'
            },
            'prefix': '*',
            'bucketOwner': '*'
          },
          'objectsPrefix': '*',
          'format': 'InventoryFormat',
          'enabled': 'boolean',
          'inventoryId': '*',
          'frequency': 'InventoryFrequency',
          'includeObjectVersions': 'InventoryObjectVersion',
          'optionalFields': '*'
        }
      ]
    },
    'ReferencedBucket': {
      'account': '*',
      'region': '*',
      'bucketArn': '*',
      'bucketName': '*',
      'bucketDomainName': '*',
      'bucketWebsiteUrl': '*',
      'bucketWebsiteDomainName': '*',
      'bucketRegionalDomainName': '*',
      'bucketDualStackDomainName': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'isWebsite': 'boolean',
      'policy': '*',
      'replicationRoleArn': '*',
      'autoCreatePolicy': 'boolean',
      'disallowPublicAccess': 'boolean',
      'notificationsHandlerRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    }
  },
  'aws-cdk-lib.aws-scheduler': {
    'ScheduleGroup': {},
    'Schedule': {
      'schedule': '*',
      'target': '*',
      'scheduleName': '*',
      'description': '*',
      'scheduleGroup': {
        'scheduleGroupName': '*',
        'scheduleGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'enabled': 'boolean',
      'key': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'timeWindow': '*',
      'start': '*',
      'end': '*'
    }
  },
  'aws-cdk-lib.aws-secretsmanager': {
    'ResourcePolicy': {
      'secret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      }
    },
    'RotationSchedule': {
      'secret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'rotationLambda': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'hostedRotation': '*',
      'automaticallyAfter': '*',
      'rotateImmediatelyOnUpdate': 'boolean'
    },
    'Secret': {
      'description': '*',
      'encryptionKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'generateSecretString': {
        'excludeUppercase': 'boolean',
        'requireEachIncludedType': 'boolean',
        'includeSpace': 'boolean',
        'excludeCharacters': '*',
        'passwordLength': '*',
        'excludePunctuation': 'boolean',
        'excludeLowercase': 'boolean',
        'excludeNumbers': 'boolean',
        'secretStringTemplate': '*',
        'generateStringKey': '*'
      },
      'secretName': '*',
      'secretStringBeta1': '*',
      'secretStringValue': '*',
      'secretObjectValue': '*',
      'removalPolicy': 'RemovalPolicy',
      'replicaRegions': {
        'region': '*',
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'addTargetAttachment': [
        '*',
        {
          'target': '*'
        }
      ],
      'addReplicaRegion': [
        '*',
        '*'
      ]
    },
    'SecretTargetAttachment': {
      'secret': {
        'encryptionKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'secretArn': '*',
        'secretFullArn': '*',
        'secretName': '*',
        'secretValue': '*'
      },
      'target': '*',
      'addToResourcePolicy': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-servicecatalog': {
    'Portfolio': {
      'displayName': '*',
      'providerName': '*',
      'messageLanguage': 'MessageLanguage',
      'description': '*',
      'tagOptions': '*'
    },
    'CloudFormationProduct': {
      'owner': '*',
      'productName': '*',
      'productVersions': {
        'description': '*',
        'validateTemplate': 'boolean',
        'cloudFormationTemplate': '*',
        'productVersionName': '*'
      },
      'messageLanguage': 'MessageLanguage',
      'description': '*',
      'distributor': '*',
      'replaceProductVersionIds': 'boolean',
      'supportDescription': '*',
      'supportEmail': '*',
      'supportUrl': '*',
      'tagOptions': '*'
    },
    'TagOptions': {
      'allowedValuesForTags': '*'
    }
  },
  'aws-cdk-lib.aws-servicediscovery': {
    'AliasTargetInstance': {
      'dnsName': '*',
      'service': {
        'serviceName': '*',
        'namespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'serviceId': '*',
        'serviceArn': '*',
        'dnsRecordType': 'DnsRecordType',
        'routingPolicy': 'RoutingPolicy',
        'discoveryType': 'DiscoveryType'
      },
      'instanceId': '*',
      'customAttributes': '*'
    },
    'CnameInstance': {
      'service': {
        'serviceName': '*',
        'namespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'serviceId': '*',
        'serviceArn': '*',
        'dnsRecordType': 'DnsRecordType',
        'routingPolicy': 'RoutingPolicy',
        'discoveryType': 'DiscoveryType'
      },
      'instanceCname': '*',
      'instanceId': '*',
      'customAttributes': '*'
    },
    'HttpNamespace': {
      'name': '*',
      'description': '*',
      'createService': [
        '*',
        {
          'name': '*',
          'description': '*',
          'healthCheck': {
            'type': 'HealthCheckType',
            'resourcePath': '*',
            'failureThreshold': '*'
          },
          'customHealthCheck': {
            'failureThreshold': '*'
          }
        }
      ]
    },
    'IpInstance': {
      'service': {
        'serviceName': '*',
        'namespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'serviceId': '*',
        'serviceArn': '*',
        'dnsRecordType': 'DnsRecordType',
        'routingPolicy': 'RoutingPolicy',
        'discoveryType': 'DiscoveryType'
      },
      'port': '*',
      'ipv4': '*',
      'ipv6': '*',
      'instanceId': '*',
      'customAttributes': '*'
    },
    'NonIpInstance': {
      'service': {
        'serviceName': '*',
        'namespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'serviceId': '*',
        'serviceArn': '*',
        'dnsRecordType': 'DnsRecordType',
        'routingPolicy': 'RoutingPolicy',
        'discoveryType': 'DiscoveryType'
      },
      'instanceId': '*',
      'customAttributes': '*'
    },
    'PrivateDnsNamespace': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'name': '*',
      'description': '*',
      'createService': [
        '*',
        {
          'discoveryType': 'DiscoveryType',
          'dnsRecordType': 'DnsRecordType',
          'dnsTtl': '*',
          'routingPolicy': 'RoutingPolicy',
          'loadBalancer': 'boolean',
          'name': '*',
          'description': '*',
          'healthCheck': {
            'type': 'HealthCheckType',
            'resourcePath': '*',
            'failureThreshold': '*'
          },
          'customHealthCheck': {
            'failureThreshold': '*'
          }
        }
      ]
    },
    'PublicDnsNamespace': {
      'name': '*',
      'description': '*',
      'createService': [
        '*',
        {
          'discoveryType': 'DiscoveryType',
          'dnsRecordType': 'DnsRecordType',
          'dnsTtl': '*',
          'routingPolicy': 'RoutingPolicy',
          'loadBalancer': 'boolean',
          'name': '*',
          'description': '*',
          'healthCheck': {
            'type': 'HealthCheckType',
            'resourcePath': '*',
            'failureThreshold': '*'
          },
          'customHealthCheck': {
            'failureThreshold': '*'
          }
        }
      ]
    },
    'Service': {
      'namespace': {
        'namespaceName': '*',
        'namespaceId': '*',
        'namespaceArn': '*',
        'type': 'NamespaceType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'discoveryType': 'DiscoveryType',
      'dnsRecordType': 'DnsRecordType',
      'dnsTtl': '*',
      'routingPolicy': 'RoutingPolicy',
      'loadBalancer': 'boolean',
      'name': '*',
      'description': '*',
      'healthCheck': {
        'type': 'HealthCheckType',
        'resourcePath': '*',
        'failureThreshold': '*'
      },
      'customHealthCheck': {
        'failureThreshold': '*'
      },
      'registerLoadBalancer': [
        '*',
        {
          'loadBalancerCanonicalHostedZoneId': '*',
          'loadBalancerDnsName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        '*'
      ],
      'registerNonIpInstance': [
        '*',
        {
          'instanceId': '*',
          'customAttributes': '*'
        }
      ],
      'registerIpInstance': [
        '*',
        {
          'port': '*',
          'ipv4': '*',
          'ipv6': '*',
          'instanceId': '*',
          'customAttributes': '*'
        }
      ],
      'registerCnameInstance': [
        '*',
        {
          'instanceCname': '*',
          'instanceId': '*',
          'customAttributes': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-ses': {
    'ConfigurationSetEventDestination': {
      'configurationSet': '*',
      'configurationSetEventDestinationName': '*',
      'enabled': 'boolean',
      'destination': '*',
      'events': 'EmailSendingEvent'
    },
    'ConfigurationSet': {
      'configurationSetName': '*',
      'dedicatedIpPool': '*',
      'tlsPolicy': 'ConfigurationSetTlsPolicy',
      'reputationMetrics': 'boolean',
      'sendingEnabled': 'boolean',
      'suppressionReasons': 'SuppressionReasons',
      'disableSuppressionList': 'boolean',
      'customTrackingRedirectDomain': '*',
      'customTrackingHttpsPolicy': 'HttpsPolicy',
      'vdmOptions': {
        'engagementMetrics': 'boolean',
        'optimizedSharedDelivery': 'boolean'
      },
      'maxDeliveryDuration': '*',
      'addEventDestination': [
        '*',
        {
          'configurationSetEventDestinationName': '*',
          'enabled': 'boolean',
          'destination': '*',
          'events': 'EmailSendingEvent'
        }
      ]
    },
    'DedicatedIpPool': {
      'dedicatedIpPoolName': '*',
      'scalingMode': 'ScalingMode'
    },
    'EmailIdentity': {
      'identity': '*',
      'configurationSet': '*',
      'dkimSigning': 'boolean',
      'dkimIdentity': '*',
      'feedbackForwarding': 'boolean',
      'mailFromDomain': '*',
      'mailFromBehaviorOnMxFailure': 'MailFromBehaviorOnMxFailure'
    },
    'ReceiptFilter': {
      'receiptFilterName': '*',
      'ip': '*',
      'policy': 'ReceiptFilterPolicy'
    },
    'ReceiptRuleSet': {
      'receiptRuleSetName': '*',
      'rules': {
        'actions': '*',
        'after': '*',
        'enabled': 'boolean',
        'receiptRuleName': '*',
        'recipients': '*',
        'scanEnabled': 'boolean',
        'tlsPolicy': 'TlsPolicy'
      },
      'dropSpam': 'boolean'
    },
    'ReceiptRule': {
      'ruleSet': '*',
      'actions': '*',
      'after': '*',
      'enabled': 'boolean',
      'receiptRuleName': '*',
      'recipients': '*',
      'scanEnabled': 'boolean',
      'tlsPolicy': 'TlsPolicy',
      'addAction': [
        '*'
      ]
    },
    'VdmAttributes': {
      'engagementMetrics': 'boolean',
      'optimizedSharedDelivery': 'boolean'
    }
  },
  'aws-cdk-lib.aws-signer': {
    'SigningProfile': {
      'platform': '*',
      'signatureValidity': '*',
      'signingProfileName': '*'
    }
  },
  'aws-cdk-lib.aws-sns': {
    'TopicPolicy': {
      'topics': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'policyDocument': '*',
      'enforceSSL': 'boolean'
    },
    'Subscription': {
      'topic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'protocol': 'SubscriptionProtocol',
      'endpoint': '*',
      'rawMessageDelivery': 'boolean',
      'filterPolicy': '*',
      'filterPolicyWithMessageBody': '*',
      'region': '*',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'subscriptionRoleArn': '*',
      'deliveryPolicy': {
        'healthyRetryPolicy': {
          'minDelayTarget': '*',
          'numRetries': '*',
          'numNoDelayRetries': '*',
          'numMinDelayRetries': '*',
          'numMaxDelayRetries': '*',
          'backoffFunction': 'BackoffFunction'
        },
        'throttlePolicy': {
          'maxReceivesPerSecond': '*'
        },
        'requestPolicy': {
          'headerContentType': '*'
        }
      }
    },
    'Topic': {
      'displayName': '*',
      'topicName': '*',
      'masterKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'contentBasedDeduplication': 'boolean',
      'fifo': 'boolean',
      'loggingConfigs': {
        'protocol': 'LoggingProtocol',
        'failureFeedbackRole': '*',
        'successFeedbackRole': '*',
        'successFeedbackSampleRate': '*'
      },
      'messageRetentionPeriodInDays': '*',
      'enforceSSL': 'boolean',
      'signatureVersion': '*',
      'tracingConfig': 'TracingConfig',
      'fifoThroughputScope': 'FifoThroughputScope',
      'addLoggingConfig': [
        {
          'protocol': 'LoggingProtocol',
          'failureFeedbackRole': '*',
          'successFeedbackRole': '*',
          'successFeedbackSampleRate': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.aws-sqs': {
    'QueuePolicy': {
      'queues': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      }
    },
    'Queue': {
      'queueName': '*',
      'retentionPeriod': '*',
      'deliveryDelay': '*',
      'maxMessageSizeBytes': '*',
      'receiveMessageWaitTime': '*',
      'visibilityTimeout': '*',
      'deadLetterQueue': {
        'queue': {
          'queueArn': '*',
          'queueUrl': '*',
          'queueName': '*',
          'encryptionMasterKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'fifo': 'boolean',
          'encryptionType': 'QueueEncryption'
        },
        'maxReceiveCount': '*'
      },
      'encryption': 'QueueEncryption',
      'encryptionMasterKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'dataKeyReuse': '*',
      'fifo': 'boolean',
      'contentBasedDeduplication': 'boolean',
      'deduplicationScope': 'DeduplicationScope',
      'fifoThroughputLimit': 'FifoThroughputLimit',
      'removalPolicy': 'RemovalPolicy',
      'enforceSSL': 'boolean',
      'redriveAllowPolicy': {
        'redrivePermission': 'RedrivePermission',
        'sourceQueues': {
          'queueArn': '*',
          'queueUrl': '*',
          'queueName': '*',
          'encryptionMasterKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'fifo': 'boolean',
          'encryptionType': 'QueueEncryption'
        }
      }
    }
  },
  'aws-cdk-lib.aws-ssm': {
    'StringParameter': {
      'stringValue': '*',
      'type': 'ParameterType',
      'dataType': 'ParameterDataType',
      'allowedPattern': '*',
      'description': '*',
      'parameterName': '*',
      'simpleName': 'boolean',
      'tier': 'ParameterTier'
    },
    'StringListParameter': {
      'stringListValue': '*',
      'allowedPattern': '*',
      'description': '*',
      'parameterName': '*',
      'simpleName': 'boolean',
      'tier': 'ParameterTier'
    }
  },
  'aws-cdk-lib.aws-stepfunctions': {
    'Activity': {
      'activityName': '*',
      'encryptionConfiguration': '*',
      'grant': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        '*'
      ],
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricRunTime': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricScheduleTime': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTime': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricScheduled': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTimedOut': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricStarted': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricSucceeded': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricFailed': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHeartbeatTimedOut': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    },
    'StateMachine': {
      'stateMachineName': '*',
      'definition': {
        'id': '*',
        'startState': '*',
        'endStates': '*'
      },
      'definitionBody': '*',
      'definitionSubstitutions': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'timeout': '*',
      'comment': '*',
      'queryLanguage': 'QueryLanguage',
      'stateMachineType': 'StateMachineType',
      'logs': {
        'destination': '*',
        'includeExecutionData': 'boolean',
        'level': 'LogLevel'
      },
      'tracingEnabled': 'boolean',
      'removalPolicy': 'RemovalPolicy',
      'encryptionConfiguration': '*',
      'addToRolePolicy': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.aws-synthetics': {
    'Canary': {
      'artifactsBucketLocation': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'timeToLive': '*',
      'schedule': '*',
      'maxRetries': '*',
      'startAfterCreation': 'boolean',
      'successRetentionPeriod': '*',
      'failureRetentionPeriod': '*',
      'canaryName': '*',
      'runtime': '*',
      'test': '*',
      'activeTracing': 'boolean',
      'environmentVariables': '*',
      'memory': '*',
      'timeout': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'cleanup': 'Cleanup',
      'provisionedResourceCleanup': 'boolean',
      'artifactsBucketLifecycleRules': {
        'id': '*',
        'enabled': 'boolean',
        'abortIncompleteMultipartUploadAfter': '*',
        'expirationDate': '*',
        'noncurrentVersionsToRetain': '*',
        'noncurrentVersionTransitions': {
          'storageClass': '*',
          'noncurrentVersionsToRetain': '*'
        },
        'transitions': '*',
        'prefix': '*',
        'tagFilters': '*',
        'expiredObjectDeleteMarker': 'boolean',
        'objectSizeLessThan': '*',
        'objectSizeGreaterThan': '*'
      },
      'artifactS3EncryptionMode': 'ArtifactsEncryptionMode',
      'artifactS3KmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'dryRunAndUpdate': 'boolean',
      'resourcesToReplicateTags': 'ResourceToReplicateTags',
      'browserConfigs': 'BrowserType',
      'metricDuration': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricSuccessPercent': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricFailed': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    }
  },
  'aws-cdk-lib.core': {
    'CustomResource': {
      'serviceToken': '*',
      'serviceTimeout': '*',
      'properties': '*',
      'resourceType': '*',
      'removalPolicy': 'RemovalPolicy',
      'pascalCaseProperties': 'boolean',
      'getAtt': [
        '*'
      ],
      'getAttString': [
        '*'
      ]
    }
  },
  'aws-cdk-lib.lambda-layer-awscli': {
    'AwsCliLayer': {}
  },
  'aws-cdk-lib.lambda-layer-node-proxy-agent': {
    'NodeProxyAgentLayer': {}
  },
  'aws-cdk-lib.triggers': {
    'TriggerFunction': {
      'runtime': '*',
      'code': '*',
      'handler': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'executeAfter': [
        '*'
      ],
      'executeBefore': [
        '*'
      ],
      'executeOnHandlerChange': 'boolean'
    }
  },
  'aws-bedrock-agentcore-alpha.lib': {
    'Gateway': {
      'gatewayName': '*',
      'description': '*',
      'protocolConfiguration': {
        'protocolType': '*'
      },
      'authorizerConfiguration': {
        'authorizerType': 'GatewayAuthorizerType'
      },
      'exceptionLevel': 'GatewayExceptionLevel',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'interceptorConfigurations': {
        'interceptionPoint': 'InterceptionPoint'
      },
      'addLambdaTarget': [
        '*',
        {
          'gatewayTargetName': '*',
          'description': '*',
          'lambdaFunction': {
            'functionName': '*',
            'functionArn': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'isBoundToVpc': 'boolean',
            'latestVersion': {
              'version': '*',
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'tenancyConfig': '*',
              'architecture': '*',
              'resourceArnsForGrantInvoke': '*',
              'connections': '*'
            },
            'resourceArnsForGrantInvoke': '*'
          },
          'toolSchema': '*',
          'credentialProviderConfigurations': {
            'credentialProviderType': 'CredentialProviderType'
          }
        }
      ],
      'addOpenApiTarget': [
        '*',
        {
          'gatewayTargetName': '*',
          'description': '*',
          'apiSchema': '*',
          'validateOpenApiSchema': 'boolean',
          'credentialProviderConfigurations': {
            'credentialProviderType': 'CredentialProviderType'
          }
        }
      ],
      'addSmithyTarget': [
        '*',
        {
          'gatewayTargetName': '*',
          'description': '*',
          'smithyModel': '*',
          'credentialProviderConfigurations': {
            'credentialProviderType': 'CredentialProviderType'
          }
        }
      ],
      'addMcpServerTarget': [
        '*',
        {
          'gatewayTargetName': '*',
          'description': '*',
          'endpoint': '*',
          'credentialProviderConfigurations': {
            'credentialProviderType': 'CredentialProviderType'
          }
        }
      ],
      'addApiGatewayTarget': [
        '*',
        {
          'gatewayTargetName': '*',
          'description': '*',
          'restApi': {
            'restApiId': '*',
            'restApiName': '*',
            'restApiRootResourceId': '*',
            'latestDeployment': '*',
            'deploymentStage': '*',
            'root': {
              'restApi': '*',
              'resourceId': '*',
              'path': '*',
              'defaultIntegration': '*',
              'defaultMethodOptions': {
                'operationName': '*',
                'authorizationType': 'AuthorizationType',
                'authorizer': {
                  'authorizerId': '*',
                  'authorizationType': 'AuthorizationType'
                },
                'apiKeyRequired': 'boolean',
                'methodResponses': {
                  'statusCode': '*',
                  'responseParameters': '*',
                  'responseModels': '*'
                },
                'requestParameters': '*',
                'requestModels': '*',
                'requestValidator': {
                  'requestValidatorId': '*',
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'authorizationScopes': '*',
                'requestValidatorOptions': {
                  'requestValidatorName': '*',
                  'validateRequestBody': 'boolean',
                  'validateRequestParameters': 'boolean'
                }
              },
              'defaultCorsPreflightOptions': {
                'statusCode': '*',
                'allowOrigins': '*',
                'allowHeaders': '*',
                'allowMethods': '*',
                'allowCredentials': 'boolean',
                'maxAge': '*',
                'disableCache': 'boolean',
                'exposeHeaders': '*'
              }
            }
          },
          'stage': '*',
          'apiGatewayToolConfiguration': {
            'toolFilters': {
              'filterPath': '*',
              'methods': 'ApiGatewayHttpMethod'
            },
            'toolOverrides': {
              'path': '*',
              'method': 'ApiGatewayHttpMethod',
              'name': '*',
              'description': '*'
            }
          },
          'credentialProviderConfigurations': {
            'credentialProviderType': 'CredentialProviderType'
          },
          'metadataConfiguration': {
            'allowedQueryParameters': '*',
            'allowedRequestHeaders': '*',
            'allowedResponseHeaders': '*'
          }
        }
      ],
      'addInterceptor': [
        {
          'interceptionPoint': 'InterceptionPoint'
        }
      ]
    },
    'Memory': {
      'memoryName': '*',
      'expirationDuration': '*',
      'description': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'memoryStrategies': {
        'name': '*',
        'description': '*',
        'strategyType': 'MemoryStrategyType'
      },
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'addMemoryStrategy': [
        {
          'name': '*',
          'description': '*',
          'strategyType': 'MemoryStrategyType'
        }
      ]
    },
    'RuntimeEndpoint': {
      'endpointName': '*',
      'agentRuntimeId': '*',
      'agentRuntimeVersion': '*',
      'description': '*',
      'tags': '*'
    },
    'Runtime': {
      'runtimeName': '*',
      'agentRuntimeArtifact': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'networkConfiguration': '*',
      'description': '*',
      'protocolConfiguration': 'ProtocolType',
      'environmentVariables': '*',
      'authorizerConfiguration': '*',
      'tags': '*',
      'requestHeaderConfiguration': {
        'allowlistedHeaders': '*'
      },
      'lifecycleConfiguration': {
        'idleRuntimeSessionTimeout': '*'
      },
      'addEndpoint': [
        '*',
        {
          'description': '*',
          'version': '*'
        }
      ]
    },
    'BrowserCustom': {
      'browserCustomName': '*',
      'description': '*',
      'networkConfiguration': '*',
      'recordingConfig': {
        'enabled': 'boolean',
        's3Location': {
          'bucketName': '*',
          'objectKey': '*',
          'objectVersion': '*'
        }
      },
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'browserSigning': 'BrowserSigning'
    },
    'CodeInterpreterCustom': {
      'codeInterpreterCustomName': '*',
      'description': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'networkConfiguration': '*',
      'tags': '*'
    }
  },
  'aws-bedrock-alpha.bedrock': {
    'AgentAlias': {
      'agentAliasName': '*',
      'agentVersion': '*',
      'agent': {
        'agentArn': '*',
        'agentId': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*'
        },
        'lastUpdated': '*'
      },
      'description': '*'
    },
    'Agent': {
      'agentName': '*',
      'instruction': '*',
      'foundationModel': {
        'invokableArn': '*'
      },
      'existingRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'shouldPrepareAgent': 'boolean',
      'idleSessionTTL': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'description': '*',
      'actionGroups': '*',
      'guardrail': {
        'guardrailArn': '*',
        'guardrailId': '*',
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'lastUpdated': '*',
        'guardrailVersion': '*'
      },
      'promptOverrideConfiguration': '*',
      'userInputEnabled': 'boolean',
      'codeInterpreterEnabled': 'boolean',
      'forceDelete': 'boolean',
      'memory': '*',
      'agentCollaboration': '*',
      'customOrchestrationExecutor': '*',
      'addGuardrail': [
        {
          'guardrailArn': '*',
          'guardrailId': '*',
          'kmsKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'lastUpdated': '*',
          'guardrailVersion': '*'
        }
      ],
      'addActionGroup': [
        '*'
      ],
      'addActionGroups': [
        '*'
      ]
    },
    'GuardrailVersion': {
      'guardrail': {
        'guardrailArn': '*',
        'guardrailId': '*',
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'lastUpdated': '*',
        'guardrailVersion': '*'
      },
      'description': '*'
    },
    'Guardrail': {
      'guardrailName': '*',
      'description': '*',
      'blockedInputMessaging': '*',
      'blockedOutputsMessaging': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'contentFilters': {
        'type': 'ContentFilterType',
        'inputStrength': 'ContentFilterStrength',
        'outputStrength': 'ContentFilterStrength',
        'inputAction': 'GuardrailAction',
        'inputEnabled': 'boolean',
        'outputAction': 'GuardrailAction',
        'outputEnabled': 'boolean',
        'inputModalities': 'ModalityType',
        'outputModalities': 'ModalityType'
      },
      'contentFiltersTierConfig': 'TierConfig',
      'deniedTopics': '*',
      'topicsTierConfig': 'TierConfig',
      'wordFilters': {
        'text': '*',
        'inputAction': 'GuardrailAction',
        'inputEnabled': 'boolean',
        'outputAction': 'GuardrailAction',
        'outputEnabled': 'boolean'
      },
      'managedWordListFilters': {
        'type': 'ManagedWordFilterType',
        'inputAction': 'GuardrailAction',
        'inputEnabled': 'boolean',
        'outputAction': 'GuardrailAction',
        'outputEnabled': 'boolean'
      },
      'piiFilters': {
        'type': '*',
        'action': 'GuardrailAction',
        'inputAction': 'GuardrailAction',
        'inputEnabled': 'boolean',
        'outputAction': 'GuardrailAction',
        'outputEnabled': 'boolean'
      },
      'regexFilters': {
        'name': '*',
        'description': '*',
        'action': 'GuardrailAction',
        'inputAction': 'GuardrailAction',
        'inputEnabled': 'boolean',
        'outputAction': 'GuardrailAction',
        'outputEnabled': 'boolean',
        'pattern': '*'
      },
      'contextualGroundingFilters': {
        'type': 'ContextualGroundingFilterType',
        'action': 'GuardrailAction',
        'enabled': 'boolean',
        'threshold': '*'
      },
      'crossRegionConfig': {
        'guardrailProfileArn': '*'
      },
      'addContentFilter': [
        {
          'type': 'ContentFilterType',
          'inputStrength': 'ContentFilterStrength',
          'outputStrength': 'ContentFilterStrength',
          'inputAction': 'GuardrailAction',
          'inputEnabled': 'boolean',
          'outputAction': 'GuardrailAction',
          'outputEnabled': 'boolean',
          'inputModalities': 'ModalityType',
          'outputModalities': 'ModalityType'
        }
      ],
      'addPIIFilter': [
        {
          'type': '*',
          'action': 'GuardrailAction',
          'inputAction': 'GuardrailAction',
          'inputEnabled': 'boolean',
          'outputAction': 'GuardrailAction',
          'outputEnabled': 'boolean'
        }
      ],
      'addRegexFilter': [
        {
          'name': '*',
          'description': '*',
          'action': 'GuardrailAction',
          'inputAction': 'GuardrailAction',
          'inputEnabled': 'boolean',
          'outputAction': 'GuardrailAction',
          'outputEnabled': 'boolean',
          'pattern': '*'
        }
      ],
      'addDeniedTopicFilter': [
        '*'
      ],
      'addContextualGroundingFilter': [
        {
          'type': 'ContextualGroundingFilterType',
          'action': 'GuardrailAction',
          'enabled': 'boolean',
          'threshold': '*'
        }
      ],
      'addWordFilter': [
        {
          'text': '*',
          'inputAction': 'GuardrailAction',
          'inputEnabled': 'boolean',
          'outputAction': 'GuardrailAction',
          'outputEnabled': 'boolean'
        }
      ],
      'addWordFilterFromFile': [
        '*',
        'GuardrailAction',
        'GuardrailAction',
        'boolean',
        'boolean'
      ],
      'addManagedWordListFilter': [
        {
          'type': 'ManagedWordFilterType',
          'inputAction': 'GuardrailAction',
          'inputEnabled': 'boolean',
          'outputAction': 'GuardrailAction',
          'outputEnabled': 'boolean'
        }
      ],
      'createVersion': [
        '*'
      ]
    },
    'ApplicationInferenceProfile': {
      'applicationInferenceProfileName': '*',
      'description': '*',
      'modelSource': {
        'invokableArn': '*'
      },
      'tags': '*',
      'grantInvoke': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantProfileUsage': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'Prompt': {
      'promptName': '*',
      'description': '*',
      'kmsKey': {
        'keyArn': '*',
        'keyId': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'defaultVariant': {
        'name': '*',
        'templateType': 'PromptTemplateType',
        'inferenceConfiguration': '*',
        'modelId': '*',
        'templateConfiguration': '*',
        'genAiResource': '*'
      },
      'variants': {
        'name': '*',
        'templateType': 'PromptTemplateType',
        'inferenceConfiguration': '*',
        'modelId': '*',
        'templateConfiguration': '*',
        'genAiResource': '*'
      },
      'tags': '*',
      'createVersion': [
        '*'
      ],
      'addVariant': [
        {
          'name': '*',
          'templateType': 'PromptTemplateType',
          'inferenceConfiguration': '*',
          'modelId': '*',
          'templateConfiguration': '*',
          'genAiResource': '*'
        }
      ]
    }
  },
  'aws-glue-alpha.lib': {
    'PySparkEtlJob': {
      'extraPythonFiles': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'jobRunQueuingEnabled': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'PySparkFlexEtlJob': {
      'notifyDelayAfter': '*',
      'extraPythonFiles': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'PySparkStreamingJob': {
      'extraPythonFiles': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'jobRunQueuingEnabled': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'PythonShellJob': {
      'pythonVersion': 'PythonVersion',
      'maxCapacity': 'MaxCapacity',
      'jobRunQueuingEnabled': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'RayJob': {
      'runtime': 'Runtime',
      'jobRunQueuingEnabled': 'boolean',
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'ScalaSparkEtlJob': {
      'className': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'jobRunQueuingEnabled': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'ScalaSparkFlexEtlJob': {
      'notifyDelayAfter': '*',
      'className': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'ScalaSparkStreamingJob': {
      'className': '*',
      'extraFiles': '*',
      'extraJars': '*',
      'extraJarsFirst': 'boolean',
      'jobRunQueuingEnabled': 'boolean',
      'sparkUI': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'prefix': '*'
      },
      'enableMetrics': 'boolean',
      'enableObservabilityMetrics': 'boolean',
      'script': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'jobName': '*',
      'description': '*',
      'numberOfWorkers': '*',
      'workerType': 'WorkerType',
      'maxConcurrentRuns': '*',
      'defaultArguments': '*',
      'connections': {
        'connectionName': '*',
        'connectionArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'maxRetries': '*',
      'timeout': '*',
      'securityConfiguration': {
        'securityConfigurationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'tags': '*',
      'glueVersion': 'GlueVersion',
      'enableProfilingMetrics': 'boolean',
      'continuousLogging': {
        'enabled': 'boolean',
        'logGroup': {
          'logGroupArn': '*',
          'logGroupName': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'stack': '*',
          'node': '*'
        },
        'logStreamPrefix': '*',
        'quiet': 'boolean',
        'conversionPattern': '*'
      }
    },
    'Workflow': {}
  },
  'aws-apigateway.lib': {
    'CognitoUserPoolsAuthorizer': {
      'authorizerName': '*',
      'cognitoUserPools': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'resultsCacheTtl': '*',
      'identitySource': '*',
      '_attachToApi': [
        {
          'restApiId': '*',
          'restApiName': '*',
          'restApiRootResourceId': '*',
          'latestDeployment': '*',
          'deploymentStage': '*',
          'root': {
            'restApi': '*',
            'resourceId': '*',
            'path': '*',
            'defaultIntegration': '*',
            'defaultMethodOptions': {
              'operationName': '*',
              'authorizationType': 'AuthorizationType',
              'authorizer': {
                'authorizerId': '*',
                'authorizationType': 'AuthorizationType'
              },
              'apiKeyRequired': 'boolean',
              'methodResponses': {
                'statusCode': '*',
                'responseParameters': '*',
                'responseModels': '*'
              },
              'requestParameters': '*',
              'requestModels': '*',
              'requestValidator': {
                'requestValidatorId': '*',
                'stack': '*',
                'node': '*',
                'env': {
                  'account': '*',
                  'region': '*'
                }
              },
              'authorizationScopes': '*',
              'requestValidatorOptions': {
                'requestValidatorName': '*',
                'validateRequestBody': 'boolean',
                'validateRequestParameters': 'boolean'
              }
            },
            'defaultCorsPreflightOptions': {
              'statusCode': '*',
              'allowOrigins': '*',
              'allowHeaders': '*',
              'allowMethods': '*',
              'allowCredentials': 'boolean',
              'maxAge': '*',
              'disableCache': 'boolean',
              'exposeHeaders': '*'
            }
          }
        }
      ]
    },
    'TokenAuthorizer': {
      'validationRegex': '*',
      'identitySource': '*',
      'authorizerName': '*',
      'handler': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'resultsCacheTtl': '*',
      'assumeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'RequestAuthorizer': {
      'identitySources': '*',
      'authorizerName': '*',
      'handler': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'resultsCacheTtl': '*',
      'assumeRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    }
  },
  'aws-apigatewayv2.lib': {
    'ApiMapping': {
      'apiMappingKey': '*',
      'api': '*',
      'domainName': '*',
      'stage': {
        'stageName': '*',
        'url': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'DomainName': {
      'domainName': '*',
      'mtls': {
        'bucket': {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        'key': '*',
        'version': '*'
      },
      'certificate': '*',
      'certificateName': '*',
      'endpointType': 'EndpointType',
      'securityPolicy': 'SecurityPolicy',
      'ownershipCertificate': '*',
      'ipAddressType': 'IpAddressType',
      'addEndpoint': [
        {
          'certificate': '*',
          'certificateName': '*',
          'endpointType': 'EndpointType',
          'securityPolicy': 'SecurityPolicy',
          'ownershipCertificate': '*',
          'ipAddressType': 'IpAddressType'
        }
      ]
    },
    'HttpApi': {
      'addStage': [
        '*',
        {
          'stageName': '*',
          'autoDeploy': 'boolean',
          'domainMapping': {
            'domainName': '*',
            'mappingKey': '*'
          },
          'throttle': {
            'rateLimit': '*',
            'burstLimit': '*'
          },
          'description': '*',
          'detailedMetricsEnabled': 'boolean',
          'accessLogSettings': {
            'destination': '*',
            'format': '*'
          },
          'stageVariables': '*'
        }
      ],
      'addRoutes': [
        {
          'path': '*',
          'methods': 'HttpMethod',
          'authorizer': '*',
          'authorizationScopes': '*',
          'integration': '*'
        }
      ]
    },
    'HttpAuthorizer': {
      'authorizerName': '*',
      'httpApi': {
        'isHttpApi': 'boolean'
      },
      'type': 'HttpAuthorizerType',
      'identitySource': '*',
      'jwtAudience': '*',
      'jwtIssuer': '*',
      'enableSimpleResponses': 'boolean',
      'payloadFormatVersion': 'AuthorizerPayloadVersion',
      'authorizerUri': '*',
      'resultsCacheTtl': '*'
    },
    'HttpIntegration': {
      'httpApi': {
        'isHttpApi': 'boolean'
      },
      'integrationType': 'HttpIntegrationType',
      'integrationSubtype': 'HttpIntegrationSubtype',
      'integrationUri': '*',
      'method': 'HttpMethod',
      'connectionId': '*',
      'connectionType': 'HttpConnectionType',
      'payloadFormatVersion': '*',
      'secureServerName': '*',
      'timeout': '*',
      'parameterMapping': '*',
      'credentials': '*'
    },
    'HttpRoute': {
      'httpApi': {
        'isHttpApi': 'boolean'
      },
      'routeKey': '*',
      'authorizer': '*',
      'authorizationScopes': '*',
      'integration': '*',
      'grantInvoke': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        {
          'httpMethods': 'HttpMethod'
        }
      ]
    },
    'HttpStage': {
      'httpApi': {
        'isHttpApi': 'boolean'
      },
      'stageName': '*',
      'autoDeploy': 'boolean',
      'domainMapping': {
        'domainName': '*',
        'mappingKey': '*'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'description': '*',
      'detailedMetricsEnabled': 'boolean',
      'accessLogSettings': {
        'destination': '*',
        'format': '*'
      },
      'stageVariables': '*'
    },
    'VpcLink': {
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'vpcLinkName': '*',
      'subnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroups': '*',
      'addSubnets': [
        '*'
      ],
      'addSecurityGroups': [
        '*'
      ]
    },
    'ApiKey': {
      'customerId': '*',
      'enabled': 'boolean',
      'generateDistinctId': 'boolean',
      'apiKeyName': '*',
      'value': '*',
      'description': '*'
    },
    'RateLimitedApiKey': {
      'apiStages': {
        'api': {
          'apiId': '*',
          'apiEndpoint': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'isWebsocketApi': 'boolean'
        },
        'stage': {
          'callbackUrl': '*',
          'stageName': '*',
          'url': '*'
        }
      },
      'quota': {
        'limit': '*',
        'offset': '*',
        'period': 'Period'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'customerId': '*',
      'enabled': 'boolean',
      'generateDistinctId': 'boolean',
      'apiKeyName': '*',
      'value': '*',
      'description': '*'
    },
    'WebSocketApi': {
      'addRoute': [
        '*',
        {
          'integration': '*',
          'authorizer': '*',
          'returnResponse': 'boolean'
        }
      ],
      'grantManageConnections': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'arnForExecuteApi': [
        '*',
        '*',
        '*'
      ],
      'arnForExecuteApiV2': [
        '*',
        '*'
      ]
    },
    'WebSocketAuthorizer': {
      'authorizerName': '*',
      'webSocketApi': {
        'apiId': '*',
        'apiEndpoint': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'isWebsocketApi': 'boolean'
      },
      'type': 'WebSocketAuthorizerType',
      'identitySource': '*',
      'authorizerUri': '*'
    },
    'WebSocketIntegration': {
      'webSocketApi': {
        'isWebsocketApi': 'boolean'
      },
      'integrationType': 'WebSocketIntegrationType',
      'integrationUri': '*',
      'integrationMethod': '*',
      'contentHandling': 'ContentHandling',
      'credentialsRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'requestParameters': '*',
      'requestTemplates': '*',
      'templateSelectionExpression': '*',
      'timeout': '*',
      'passthroughBehavior': 'PassthroughBehavior'
    },
    'WebSocketRoute': {
      'webSocketApi': {
        'apiId': '*',
        'apiEndpoint': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'isWebsocketApi': 'boolean'
      },
      'routeKey': '*',
      'apiKeyRequired': 'boolean',
      'integration': '*',
      'authorizer': '*',
      'returnResponse': 'boolean'
    },
    'WebSocketStage': {
      'webSocketApi': {
        'apiId': '*',
        'apiEndpoint': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'isWebsocketApi': 'boolean'
      },
      'stageName': '*',
      'autoDeploy': 'boolean',
      'domainMapping': {
        'domainName': '*',
        'mappingKey': '*'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'description': '*',
      'detailedMetricsEnabled': 'boolean',
      'accessLogSettings': {
        'destination': '*',
        'format': '*'
      },
      'stageVariables': '*',
      'grantManagementApiAccess': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'UsagePlan': {
      'apiStages': {
        'api': {
          'apiId': '*',
          'apiEndpoint': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'isWebsocketApi': 'boolean'
        },
        'stage': {
          'callbackUrl': '*',
          'stageName': '*',
          'url': '*'
        }
      },
      'description': '*',
      'quota': {
        'limit': '*',
        'offset': '*',
        'period': 'Period'
      },
      'throttle': {
        'rateLimit': '*',
        'burstLimit': '*'
      },
      'usagePlanName': '*',
      'addApiStage': [
        {
          'api': {
            'apiId': '*',
            'apiEndpoint': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            },
            'isWebsocketApi': 'boolean'
          },
          'stage': {
            'callbackUrl': '*',
            'stageName': '*',
            'url': '*'
          }
        }
      ]
    }
  },
  'aws-cloudfront.lib': {
    'EdgeFunction': {
      'stackId': '*',
      'runtime': '*',
      'code': '*',
      'handler': '*',
      'description': '*',
      'timeout': '*',
      'environment': '*',
      'functionName': '*',
      'memorySize': '*',
      'ephemeralStorageSize': '*',
      'initialPolicy': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'ipv6AllowedForDualStack': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'allowAllOutbound': 'boolean',
      'allowAllIpv6Outbound': 'boolean',
      'deadLetterQueueEnabled': 'boolean',
      'deadLetterQueue': {
        'queueArn': '*',
        'queueUrl': '*',
        'queueName': '*',
        'encryptionMasterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'fifo': 'boolean',
        'encryptionType': 'QueueEncryption'
      },
      'deadLetterTopic': {
        'topicArn': '*',
        'topicName': '*',
        'masterKey': {
          'keyArn': '*',
          'keyId': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'contentBasedDeduplication': 'boolean',
        'fifo': 'boolean'
      },
      'tracing': 'Tracing',
      'snapStart': '*',
      'profiling': 'boolean',
      'profilingGroup': {
        'profilingGroupName': '*',
        'profilingGroupArn': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'insightsVersion': '*',
      'adotInstrumentation': {
        'layerVersion': '*',
        'execWrapper': 'AdotLambdaExecWrapper'
      },
      'paramsAndSecrets': '*',
      'layers': {
        'layerVersionArn': '*',
        'compatibleRuntimes': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'reservedConcurrentExecutions': '*',
      'events': '*',
      'logRetention': 'RetentionDays',
      'logRemovalPolicy': 'RemovalPolicy',
      'logRetentionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'logRetentionRetryOptions': {
        'maxRetries': '*',
        'base': '*'
      },
      'currentVersionOptions': {
        'codeSha256': '*',
        'description': '*',
        'provisionedConcurrentExecutions': '*',
        'removalPolicy': 'RemovalPolicy',
        'minExecutionEnvironments': '*',
        'maxExecutionEnvironments': '*',
        'onFailure': '*',
        'maxEventAge': '*',
        'retryAttempts': '*'
      },
      'filesystem': '*',
      'allowPublicSubnet': 'boolean',
      'environmentEncryption': '*',
      'codeSigningConfig': '*',
      'architectures': '*',
      'architecture': '*',
      'runtimeManagementMode': '*',
      'tenancyConfig': '*',
      'durableConfig': {
        'executionTimeout': '*'
      },
      'logGroup': '*',
      'logFormat': '*',
      'loggingFormat': 'LoggingFormat',
      'recursiveLoop': 'RecursiveLoop',
      'applicationLogLevel': '*',
      'applicationLogLevelV2': 'ApplicationLogLevel',
      'systemLogLevel': '*',
      'systemLogLevelV2': 'SystemLogLevel',
      'onFailure': '*',
      'onSuccess': '*',
      'maxEventAge': '*',
      'retryAttempts': '*',
      'addAlias': [
        '*',
        {
          'description': '*',
          'additionalVersions': {
            'version': {
              'version': '*',
              'lambda': {
                'functionName': '*',
                'functionArn': '*',
                'role': {
                  'roleArn': '*',
                  'roleName': '*',
                  'assumeRoleAction': '*',
                  'policyFragment': '*',
                  'principalAccount': '*',
                  'grantPrincipal': {
                    'assumeRoleAction': '*',
                    'principalAccount': '*'
                  },
                  'stack': '*',
                  'node': '*',
                  'env': {
                    'account': '*',
                    'region': '*'
                  }
                },
                'isBoundToVpc': 'boolean',
                'tenancyConfig': '*',
                'architecture': '*',
                'resourceArnsForGrantInvoke': '*',
                'connections': '*'
              },
              'edgeArn': '*',
              'functionName': '*',
              'functionArn': '*',
              'isBoundToVpc': 'boolean',
              'resourceArnsForGrantInvoke': '*'
            },
            'weight': '*'
          },
          'provisionedConcurrentExecutions': '*',
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ],
      'addEventSourceMapping': [
        '*',
        {
          'eventSourceArn': '*',
          'batchSize': '*',
          'bisectBatchOnError': 'boolean',
          'onFailure': '*',
          'enabled': 'boolean',
          'startingPosition': 'StartingPosition',
          'startingPositionTimestamp': '*',
          'reportBatchItemFailures': 'boolean',
          'maxBatchingWindow': '*',
          'maxConcurrency': '*',
          'retryAttempts': '*',
          'parallelizationFactor': '*',
          'kafkaTopic': '*',
          'kafkaBootstrapServers': '*',
          'kafkaConsumerGroupId': '*',
          'sourceAccessConfigurations': {
            'type': '*',
            'uri': '*'
          },
          'filters': '*',
          'filterEncryption': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'supportS3OnFailureDestination': 'boolean',
          'provisionedPollerConfig': {
            'minimumPollers': '*',
            'maximumPollers': '*',
            'pollerGroupName': '*'
          },
          'metricsConfig': {
            'metrics': 'MetricType'
          },
          'logLevel': 'EventSourceMappingLogLevel',
          'schemaRegistryConfig': '*'
        }
      ],
      'addPermission': [
        '*',
        {
          'action': '*',
          'eventSourceToken': '*',
          'principal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          },
          'scope': '*',
          'sourceAccount': '*',
          'sourceArn': '*',
          'organizationId': '*',
          'functionUrlAuthType': 'FunctionUrlAuthType',
          'invokedViaFunctionUrl': 'boolean'
        }
      ],
      'addToRolePolicy': [
        '*'
      ],
      'grantInvoke': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantInvokeLatestVersion': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantInvokeVersion': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        {
          'version': '*',
          'lambda': {
            'functionName': '*',
            'functionArn': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'resourceArnsForGrantInvoke': '*'
        }
      ],
      'grantInvokeUrl': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'grantInvokeCompositePrincipal': [
        '*'
      ],
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricDuration': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricErrors': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricInvocations': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricThrottles': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'addEventSource': [
        '*'
      ],
      'configureAsyncInvoke': [
        {
          'onFailure': '*',
          'maxEventAge': '*',
          'retryAttempts': '*'
        }
      ],
      'addFunctionUrl': [
        {
          'authType': 'FunctionUrlAuthType',
          'cors': {
            'allowCredentials': 'boolean',
            'allowedHeaders': '*',
            'allowedMethods': 'HttpMethod',
            'allowedOrigins': '*',
            'exposedHeaders': '*',
            'maxAge': '*'
          },
          'invokeMode': 'InvokeMode'
        }
      ]
    }
  },
  'aws-codedeploy.lib': {
    'EcsApplication': {
      'applicationName': '*'
    },
    'EcsDeploymentConfig': {},
    'EcsDeploymentGroup': {
      'application': '*',
      'deploymentGroupName': '*',
      'deploymentConfig': '*',
      'alarms': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'service': {
        'cluster': {
          'clusterName': '*',
          'clusterArn': '*',
          'vpc': {
            'vpcId': '*',
            'vpcArn': '*',
            'vpcCidrBlock': '*',
            'publicSubnets': {
              'availabilityZone': '*',
              'subnetId': '*',
              'internetConnectivityEstablished': '*',
              'ipv4CidrBlock': '*',
              'routeTable': {
                'routeTableId': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'availabilityZones': '*',
            'vpnGatewayId': '*'
          },
          'connections': '*',
          'hasEc2Capacity': 'boolean',
          'defaultCloudMapNamespace': {
            'namespaceName': '*',
            'namespaceId': '*',
            'namespaceArn': '*',
            'type': 'NamespaceType'
          },
          'autoscalingGroup': {
            'autoScalingGroupName': '*',
            'autoScalingGroupArn': '*',
            'osType': 'OperatingSystemType',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*'
            }
          },
          'executeCommandConfiguration': {
            'kmsKey': {
              'keyArn': '*',
              'keyId': '*'
            },
            'logConfiguration': {
              'cloudWatchEncryptionEnabled': 'boolean',
              'cloudWatchLogGroup': '*',
              's3Bucket': {
                'bucketArn': '*',
                'bucketName': '*',
                'bucketWebsiteUrl': '*',
                'bucketWebsiteDomainName': '*',
                'bucketDomainName': '*',
                'bucketDualStackDomainName': '*',
                'bucketRegionalDomainName': '*',
                'isWebsite': 'boolean',
                'policy': '*',
                'replicationRoleArn': '*'
              },
              's3EncryptionEnabled': 'boolean',
              's3KeyPrefix': '*'
            },
            'logging': 'ExecuteCommandLogging'
          }
        },
        'serviceArn': '*',
        'serviceName': '*'
      },
      'blueGreenDeploymentConfig': {
        'blueTargetGroup': {
          'targetGroupName': '*',
          'targetGroupArn': '*',
          'loadBalancerArns': '*',
          'loadBalancerAttached': '*',
          'node': '*'
        },
        'listener': '*',
        'testListener': '*',
        'deploymentApprovalWaitTime': '*'
      },
      'ignorePollAlarmsFailure': 'boolean',
      'autoRollback': {
        'failedDeployment': 'boolean',
        'stoppedDeployment': 'boolean',
        'deploymentInAlarm': 'boolean'
      },
      'ignoreAlarmConfiguration': 'boolean',
      'addAlarm': [
        '*'
      ]
    },
    'ImportedEcsDeploymentGroup': {
      'application': '*',
      'deploymentGroupName': '*',
      'deploymentConfig': '*'
    },
    'LambdaApplication': {
      'applicationName': '*'
    },
    'CustomLambdaDeploymentConfig': {
      'type': 'CustomLambdaDeploymentConfigType',
      'percentage': '*',
      'interval': '*',
      'deploymentConfigName': '*',
      'bindEnvironment': [
        '*'
      ]
    },
    'LambdaDeploymentConfig': {},
    'LambdaDeploymentGroup': {
      'application': {
        'applicationArn': '*',
        'applicationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'deploymentGroupName': '*',
      'deploymentConfig': {
        'deploymentConfigName': '*',
        'deploymentConfigArn': '*'
      },
      'alarms': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'alias': '*',
      'preHook': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'postHook': {
        'functionName': '*',
        'functionArn': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'isBoundToVpc': 'boolean',
        'latestVersion': {
          'version': '*',
          'edgeArn': '*',
          'functionName': '*',
          'functionArn': '*',
          'isBoundToVpc': 'boolean',
          'tenancyConfig': '*',
          'architecture': '*',
          'resourceArnsForGrantInvoke': '*',
          'connections': '*'
        },
        'resourceArnsForGrantInvoke': '*'
      },
      'ignorePollAlarmsFailure': 'boolean',
      'autoRollback': {
        'failedDeployment': 'boolean',
        'stoppedDeployment': 'boolean',
        'deploymentInAlarm': 'boolean'
      },
      'ignoreAlarmConfiguration': 'boolean',
      'addAlarm': [
        '*'
      ],
      'addPreHook': [
        {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        }
      ],
      'addPostHook': [
        {
          'functionName': '*',
          'functionArn': '*',
          'role': {
            'roleArn': '*',
            'roleName': '*',
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*',
            'grantPrincipal': {
              'assumeRoleAction': '*',
              'principalAccount': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'isBoundToVpc': 'boolean',
          'latestVersion': {
            'version': '*',
            'edgeArn': '*',
            'functionName': '*',
            'functionArn': '*',
            'isBoundToVpc': 'boolean',
            'tenancyConfig': '*',
            'architecture': '*',
            'resourceArnsForGrantInvoke': '*',
            'connections': '*'
          },
          'resourceArnsForGrantInvoke': '*'
        }
      ],
      'grantPutLifecycleEventHookExecutionStatus': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    },
    'ImportedLambdaDeploymentGroup': {
      'application': {
        'applicationArn': '*',
        'applicationName': '*',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'deploymentGroupName': '*',
      'deploymentConfig': {
        'deploymentConfigName': '*',
        'deploymentConfigArn': '*'
      }
    },
    'ImportedDeploymentGroupBase': {
      'application': '*',
      'deploymentGroupName': '*'
    },
    'DeploymentGroupBase': {
      'deploymentGroupName': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'roleConstructId': '*'
    },
    'ServerApplication': {
      'applicationName': '*'
    },
    'ServerDeploymentConfig': {
      'minimumHealthyHosts': '*',
      'zonalConfig': {
        'monitorDuration': '*',
        'minimumHealthyHostsPerZone': '*'
      },
      'deploymentConfigName': '*'
    },
    'ImportedServerDeploymentGroup': {
      'application': '*',
      'deploymentGroupName': '*',
      'deploymentConfig': '*'
    },
    'ServerDeploymentGroup': {
      'application': '*',
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'deploymentGroupName': '*',
      'deploymentConfig': '*',
      'autoScalingGroups': {
        'autoScalingGroupName': '*',
        'autoScalingGroupArn': '*',
        'osType': 'OperatingSystemType',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      },
      'installAgent': 'boolean',
      'loadBalancer': '*',
      'loadBalancers': '*',
      'ec2InstanceTags': '*',
      'onPremiseInstanceTags': '*',
      'alarms': '*',
      'ignorePollAlarmsFailure': 'boolean',
      'autoRollback': {
        'failedDeployment': 'boolean',
        'stoppedDeployment': 'boolean',
        'deploymentInAlarm': 'boolean'
      },
      'ignoreAlarmConfiguration': 'boolean',
      'terminationHook': 'boolean',
      'addAutoScalingGroup': [
        '*'
      ],
      'addAlarm': [
        '*'
      ]
    }
  },
  'aws-codepipeline.lib': {
    'AliasWithShorterGeneratedName': {}
  },
  'aws-cognito.lib': {
    'UserPoolIdentityProviderAmazon': {
      'clientId': '*',
      'clientSecret': '*',
      'scopes': '*',
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    },
    'UserPoolIdentityProviderApple': {
      'clientId': '*',
      'teamId': '*',
      'keyId': '*',
      'privateKey': '*',
      'privateKeyValue': '*',
      'scopes': '*',
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    },
    'UserPoolIdentityProviderFacebook': {
      'clientId': '*',
      'clientSecret': '*',
      'scopes': '*',
      'apiVersion': '*',
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    },
    'UserPoolIdentityProviderGoogle': {
      'clientId': '*',
      'clientSecret': '*',
      'clientSecretValue': '*',
      'scopes': '*',
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    },
    'UserPoolIdentityProviderOidc': {
      'clientId': '*',
      'clientSecret': '*',
      'issuerUrl': '*',
      'name': '*',
      'scopes': '*',
      'identifiers': '*',
      'attributeRequestMethod': 'OidcAttributeRequestMethod',
      'endpoints': {
        'authorization': '*',
        'token': '*',
        'userInfo': '*',
        'jwksUri': '*'
      },
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    },
    'UserPoolIdentityProviderSaml': {
      'name': '*',
      'identifiers': '*',
      'metadata': '*',
      'idpSignout': 'boolean',
      'encryptedResponses': 'boolean',
      'requestSigningAlgorithm': 'SigningAlgorithm',
      'idpInitiated': 'boolean',
      'userPool': {
        'userPoolId': '*',
        'userPoolArn': '*',
        'userPoolProviderName': '*',
        'identityProviders': {
          'providerName': '*',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'attributeMapping': {
        'address': '*',
        'custom': '*'
      }
    }
  },
  'aws-ecs.lib': {
    'ImportedTaskDefinition': {
      'taskDefinitionArn': '*',
      'compatibility': 'Compatibility',
      'networkMode': 'NetworkMode',
      'taskRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      }
    },
    'TaskDefinition': {
      'networkMode': 'NetworkMode',
      'placementConstraints': '*',
      'compatibility': 'Compatibility',
      'cpu': '*',
      'memoryMiB': '*',
      'ipcMode': 'IpcMode',
      'pidMode': 'PidMode',
      'inferenceAccelerators': {
        'deviceName': '*',
        'deviceType': '*'
      },
      'ephemeralStorageGiB': '*',
      'runtimePlatform': {
        'cpuArchitecture': '*',
        'operatingSystemFamily': '*'
      },
      'family': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'taskRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'proxyConfiguration': '*',
      'volumes': {
        'host': {
          'sourcePath': '*'
        },
        'name': '*',
        'configuredAtLaunch': 'boolean',
        'dockerVolumeConfiguration': {
          'autoprovision': 'boolean',
          'driver': '*',
          'driverOpts': '*',
          'labels': '*',
          'scope': 'Scope'
        },
        'efsVolumeConfiguration': {
          'fileSystemId': '*',
          'rootDirectory': '*',
          'transitEncryption': '*',
          'transitEncryptionPort': '*',
          'authorizationConfig': {
            'accessPointId': '*',
            'iam': '*'
          }
        }
      },
      'enableFaultInjection': 'boolean',
      '_validateTarget': [
        {
          'containerName': '*',
          'containerPort': '*',
          'protocol': 'Protocol',
          'alternateTarget': '*'
        }
      ],
      '_portRangeFromPortMapping': [
        {
          'containerPort': '*',
          'containerPortRange': '*',
          'hostPort': '*',
          'protocol': 'Protocol',
          'name': '*',
          'appProtocol': '*'
        }
      ],
      'addToTaskRolePolicy': [
        '*'
      ],
      'addToExecutionRolePolicy': [
        '*'
      ],
      'addContainer': [
        '*',
        {
          'image': '*',
          'containerName': '*',
          'command': '*',
          'credentialSpecs': '*',
          'cpu': '*',
          'disableNetworking': 'boolean',
          'dnsSearchDomains': '*',
          'dnsServers': '*',
          'dockerLabels': '*',
          'dockerSecurityOptions': '*',
          'entryPoint': '*',
          'environment': '*',
          'environmentFiles': '*',
          'secrets': '*',
          'startTimeout': '*',
          'essential': 'boolean',
          'extraHosts': '*',
          'healthCheck': {
            'command': '*',
            'retries': '*'
          },
          'hostname': '*',
          'interactive': 'boolean',
          'memoryLimitMiB': '*',
          'memoryReservationMiB': '*',
          'privileged': 'boolean',
          'readonlyRootFilesystem': 'boolean',
          'user': '*',
          'versionConsistency': 'VersionConsistency',
          'workingDirectory': '*',
          'logging': '*',
          'linuxParameters': '*',
          'gpuCount': '*',
          'portMappings': {
            'containerPort': '*',
            'containerPortRange': '*',
            'hostPort': '*',
            'protocol': 'Protocol',
            'name': '*',
            'appProtocol': '*'
          },
          'inferenceAcceleratorResources': '*',
          'systemControls': {
            'namespace': '*',
            'value': '*'
          },
          'pseudoTerminal': 'boolean',
          'ulimits': {
            'name': 'UlimitName',
            'softLimit': '*',
            'hardLimit': '*'
          },
          'enableRestartPolicy': 'boolean',
          'restartIgnoredExitCodes': '*'
        }
      ],
      'addFirelensLogRouter': [
        '*',
        {
          'firelensConfig': {
            'type': 'FirelensLogRouterType',
            'options': {
              'enableECSLogMetadata': 'boolean',
              'configFileType': 'FirelensConfigFileType',
              'configFileValue': '*'
            }
          },
          'image': '*',
          'containerName': '*',
          'command': '*',
          'credentialSpecs': '*',
          'cpu': '*',
          'disableNetworking': 'boolean',
          'dnsSearchDomains': '*',
          'dnsServers': '*',
          'dockerLabels': '*',
          'dockerSecurityOptions': '*',
          'entryPoint': '*',
          'environment': '*',
          'environmentFiles': '*',
          'secrets': '*',
          'startTimeout': '*',
          'essential': 'boolean',
          'extraHosts': '*',
          'healthCheck': {
            'command': '*',
            'retries': '*'
          },
          'hostname': '*',
          'interactive': 'boolean',
          'memoryLimitMiB': '*',
          'memoryReservationMiB': '*',
          'privileged': 'boolean',
          'readonlyRootFilesystem': 'boolean',
          'user': '*',
          'versionConsistency': 'VersionConsistency',
          'workingDirectory': '*',
          'logging': '*',
          'linuxParameters': '*',
          'gpuCount': '*',
          'portMappings': {
            'containerPort': '*',
            'containerPortRange': '*',
            'hostPort': '*',
            'protocol': 'Protocol',
            'name': '*',
            'appProtocol': '*'
          },
          'inferenceAcceleratorResources': '*',
          'systemControls': {
            'namespace': '*',
            'value': '*'
          },
          'pseudoTerminal': 'boolean',
          'ulimits': {
            'name': 'UlimitName',
            'softLimit': '*',
            'hardLimit': '*'
          },
          'enableRestartPolicy': 'boolean',
          'restartIgnoredExitCodes': '*'
        }
      ],
      '_linkContainer': [
        '*'
      ],
      'addVolume': [
        {
          'host': {
            'sourcePath': '*'
          },
          'name': '*',
          'configuredAtLaunch': 'boolean',
          'dockerVolumeConfiguration': {
            'autoprovision': 'boolean',
            'driver': '*',
            'driverOpts': '*',
            'labels': '*',
            'scope': 'Scope'
          },
          'efsVolumeConfiguration': {
            'fileSystemId': '*',
            'rootDirectory': '*',
            'transitEncryption': '*',
            'transitEncryptionPort': '*',
            'authorizationConfig': {
              'accessPointId': '*',
              'iam': '*'
            }
          }
        }
      ],
      'addPlacementConstraint': [
        '*'
      ],
      'addExtension': [
        '*'
      ],
      'addInferenceAccelerator': [
        {
          'deviceName': '*',
          'deviceType': '*'
        }
      ],
      'grantRun': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ],
      'obtainExecutionRole': [],
      'findPortMappingByName': [
        '*'
      ],
      'findContainer': [
        '*'
      ]
    },
    'Ec2Service': {
      'taskDefinition': '*',
      'assignPublicIp': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'placementConstraints': '*',
      'placementStrategies': '*',
      'daemon': 'boolean',
      'availabilityZoneRebalancing': 'AvailabilityZoneRebalancing',
      'cluster': {
        'clusterName': '*',
        'clusterArn': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'connections': '*',
        'hasEc2Capacity': 'boolean',
        'defaultCloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType'
        },
        'autoscalingGroup': {
          'autoScalingGroupName': '*',
          'autoScalingGroupArn': '*',
          'osType': 'OperatingSystemType',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        'executeCommandConfiguration': {
          'kmsKey': {
            'keyArn': '*',
            'keyId': '*'
          },
          'logConfiguration': {
            'cloudWatchEncryptionEnabled': 'boolean',
            'cloudWatchLogGroup': '*',
            's3Bucket': {
              'bucketArn': '*',
              'bucketName': '*',
              'bucketWebsiteUrl': '*',
              'bucketWebsiteDomainName': '*',
              'bucketDomainName': '*',
              'bucketDualStackDomainName': '*',
              'bucketRegionalDomainName': '*',
              'isWebsite': 'boolean',
              'policy': '*',
              'replicationRoleArn': '*'
            },
            's3EncryptionEnabled': 'boolean',
            's3KeyPrefix': '*'
          },
          'logging': 'ExecuteCommandLogging'
        }
      },
      'desiredCount': '*',
      'serviceName': '*',
      'maxHealthyPercent': '*',
      'minHealthyPercent': '*',
      'healthCheckGracePeriod': '*',
      'cloudMapOptions': {
        'name': '*',
        'cloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'dnsRecordType': 'DnsRecordType',
        'dnsTtl': '*',
        'failureThreshold': '*',
        'container': '*',
        'containerPort': '*'
      },
      'propagateTags': 'PropagatedTagSource',
      'propagateTaskTagsFrom': 'PropagatedTagSource',
      'enableECSManagedTags': 'boolean',
      'deploymentController': {
        'type': 'DeploymentControllerType'
      },
      'circuitBreaker': {
        'enable': 'boolean',
        'rollback': 'boolean'
      },
      'deploymentAlarms': {
        'alarmNames': '*',
        'behavior': 'AlarmBehavior'
      },
      'capacityProviderStrategies': {
        'capacityProvider': '*',
        'base': '*',
        'weight': '*'
      },
      'enableExecuteCommand': 'boolean',
      'serviceConnectConfiguration': {
        'namespace': '*',
        'services': {
          'portMappingName': '*',
          'discoveryName': '*',
          'dnsName': '*',
          'port': '*',
          'ingressPortOverride': '*',
          'idleTimeout': '*',
          'tls': {
            'awsPcaAuthorityArn': '*',
            'kmsKey': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          }
        },
        'logDriver': '*'
      },
      'taskDefinitionRevision': '*',
      'volumeConfigurations': '*',
      'deploymentStrategy': 'DeploymentStrategy',
      'bakeTime': '*',
      'lifecycleHooks': '*',
      'linearConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'canaryConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'addPlacementStrategies': [
        '*'
      ],
      'addPlacementConstraints': [
        '*'
      ],
      'attachToClassicLB': [
        '*'
      ]
    },
    'Ec2TaskDefinition': {
      'networkMode': 'NetworkMode',
      'placementConstraints': '*',
      'ipcMode': 'IpcMode',
      'pidMode': 'PidMode',
      'inferenceAccelerators': {
        'deviceName': '*',
        'deviceType': '*'
      },
      'family': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'taskRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'proxyConfiguration': '*',
      'volumes': {
        'host': {
          'sourcePath': '*'
        },
        'name': '*',
        'configuredAtLaunch': 'boolean',
        'dockerVolumeConfiguration': {
          'autoprovision': 'boolean',
          'driver': '*',
          'driverOpts': '*',
          'labels': '*',
          'scope': 'Scope'
        },
        'efsVolumeConfiguration': {
          'fileSystemId': '*',
          'rootDirectory': '*',
          'transitEncryption': '*',
          'transitEncryptionPort': '*',
          'authorizationConfig': {
            'accessPointId': '*',
            'iam': '*'
          }
        }
      },
      'enableFaultInjection': 'boolean'
    },
    'ExternalService': {
      'taskDefinition': '*',
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'daemon': 'boolean',
      'cluster': {
        'clusterName': '*',
        'clusterArn': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'connections': '*',
        'hasEc2Capacity': 'boolean',
        'defaultCloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType'
        },
        'autoscalingGroup': {
          'autoScalingGroupName': '*',
          'autoScalingGroupArn': '*',
          'osType': 'OperatingSystemType',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        'executeCommandConfiguration': {
          'kmsKey': {
            'keyArn': '*',
            'keyId': '*'
          },
          'logConfiguration': {
            'cloudWatchEncryptionEnabled': 'boolean',
            'cloudWatchLogGroup': '*',
            's3Bucket': {
              'bucketArn': '*',
              'bucketName': '*',
              'bucketWebsiteUrl': '*',
              'bucketWebsiteDomainName': '*',
              'bucketDomainName': '*',
              'bucketDualStackDomainName': '*',
              'bucketRegionalDomainName': '*',
              'isWebsite': 'boolean',
              'policy': '*',
              'replicationRoleArn': '*'
            },
            's3EncryptionEnabled': 'boolean',
            's3KeyPrefix': '*'
          },
          'logging': 'ExecuteCommandLogging'
        }
      },
      'desiredCount': '*',
      'serviceName': '*',
      'maxHealthyPercent': '*',
      'minHealthyPercent': '*',
      'healthCheckGracePeriod': '*',
      'cloudMapOptions': {
        'name': '*',
        'cloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'dnsRecordType': 'DnsRecordType',
        'dnsTtl': '*',
        'failureThreshold': '*',
        'container': '*',
        'containerPort': '*'
      },
      'propagateTags': 'PropagatedTagSource',
      'propagateTaskTagsFrom': 'PropagatedTagSource',
      'enableECSManagedTags': 'boolean',
      'deploymentController': {
        'type': 'DeploymentControllerType'
      },
      'circuitBreaker': {
        'enable': 'boolean',
        'rollback': 'boolean'
      },
      'deploymentAlarms': {
        'alarmNames': '*',
        'behavior': 'AlarmBehavior'
      },
      'capacityProviderStrategies': {
        'capacityProvider': '*',
        'base': '*',
        'weight': '*'
      },
      'enableExecuteCommand': 'boolean',
      'serviceConnectConfiguration': {
        'namespace': '*',
        'services': {
          'portMappingName': '*',
          'discoveryName': '*',
          'dnsName': '*',
          'port': '*',
          'ingressPortOverride': '*',
          'idleTimeout': '*',
          'tls': {
            'awsPcaAuthorityArn': '*',
            'kmsKey': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          }
        },
        'logDriver': '*'
      },
      'taskDefinitionRevision': '*',
      'volumeConfigurations': '*',
      'deploymentStrategy': 'DeploymentStrategy',
      'bakeTime': '*',
      'lifecycleHooks': '*',
      'linearConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'canaryConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'attachToApplicationTargetGroup': [
        {
          'metrics': '*',
          'targetGroupName': '*',
          'targetGroupArn': '*',
          'loadBalancerArns': '*',
          'loadBalancerAttached': '*',
          'node': '*'
        }
      ],
      'loadBalancerTarget': [
        {
          'containerName': '*',
          'containerPort': '*',
          'protocol': 'Protocol',
          'alternateTarget': '*'
        }
      ],
      'registerLoadBalancerTargets': [
        {
          'containerName': '*',
          'containerPort': '*',
          'protocol': 'Protocol',
          'newTargetGroupId': '*',
          'listener': '*'
        }
      ],
      'autoScaleTaskCount': [
        {
          'minCapacity': '*',
          'maxCapacity': '*'
        }
      ],
      'enableCloudMap': [
        {
          'name': '*',
          'cloudMapNamespace': {
            'namespaceName': '*',
            'namespaceId': '*',
            'namespaceArn': '*',
            'type': 'NamespaceType',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'dnsRecordType': 'DnsRecordType',
          'dnsTtl': '*',
          'failureThreshold': '*',
          'container': '*',
          'containerPort': '*'
        }
      ],
      'associateCloudMapService': [
        {
          'service': {
            'serviceName': '*',
            'namespace': {
              'namespaceName': '*',
              'namespaceId': '*',
              'namespaceArn': '*',
              'type': 'NamespaceType',
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            },
            'serviceId': '*',
            'serviceArn': '*',
            'dnsRecordType': 'DnsRecordType',
            'routingPolicy': 'RoutingPolicy',
            'discoveryType': 'DiscoveryType'
          },
          'container': '*',
          'containerPort': '*'
        }
      ]
    },
    'ExternalTaskDefinition': {
      'networkMode': 'NetworkMode',
      'family': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'taskRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'proxyConfiguration': '*',
      'volumes': {
        'host': {
          'sourcePath': '*'
        },
        'name': '*',
        'configuredAtLaunch': 'boolean',
        'dockerVolumeConfiguration': {
          'autoprovision': 'boolean',
          'driver': '*',
          'driverOpts': '*',
          'labels': '*',
          'scope': 'Scope'
        },
        'efsVolumeConfiguration': {
          'fileSystemId': '*',
          'rootDirectory': '*',
          'transitEncryption': '*',
          'transitEncryptionPort': '*',
          'authorizationConfig': {
            'accessPointId': '*',
            'iam': '*'
          }
        }
      },
      'enableFaultInjection': 'boolean',
      'addInferenceAccelerator': [
        {
          'deviceName': '*',
          'deviceType': '*'
        }
      ]
    },
    'FargateService': {
      'taskDefinition': '*',
      'assignPublicIp': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'platformVersion': 'FargatePlatformVersion',
      'availabilityZoneRebalancing': 'AvailabilityZoneRebalancing',
      'cluster': {
        'clusterName': '*',
        'clusterArn': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'connections': '*',
        'hasEc2Capacity': 'boolean',
        'defaultCloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType'
        },
        'autoscalingGroup': {
          'autoScalingGroupName': '*',
          'autoScalingGroupArn': '*',
          'osType': 'OperatingSystemType',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        },
        'executeCommandConfiguration': {
          'kmsKey': {
            'keyArn': '*',
            'keyId': '*'
          },
          'logConfiguration': {
            'cloudWatchEncryptionEnabled': 'boolean',
            'cloudWatchLogGroup': '*',
            's3Bucket': {
              'bucketArn': '*',
              'bucketName': '*',
              'bucketWebsiteUrl': '*',
              'bucketWebsiteDomainName': '*',
              'bucketDomainName': '*',
              'bucketDualStackDomainName': '*',
              'bucketRegionalDomainName': '*',
              'isWebsite': 'boolean',
              'policy': '*',
              'replicationRoleArn': '*'
            },
            's3EncryptionEnabled': 'boolean',
            's3KeyPrefix': '*'
          },
          'logging': 'ExecuteCommandLogging'
        }
      },
      'desiredCount': '*',
      'serviceName': '*',
      'maxHealthyPercent': '*',
      'minHealthyPercent': '*',
      'healthCheckGracePeriod': '*',
      'cloudMapOptions': {
        'name': '*',
        'cloudMapNamespace': {
          'namespaceName': '*',
          'namespaceId': '*',
          'namespaceArn': '*',
          'type': 'NamespaceType',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'dnsRecordType': 'DnsRecordType',
        'dnsTtl': '*',
        'failureThreshold': '*',
        'container': '*',
        'containerPort': '*'
      },
      'propagateTags': 'PropagatedTagSource',
      'propagateTaskTagsFrom': 'PropagatedTagSource',
      'enableECSManagedTags': 'boolean',
      'deploymentController': {
        'type': 'DeploymentControllerType'
      },
      'circuitBreaker': {
        'enable': 'boolean',
        'rollback': 'boolean'
      },
      'deploymentAlarms': {
        'alarmNames': '*',
        'behavior': 'AlarmBehavior'
      },
      'capacityProviderStrategies': {
        'capacityProvider': '*',
        'base': '*',
        'weight': '*'
      },
      'enableExecuteCommand': 'boolean',
      'serviceConnectConfiguration': {
        'namespace': '*',
        'services': {
          'portMappingName': '*',
          'discoveryName': '*',
          'dnsName': '*',
          'port': '*',
          'ingressPortOverride': '*',
          'idleTimeout': '*',
          'tls': {
            'awsPcaAuthorityArn': '*',
            'kmsKey': '*',
            'role': {
              'roleArn': '*',
              'roleName': '*',
              'assumeRoleAction': '*',
              'policyFragment': '*',
              'principalAccount': '*',
              'grantPrincipal': {
                'assumeRoleAction': '*',
                'principalAccount': '*'
              },
              'stack': '*',
              'node': '*',
              'env': {
                'account': '*',
                'region': '*'
              }
            }
          }
        },
        'logDriver': '*'
      },
      'taskDefinitionRevision': '*',
      'volumeConfigurations': '*',
      'deploymentStrategy': 'DeploymentStrategy',
      'bakeTime': '*',
      'lifecycleHooks': '*',
      'linearConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'canaryConfiguration': {
        'stepPercent': '*',
        'stepBakeTime': '*'
      },
      'attachToClassicLB': [
        '*'
      ]
    },
    'FargateTaskDefinition': {
      'cpu': '*',
      'memoryLimitMiB': '*',
      'ephemeralStorageGiB': '*',
      'runtimePlatform': {
        'cpuArchitecture': '*',
        'operatingSystemFamily': '*'
      },
      'pidMode': 'PidMode',
      'family': '*',
      'executionRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'taskRole': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'proxyConfiguration': '*',
      'volumes': {
        'host': {
          'sourcePath': '*'
        },
        'name': '*',
        'configuredAtLaunch': 'boolean',
        'dockerVolumeConfiguration': {
          'autoprovision': 'boolean',
          'driver': '*',
          'driverOpts': '*',
          'labels': '*',
          'scope': 'Scope'
        },
        'efsVolumeConfiguration': {
          'fileSystemId': '*',
          'rootDirectory': '*',
          'transitEncryption': '*',
          'transitEncryptionPort': '*',
          'authorizationConfig': {
            'accessPointId': '*',
            'iam': '*'
          }
        }
      },
      'enableFaultInjection': 'boolean'
    }
  },
  'aws-elasticloadbalancingv2.lib': {
    'ApplicationListener': {
      'loadBalancer': {
        'loadBalancerArn': '*',
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'ipAddressType': 'IpAddressType',
        'listeners': '*',
        'metrics': '*',
        'loadBalancerCanonicalHostedZoneId': '*',
        'loadBalancerDnsName': '*',
        'connections': '*',
        'isApplicationLoadBalancer': 'boolean'
      },
      'protocol': 'ApplicationProtocol',
      'port': '*',
      'certificateArns': '*',
      'certificates': {
        'certificateArn': '*'
      },
      'sslPolicy': 'SslPolicy',
      'defaultTargetGroups': {
        'metrics': '*',
        'targetGroupName': '*',
        'targetGroupArn': '*',
        'loadBalancerArns': '*',
        'loadBalancerAttached': '*',
        'node': '*'
      },
      'defaultAction': '*',
      'open': 'boolean',
      'mutualAuthentication': {
        'mutualAuthenticationMode': 'MutualAuthenticationMode',
        'trustStore': '*',
        'ignoreClientCertificateExpiry': 'boolean',
        'advertiseTrustStoreCaNames': 'boolean'
      },
      'addCertificateArns': [
        '*',
        '*'
      ],
      'addCertificates': [
        '*',
        {
          'certificateArn': '*'
        }
      ],
      'addAction': [
        '*',
        {
          'action': '*',
          'removeSuffix': 'boolean',
          'priority': '*',
          'conditions': '*',
          'hostHeader': '*',
          'pathPattern': '*',
          'pathPatterns': '*'
        }
      ],
      'addTargetGroups': [
        '*',
        {
          'targetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*'
          },
          'priority': '*',
          'conditions': '*',
          'hostHeader': '*',
          'pathPattern': '*',
          'pathPatterns': '*'
        }
      ],
      'addTargets': [
        '*',
        {
          'protocol': 'ApplicationProtocol',
          'protocolVersion': 'ApplicationProtocolVersion',
          'port': '*',
          'slowStart': '*',
          'stickinessCookieName': '*',
          'targets': '*',
          'targetGroupName': '*',
          'healthCheck': {
            'enabled': 'boolean',
            'path': '*',
            'port': '*',
            'protocol': 'Protocol',
            'healthyThresholdCount': '*',
            'unhealthyThresholdCount': '*',
            'healthyGrpcCodes': '*',
            'healthyHttpCodes': '*'
          },
          'loadBalancingAlgorithmType': 'TargetGroupLoadBalancingAlgorithmType',
          'enableAnomalyMitigation': 'boolean',
          'priority': '*',
          'conditions': '*',
          'hostHeader': '*',
          'pathPattern': '*',
          'pathPatterns': '*'
        }
      ],
      'addFixedResponse': [
        '*',
        {
          'priority': '*',
          'conditions': '*',
          'hostHeader': '*',
          'pathPattern': '*',
          'pathPatterns': '*',
          'statusCode': '*',
          'contentType': 'ContentType',
          'messageBody': '*'
        }
      ],
      'addRedirectResponse': [
        '*',
        {
          'priority': '*',
          'conditions': '*',
          'hostHeader': '*',
          'pathPattern': '*',
          'pathPatterns': '*',
          'host': '*',
          'path': '*',
          'port': '*',
          'protocol': '*',
          'query': '*',
          'statusCode': '*'
        }
      ],
      'registerConnectable': [
        {
          'connections': '*'
        },
        '*'
      ]
    },
    'ImportedApplicationListener': {
      'listenerArn': '*',
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'defaultPort': '*',
      'securityGroupAllowsAllOutbound': 'boolean'
    },
    'LookedUpApplicationListener': {
      'listenerArn': '*',
      'listenerPort': '*',
      'securityGroupIds': '*'
    },
    'ApplicationLoadBalancer': {
      'securityGroup': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'ipAddressType': 'IpAddressType',
      'http2Enabled': 'boolean',
      'idleTimeout': '*',
      'dropInvalidHeaderFields': 'boolean',
      'desyncMitigationMode': 'DesyncMitigationMode',
      'clientKeepAlive': '*',
      'preserveHostHeader': 'boolean',
      'xAmznTlsVersionAndCipherSuiteHeaders': 'boolean',
      'preserveXffClientPort': 'boolean',
      'xffHeaderProcessingMode': 'XffHeaderProcessingMode',
      'wafFailOpen': 'boolean',
      'loadBalancerName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'internetFacing': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'deletionProtection': 'boolean',
      'crossZoneEnabled': 'boolean',
      'denyAllIgwTraffic': 'boolean',
      'minimumCapacityUnit': '*',
      'addListener': [
        '*',
        {
          'protocol': 'ApplicationProtocol',
          'port': '*',
          'certificateArns': '*',
          'certificates': {
            'certificateArn': '*'
          },
          'sslPolicy': 'SslPolicy',
          'defaultTargetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*'
          },
          'defaultAction': '*',
          'open': 'boolean',
          'mutualAuthentication': {
            'mutualAuthenticationMode': 'MutualAuthenticationMode',
            'trustStore': '*',
            'ignoreClientCertificateExpiry': 'boolean',
            'advertiseTrustStoreCaNames': 'boolean'
          }
        }
      ],
      'addRedirect': [
        {
          'sourceProtocol': 'ApplicationProtocol',
          'sourcePort': '*',
          'targetProtocol': 'ApplicationProtocol',
          'targetPort': '*',
          'open': 'boolean'
        }
      ],
      'logAccessLogs': [
        {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        '*'
      ],
      'logConnectionLogs': [
        {
          'bucketArn': '*',
          'bucketName': '*',
          'bucketWebsiteUrl': '*',
          'bucketWebsiteDomainName': '*',
          'bucketDomainName': '*',
          'bucketDualStackDomainName': '*',
          'bucketRegionalDomainName': '*',
          'isWebsite': 'boolean',
          'encryptionKey': {
            'keyArn': '*',
            'keyId': '*',
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'policy': '*',
          'replicationRoleArn': '*'
        },
        '*'
      ],
      'addSecurityGroup': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ],
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricActiveConnectionCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricClientTlsNegotiationErrorCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricConsumedLCUs': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHttpFixedResponseCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHttpRedirectCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHttpRedirectUrlLimitExceededCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHttpCodeElb': [
        'HttpCodeElb',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHttpCodeTarget': [
        'HttpCodeTarget',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricIpv6ProcessedBytes': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricIpv6RequestCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricNewConnectionCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricProcessedBytes': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricRejectedConnectionCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricRequestCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricRuleEvaluations': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTargetConnectionErrorCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTargetResponseTime': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTargetTLSNegotiationErrorCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricElbAuthError': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricElbAuthFailure': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricElbAuthLatency': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricElbAuthSuccess': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    },
    'ImportedApplicationLoadBalancer': {
      'loadBalancerArn': '*',
      'securityGroupId': '*',
      'loadBalancerCanonicalHostedZoneId': '*',
      'loadBalancerDnsName': '*',
      'securityGroupAllowsAllOutbound': 'boolean',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'addListener': [
        '*',
        {
          'protocol': 'ApplicationProtocol',
          'port': '*',
          'certificateArns': '*',
          'certificates': {
            'certificateArn': '*'
          },
          'sslPolicy': 'SslPolicy',
          'defaultTargetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*'
          },
          'defaultAction': '*',
          'open': 'boolean',
          'mutualAuthentication': {
            'mutualAuthenticationMode': 'MutualAuthenticationMode',
            'trustStore': '*',
            'ignoreClientCertificateExpiry': 'boolean',
            'advertiseTrustStoreCaNames': 'boolean'
          }
        }
      ]
    },
    'LookedUpApplicationLoadBalancer': {
      'loadBalancerArn': '*',
      'loadBalancerCanonicalHostedZoneId': '*',
      'loadBalancerDnsName': '*',
      'ipAddressType': 'LoadBalancerIpAddressType',
      'securityGroupIds': '*',
      'vpcId': '*',
      'addListener': [
        '*',
        {
          'protocol': 'ApplicationProtocol',
          'port': '*',
          'certificateArns': '*',
          'certificates': {
            'certificateArn': '*'
          },
          'sslPolicy': 'SslPolicy',
          'defaultTargetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*'
          },
          'defaultAction': '*',
          'open': 'boolean',
          'mutualAuthentication': {
            'mutualAuthenticationMode': 'MutualAuthenticationMode',
            'trustStore': '*',
            'ignoreClientCertificateExpiry': 'boolean',
            'advertiseTrustStoreCaNames': 'boolean'
          }
        }
      ]
    },
    'TrustStoreRevocation': {
      'trustStore': '*',
      'revocationContents': {
        'revocationType': 'RevocationType',
        'bucket': '*',
        'key': '*',
        'version': '*'
      }
    },
    'TrustStore': {
      'trustStoreName': '*',
      'bucket': '*',
      'key': '*',
      'version': '*'
    },
    'NetworkListener': {
      'loadBalancer': {
        'vpc': {
          'vpcId': '*',
          'vpcArn': '*',
          'vpcCidrBlock': '*',
          'publicSubnets': {
            'availabilityZone': '*',
            'subnetId': '*',
            'internetConnectivityEstablished': '*',
            'ipv4CidrBlock': '*',
            'routeTable': {
              'routeTableId': '*'
            },
            'stack': '*',
            'node': '*',
            'env': {
              'account': '*',
              'region': '*'
            }
          },
          'availabilityZones': '*',
          'vpnGatewayId': '*'
        },
        'metrics': '*',
        'securityGroups': '*',
        'ipAddressType': 'IpAddressType',
        'enforceSecurityGroupInboundRulesOnPrivateLinkTraffic': '*',
        'loadBalancerCanonicalHostedZoneId': '*',
        'loadBalancerDnsName': '*',
        'loadBalancerArn': '*',
        'connections': '*'
      },
      'port': '*',
      'defaultTargetGroups': {
        'metrics': '*',
        'targetGroupName': '*',
        'targetGroupArn': '*',
        'loadBalancerArns': '*',
        'loadBalancerAttached': '*',
        'node': '*',
        'isNetworkTargetGroup': 'boolean'
      },
      'defaultAction': '*',
      'protocol': 'Protocol',
      'certificates': {
        'certificateArn': '*'
      },
      'sslPolicy': 'SslPolicy',
      'alpnPolicy': 'AlpnPolicy',
      'tcpIdleTimeout': '*',
      'addCertificates': [
        '*',
        {
          'certificateArn': '*'
        }
      ],
      'addTargetGroups': [
        '*',
        {
          'metrics': '*',
          'targetGroupName': '*',
          'targetGroupArn': '*',
          'loadBalancerArns': '*',
          'loadBalancerAttached': '*',
          'node': '*',
          'isNetworkTargetGroup': 'boolean'
        }
      ],
      'addAction': [
        '*',
        {
          'action': '*'
        }
      ],
      'addTargets': [
        '*',
        {
          'port': '*',
          'protocol': 'Protocol',
          'targets': '*',
          'targetGroupName': '*',
          'deregistrationDelay': '*',
          'proxyProtocolV2': 'boolean',
          'preserveClientIp': 'boolean',
          'healthCheck': {
            'enabled': 'boolean',
            'path': '*',
            'port': '*',
            'protocol': 'Protocol',
            'healthyThresholdCount': '*',
            'unhealthyThresholdCount': '*',
            'healthyGrpcCodes': '*',
            'healthyHttpCodes': '*'
          }
        }
      ]
    },
    'NetworkLoadBalancer': {
      'securityGroups': {
        'securityGroupId': '*',
        'allowAllOutbound': 'boolean',
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        },
        'canInlineRule': 'boolean',
        'uniqueId': '*',
        'connections': '*'
      },
      'ipAddressType': 'IpAddressType',
      'clientRoutingPolicy': 'ClientRoutingPolicy',
      'enforceSecurityGroupInboundRulesOnPrivateLinkTraffic': 'boolean',
      'zonalShift': 'boolean',
      'enablePrefixForIpv6SourceNat': 'boolean',
      'subnetMappings': {
        'subnet': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'allocationId': '*',
        'ipv6Address': '*',
        'privateIpv4Address': '*',
        'sourceNatIpv6Prefix': '*'
      },
      'disableSecurityGroups': 'boolean',
      'loadBalancerName': '*',
      'vpc': {
        'vpcId': '*',
        'vpcArn': '*',
        'vpcCidrBlock': '*',
        'publicSubnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'availabilityZones': '*',
        'vpnGatewayId': '*'
      },
      'internetFacing': 'boolean',
      'vpcSubnets': {
        'subnetType': 'SubnetType',
        'availabilityZones': '*',
        'subnetGroupName': '*',
        'subnetName': '*',
        'onePerAz': 'boolean',
        'subnetFilters': '*',
        'subnets': {
          'availabilityZone': '*',
          'subnetId': '*',
          'internetConnectivityEstablished': '*',
          'ipv4CidrBlock': '*',
          'routeTable': {
            'routeTableId': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        }
      },
      'deletionProtection': 'boolean',
      'crossZoneEnabled': 'boolean',
      'denyAllIgwTraffic': 'boolean',
      'minimumCapacityUnit': '*',
      'addListener': [
        '*',
        {
          'port': '*',
          'defaultTargetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*',
            'isNetworkTargetGroup': 'boolean'
          },
          'defaultAction': '*',
          'protocol': 'Protocol',
          'certificates': {
            'certificateArn': '*'
          },
          'sslPolicy': 'SslPolicy',
          'alpnPolicy': 'AlpnPolicy',
          'tcpIdleTimeout': '*'
        }
      ],
      'addSecurityGroup': [
        {
          'securityGroupId': '*',
          'allowAllOutbound': 'boolean',
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          },
          'canInlineRule': 'boolean',
          'uniqueId': '*',
          'connections': '*'
        }
      ],
      'metric': [
        '*',
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricActiveFlowCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricConsumedLCUs': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricHealthyHostCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricUnHealthyHostCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricNewFlowCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricProcessedBytes': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTcpClientResetCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTcpElbResetCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ],
      'metricTcpTargetResetCount': [
        {
          'period': '*',
          'statistic': '*',
          'dimensions': '*',
          'dimensionsMap': '*',
          'unit': 'Unit',
          'label': '*',
          'color': '*',
          'id': '*',
          'visible': 'boolean',
          'account': '*',
          'region': '*',
          'stackAccount': '*',
          'stackRegion': '*'
        }
      ]
    },
    'LookedUpNetworkLoadBalancer': {
      'loadBalancerArn': '*',
      'loadBalancerCanonicalHostedZoneId': '*',
      'loadBalancerDnsName': '*',
      'ipAddressType': 'LoadBalancerIpAddressType',
      'securityGroupIds': '*',
      'vpcId': '*',
      'addListener': [
        '*',
        {
          'port': '*',
          'defaultTargetGroups': {
            'metrics': '*',
            'targetGroupName': '*',
            'targetGroupArn': '*',
            'loadBalancerArns': '*',
            'loadBalancerAttached': '*',
            'node': '*',
            'isNetworkTargetGroup': 'boolean'
          },
          'defaultAction': '*',
          'protocol': 'Protocol',
          'certificates': {
            'certificateArn': '*'
          },
          'sslPolicy': 'SslPolicy',
          'alpnPolicy': 'AlpnPolicy',
          'tcpIdleTimeout': '*'
        }
      ]
    }
  },
  'aws-iam.lib': {
    'ImmutableRole': {
      'roleArn': '*',
      'roleName': '*',
      'grant': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        '*'
      ],
      'grantPassRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grantAssumeRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'attachInlinePolicy': [
        '*'
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'assumeRoleAction': '*',
      'policyFragment': '*',
      'principalAccount': '*',
      'addToPolicy': [
        '*'
      ],
      'addToPrincipalPolicy': [
        '*'
      ],
      'grantPrincipal': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'stack': '*',
      'applyRemovalPolicy': '*',
      'node': '*',
      'with': '*',
      'env': {
        'account': '*',
        'region': '*'
      }
    },
    'ImportedRole': {
      'roleArn': '*',
      'roleName': '*',
      'account': '*',
      'mutable': 'boolean',
      'addGrantsToResources': 'boolean',
      'defaultPolicyName': '*',
      'addToPolicy': [
        '*'
      ],
      'addToPrincipalPolicy': [
        '*'
      ],
      'attachInlinePolicy': [
        '*'
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'grantPassRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grantAssumeRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grant': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        '*'
      ],
      'dedupeString': []
    },
    'PrecreatedRole': {
      'role': {
        'roleArn': '*',
        'roleName': '*',
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*',
        'grantPrincipal': {
          'assumeRoleAction': '*',
          'principalAccount': '*'
        },
        'stack': '*',
        'node': '*',
        'env': {
          'account': '*',
          'region': '*'
        }
      },
      'assumeRolePolicy': '*',
      'missing': 'boolean',
      'rolePath': '*',
      'attachInlinePolicy': [
        '*'
      ],
      'addManagedPolicy': [
        {
          'managedPolicyArn': '*'
        }
      ],
      'addToPolicy': [
        '*'
      ],
      'addToPrincipalPolicy': [
        '*'
      ],
      'grant': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        },
        '*'
      ],
      'grantPassRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ],
      'grantAssumeRole': [
        {
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*'
        }
      ]
    }
  },
  'pipelines.lib': {
    'AssetSingletonRole': {
      'assumedBy': {
        'assumeRoleAction': '*',
        'policyFragment': '*',
        'principalAccount': '*'
      },
      'externalId': '*',
      'externalIds': '*',
      'managedPolicies': {
        'managedPolicyArn': '*'
      },
      'inlinePolicies': '*',
      'path': '*',
      'permissionsBoundary': {
        'managedPolicyArn': '*'
      },
      'roleName': '*',
      'maxSessionDuration': '*',
      'description': '*',
      'addToPrincipalPolicy': [
        '*'
      ],
      'addAssumeRole': [
        '*'
      ]
    }
  },
  'lib.gateway': {
    'GatewayTarget': {
      'gateway': {
        'gatewayArn': '*',
        'gatewayId': '*',
        'name': '*',
        'role': {
          'roleArn': '*',
          'roleName': '*',
          'assumeRoleAction': '*',
          'policyFragment': '*',
          'principalAccount': '*',
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'principalAccount': '*'
          },
          'stack': '*',
          'node': '*',
          'env': {
            'account': '*',
            'region': '*'
          }
        },
        'description': '*',
        'protocolConfiguration': {
          'protocolType': '*'
        },
        'authorizerConfiguration': {
          'authorizerType': 'GatewayAuthorizerType'
        },
        'exceptionLevel': 'GatewayExceptionLevel',
        'kmsKey': {
          'keyArn': '*',
          'keyId': '*'
        },
        'gatewayUrl': '*',
        'status': '*',
        'statusReason': '*',
        'createdAt': '*',
        'updatedAt': '*'
      },
      'targetConfiguration': {
        'targetType': 'McpTargetType'
      },
      'credentialProviderConfigurations': {
        'credentialProviderType': 'CredentialProviderType'
      },
      'gatewayTargetName': '*',
      'description': '*',
      'grantSync': [
        {
          'grantPrincipal': {
            'assumeRoleAction': '*',
            'policyFragment': '*',
            'principalAccount': '*'
          }
        }
      ]
    }
  },
  'lib.services': {
    'ResourcePolicy': {}
  }
};