import React, { FC } from 'react';
import { HasDependences } from '@rediagram/cdk';

declare type StyleOption = {
  color?: 'purple' | 'lipstickA' | 'lipstickB' | 'dell' | 'tiaMaria' | 'monza' | 'governorBay' | 'greenPea' | 'auto';
  style?: 'dashed';
};
declare type AWSDependences = HasDependences<StyleOption>;
declare type AWSContext = {
  serviceName?:
    | boolean
    | {
        type: 'full' | 'medium' | 'short';
      };
};

declare type AnalyticsProps = {
  name: string;
} & AWSDependences;
declare const Analytics: FC<AnalyticsProps>;

declare type AthenaProps = {
  name: string;
} & AWSDependences;
declare const Athena: FC<AthenaProps>;

declare type CloudSearchType = 'Search documents';
declare type CloudSearchProps = {
  type?: CloudSearchType;
  name: string;
} & AWSDependences;
declare const CloudSearch: FC<CloudSearchProps>;

declare type DataPipelineProps = {
  name: string;
} & AWSDependences;
declare const DataPipeline: FC<DataPipelineProps>;

declare type ElasticsearchServiceProps = {
  name: string;
} & AWSDependences;
declare const ElasticsearchService: FC<ElasticsearchServiceProps>;

declare type EMRType =
  | 'HDFS cluster'
  | 'Cluster'
  | 'EMR engine'
  | 'EMR engine mapR M3'
  | 'EMR engine mapR M5'
  | 'EMR engine mapR M7';
declare type EMRProps = {
  type?: EMRType;
  name: string;
} & AWSDependences;
declare const EMR: FC<EMRProps>;

declare type GlueType = 'Crawler' | 'Data catalog';
declare type GlueProps = {
  type?: GlueType;
  name: string;
} & AWSDependences;
declare const Glue: FC<GlueProps>;

declare type KinesisType = 'Video Streams' | 'Data Streams' | 'Data Firehose' | 'Data Analytics';
declare type KinesisProps = {
  name: string;
  type?: KinesisType;
} & AWSDependences;
declare const Kinesis: FC<KinesisProps>;

declare type LakeFormationType = 'Data lake';
declare type LakeFormationProps = {
  type?: LakeFormationType;
  name: string;
} & AWSDependences;
declare const LakeFormation: FC<LakeFormationProps>;

declare type ManagedStreamingForKafkaProps = {
  name: string;
} & HasDependences;
declare const ManagedStreamingForKafka: FC<ManagedStreamingForKafkaProps>;

declare type QuickSightProps = {
  name: string;
} & HasDependences;
declare const QuickSight: FC<QuickSightProps>;

declare type ApplicationIntegrationProps = {
  name: string;
} & HasDependences;
declare const ApplicationIntegration: FC<ApplicationIntegrationProps>;

declare type ConsoleMobileApplicationProps = {
  name: string;
} & AWSDependences;
declare const ConsoleMobileApplication: FC<ConsoleMobileApplicationProps>;

declare type EventBridgeType = 'Event' | 'Default' | 'Custom' | 'SaaS';
declare type EventBridgeProps = {
  type?: EventBridgeType;
  name: string;
} & AWSDependences;
declare const EventBridge: FC<EventBridgeProps>;

declare type ExpressWorkflowsProps = {
  name: string;
} & AWSDependences;
declare const ExpressWorkflows: FC<ExpressWorkflowsProps>;

declare type MQProps = {
  name: string;
} & AWSDependences;
declare const MQ: FC<MQProps>;

declare type SimpleNotificationServiceType = 'Email notification' | 'HTTP notification' | 'Topic';
declare type SimpleNotificationServiceProps = {
  type?: SimpleNotificationServiceType;
  name: string;
} & AWSDependences;
declare const SimpleNotificationService: FC<SimpleNotificationServiceProps>;
declare const SNS: React.FC<SimpleNotificationServiceProps>;

declare type SimpleQueueServiceType = 'Message' | 'Queue';
declare type SimpleQueueServiceProps = {
  type?: SimpleQueueServiceType;
  name: string;
} & AWSDependences;
declare const SimpleQueueService: FC<SimpleQueueServiceProps>;
declare const SQS: React.FC<SimpleQueueServiceProps>;

declare type StepFunctionsProps = {
  name: string;
} & HasDependences;
declare const StepFunctions: FC<StepFunctionsProps>;
declare const SF: React.FC<StepFunctionsProps>;

declare type ArVrProps = {
  name: string;
} & AWSDependences;
declare const ArVr: FC<ArVrProps>;
declare const VrAr: React.FC<ArVrProps>;

declare type SumerianProps = {
  name: string;
} & AWSDependences;
declare const Sumerian: FC<SumerianProps>;

declare type BlockchainProps = {
  name: string;
} & AWSDependences;
declare const Blockchain: FC<BlockchainProps>;

declare type ManagedBlockchainType = 'Blockchain';
declare type ManagedBlockchainProps = {
  type?: ManagedBlockchainType;
  name: string;
} & AWSDependences;
declare const ManagedBlockchain: FC<ManagedBlockchainProps>;

declare type AlexaForBusinessProps = {
  name: string;
} & AWSDependences;
declare const AlexaForBusiness: FC<AlexaForBusinessProps>;

declare type BusinessApplicationsProps = {
  name: string;
} & AWSDependences;
declare const BusinessApplications: FC<BusinessApplicationsProps>;

declare type ChimeProps = {
  name: string;
} & AWSDependences;
declare const Chime: FC<ChimeProps>;

declare type WorkMailProps = {
  name: string;
} & AWSDependences;
declare const WorkMail: FC<WorkMailProps>;

declare type BatchProps = {
  name: string;
} & AWSDependences;
declare const Batch: FC<BatchProps>;

declare type BottlerocketProps = {
  name: string;
} & AWSDependences;
declare const Bottlerocket: FC<BottlerocketProps>;

declare type ComputeProps = {
  name: string;
} & AWSDependences;
declare const Compute: FC<ComputeProps>;

declare type ComputeOptimizerProps = {
  name: string;
} & AWSDependences;
declare const ComputeOptimizer: FC<ComputeOptimizerProps>;

declare type ContainerRegistryType = 'Registry' | 'Image';
declare type ContainerRegistryProps = {
  type?: ContainerRegistryType;
  name: string;
} & AWSDependences;
declare const ContainerRegistry: FC<ContainerRegistryProps>;
declare const ECR: React.FC<ContainerRegistryProps>;

declare type ContainerServiceType = 'Container1' | 'Container2' | 'Container3' | 'Service' | 'Task';
declare type ContainerServiceProps = {
  type?: ContainerServiceType;
  name: string;
} & AWSDependences;
declare const ContainerService: FC<ContainerServiceProps>;
declare const ECS: React.FC<ContainerServiceProps>;

declare type EC2Type =
  | 'AMI'
  | 'Auto Scaling'
  | 'Elastic IP address'
  | 'Rescue'
  | 'Instance'
  | 'A1 instance'
  | 'M4 instance'
  | 'R5a instance'
  | 'z1d instance'
  | 'H1 instance'
  | 'Instances'
  | 'T3 instance'
  | 'C5 instance'
  | 'R4 instance'
  | 'P3 instance'
  | 'I3 instance'
  | 'Spot Instance'
  | 'T2 instance'
  | 'C5n instance'
  | 'X1e instance'
  | 'P2 instance'
  | 'D2 instance'
  | 'Instance with CloudWatch'
  | 'M5 instance'
  | 'C4 instance'
  | 'X1 instance'
  | 'G3 instance'
  | 'DB instance'
  | 'M5a instance'
  | 'R5 instance'
  | 'High memory instance'
  | 'F1 instance';
declare type EC2Props = {
  type?: EC2Type;
  name: string;
} & AWSDependences;
declare const EC2: FC<EC2Props>;

declare type ElasticBeanstalkType = 'Deployment' | 'Application';
declare type ElasticBeanstalkProps = {
  type?: ElasticBeanstalkType;
  name: string;
} & AWSDependences;
declare const ElasticBeanstalk: FC<ElasticBeanstalkProps>;

declare type ElasticKubernetesServiceProps = {
  name: string;
} & AWSDependences;
declare const ElasticKubernetesService: FC<ElasticKubernetesServiceProps>;
declare const EKS: React.FC<ElasticKubernetesServiceProps>;

declare type FargateProps = {
  name: string;
} & AWSDependences;
declare const Fargate: FC<FargateProps>;

declare type ImageBuilderProps = {
  name: string;
} & AWSDependences;
declare const ImageBuilder: FC<ImageBuilderProps>;

declare type LambdaType = 'Lambda Function';
declare type LambdaProps = {
  type?: LambdaType;
  name: string;
} & AWSDependences;
declare const Lambda: FC<LambdaProps>;

declare type LightsailProps = {
  name: string;
} & AWSDependences;
declare const Lightsail: FC<LightsailProps>;

declare type LocalZonesProps = {
  name: string;
} & AWSDependences;
declare const LocalZones: FC<LocalZonesProps>;

declare type OutpostsProps = {
  name: string;
} & AWSDependences;
declare const Outposts: FC<OutpostsProps>;

declare type ParallelClusterProps = {
  name: string;
} & AWSDependences;
declare const ParallelCluster: FC<ParallelClusterProps>;

declare type ServerlessApplicationRepositoryProps = {
  name: string;
} & AWSDependences;
declare const ServerlessApplicationRepository: FC<ServerlessApplicationRepositoryProps>;

declare type ThinkboxType = 'Deadline' | 'Frost' | 'Krakatoa' | 'Sequoia' | 'Stoke' | 'Mesh';
declare type ThinkboxProps = {
  name: string;
  type: ThinkboxType;
} & AWSDependences;
declare const Thinkbox: FC<ThinkboxProps>;

declare type ThinkboxKrakatoaProps = {
  name: string;
} & AWSDependences;
declare const ThinkboxKrakatoa: FC<ThinkboxKrakatoaProps>;

declare type ThinkboxSequoiaProps = {
  name: string;
} & AWSDependences;
declare const ThinkboxSequoia: FC<ThinkboxSequoiaProps>;

declare type ThinkboxStokeProps = {
  name: string;
} & AWSDependences;
declare const ThinkboxStoke: FC<ThinkboxStokeProps>;

declare type ThinkboxXMeshProps = {
  name: string;
} & AWSDependences;
declare const ThinkboxXMesh: FC<ThinkboxXMeshProps>;

declare type VMwareCloudOnAWSProps = {
  name: string;
} & AWSDependences;
declare const VMwareCloudOnAWS: FC<VMwareCloudOnAWSProps>;

declare type WavelengthProps = {
  name: string;
} & AWSDependences;
declare const Wavelength: FC<WavelengthProps>;

declare type BudgetsProps = {
  name: string;
} & AWSDependences;
declare const Budgets: FC<BudgetsProps>;

declare type CostAndUsageReportProps = {
  name: string;
} & AWSDependences;
declare const CostAndUsageReport: FC<CostAndUsageReportProps>;

declare type CostExplorerProps = {
  name: string;
} & AWSDependences;
declare const CostExplorer: FC<CostExplorerProps>;

declare type CostManagementProps = {
  name: string;
} & AWSDependences;
declare const CostManagement: FC<CostManagementProps>;

declare type ReservedInstanceReportingProps = {
  name: string;
} & AWSDependences;
declare const ReservedInstanceReporting: FC<ReservedInstanceReportingProps>;

declare type SavingsPlansProps = {
  name: string;
} & AWSDependences;
declare const SavingsPlans: FC<SavingsPlansProps>;

declare type CustomerEnablementProps = {
  name: string;
} & AWSDependences;
declare const CustomerEnablement: FC<CustomerEnablementProps>;

declare type IQProps = {
  name: string;
} & AWSDependences;
declare const IQ: FC<IQProps>;

declare type ProfessionalServicesProps = {
  name: string;
} & AWSDependences;
declare const ProfessionalServices: FC<ProfessionalServicesProps>;

declare type SupportProps = {
  name: string;
} & AWSDependences;
declare const Support: FC<SupportProps>;

declare type ConnectProps = {
  name: string;
} & AWSDependences;
declare const Connect: FC<ConnectProps>;

declare type CustomerEngagementProps = {
  name: string;
} & AWSDependences;
declare const CustomerEngagement: FC<CustomerEngagementProps>;

declare type SimpleEmailServiceType = 'Email';
declare type SimpleEmailServiceProps = {
  type?: SimpleEmailServiceType;
  name: string;
} & AWSDependences;
declare const SimpleEmailService: FC<SimpleEmailServiceProps>;
declare const SES: React.FC<SimpleEmailServiceProps>;

declare type AuroraProps = {
  name: string;
} & AWSDependences;
declare const Aurora: FC<AuroraProps>;

declare type DatabaseProps = {
  name: string;
} & AWSDependences;
declare const Database: FC<DatabaseProps>;

declare type DatabaseMigrationServiceCategory = 'database' | 'migration-transfer';
declare type DatabaseMigrationServiceType = 'workflow/job';
declare type DatabaseMigrationServiceProps = {
  category?: DatabaseMigrationServiceCategory;
  type?: DatabaseMigrationServiceType;
  name: string;
} & AWSDependences;
declare const DatabaseMigrationService: FC<DatabaseMigrationServiceProps>;

declare type DocumentDBProps = {
  name: string;
} & AWSDependences;
declare const DocumentDB: FC<DocumentDBProps>;

declare type DynamoDBType = 'Attribute' | 'Items' | 'Item' | 'Table' | 'Attributes' | 'Global secondary index' | 'DAX';
declare type DynamoDBProps = {
  type?: DynamoDBType;
  name: string;
} & AWSDependences;
declare const DynamoDB: FC<DynamoDBProps>;

declare type ElastiCacheType = 'Cache node' | 'Redis' | 'Memcached';
declare type ElastiCacheProps = {
  type?: ElastiCacheType;
  name: string;
} & AWSDependences;
declare const ElastiCache: FC<ElastiCacheProps>;

declare type ManagedApacheCassandraServiceProps = {
  name: string;
} & AWSDependences;
declare const ManagedApacheCassandraService: FC<ManagedApacheCassandraServiceProps>;
declare const MCS: React.FC<ManagedApacheCassandraServiceProps>;

declare type NeptuneProps = {
  name: string;
} & AWSDependences;
declare const Neptune: FC<NeptuneProps>;

declare type QuantumLedgerDatabaseCategory = 'blockchain' | 'database';
declare type QuantumLedgerDatabaseProps = {
  category?: QuantumLedgerDatabaseCategory;
  name: string;
} & AWSDependences;
declare const QuantumLedgerDatabase: FC<QuantumLedgerDatabaseProps>;
declare const QLDB: React.FC<QuantumLedgerDatabaseProps>;

declare type RDSType =
  | 'Aurora'
  | 'Aurora alt'
  | 'MariaDB'
  | 'MariaDB alt'
  | 'MySQL'
  | 'MySQL alt'
  | 'on VMware'
  | 'Oracle'
  | 'Oracle alt'
  | 'PIOPS'
  | 'PostgreSQL'
  | 'PostgreSQL alt'
  | 'RDS'
  | 'RDS alt'
  | 'SQL Server'
  | 'SQL Server alt';
declare type RDSProps = {
  type?: RDSType;
  name: string;
} & AWSDependences;
declare const RDS: FC<RDSProps>;

declare type RedshiftCategory = 'analytics' | 'database';
declare type RedshiftType = 'Dense compute node' | 'Dense storage node';
declare type RedshiftProps = {
  category?: RedshiftCategory;
  type?: RedshiftType;
  name: string;
} & AWSDependences;
declare const Redshift: FC<RedshiftProps>;

declare type TimestreamProps = {
  name: string;
} & AWSDependences;
declare const Timestream: FC<TimestreamProps>;

declare type Cloud9Type = 'Instance';
declare type Cloud9Props = {
  type?: Cloud9Type;
  name: string;
} & AWSDependences;
declare const Cloud9: FC<Cloud9Props>;

declare type CloudDevelopmentKitProps = {
  name: string;
} & AWSDependences;
declare const CloudDevelopmentKit: FC<CloudDevelopmentKitProps>;
declare const CDK: React.FC<CloudDevelopmentKitProps>;

declare type CodeBuildProps = {
  name: string;
} & AWSDependences;
declare const CodeBuild: FC<CodeBuildProps>;

declare type CodeCommitProps = {
  name: string;
} & AWSDependences;
declare const CodeCommit: FC<CodeCommitProps>;

declare type CodeDeployProps = {
  name: string;
} & AWSDependences;
declare const CodeDeploy: FC<CodeDeployProps>;

declare type CodePipelineProps = {
  name: string;
} & AWSDependences;
declare const CodePipeline: FC<CodePipelineProps>;

declare type CodeStarProps = {
  name: string;
} & AWSDependences;
declare const CodeStar: FC<CodeStarProps>;

declare type CommandLineInterfaceCategory = 'developer-tools' | 'management-governance';
declare type CommandLineInterfaceProps = {
  category?: CommandLineInterfaceCategory;
  name: string;
} & AWSDependences;
declare const CommandLineInterface: FC<CommandLineInterfaceProps>;
declare const CLI: React.FC<CommandLineInterfaceProps>;

declare type DeveloperToolsProps = {
  name: string;
} & AWSDependences;
declare const DeveloperTools: FC<DeveloperToolsProps>;

declare type ToolsAndSDKsProps = {
  name: string;
} & AWSDependences;
declare const ToolsAndSDKs: FC<ToolsAndSDKsProps>;

declare type XRayProps = {
  name: string;
} & AWSDependences;
declare const XRay: FC<XRayProps>;

declare type AppStream2Props = {
  name: string;
} & AWSDependences;
declare const AppStream2: FC<AppStream2Props>;

declare type EndUserComputingProps = {
  name: string;
} & AWSDependences;
declare const EndUserComputing: FC<EndUserComputingProps>;

declare type WorkDocsProps = {
  name: string;
} & AWSDependences;
declare const WorkDocs: FC<WorkDocsProps>;

declare type WorkLinkProps = {
  name: string;
} & AWSDependences;
declare const WorkLink: FC<WorkLinkProps>;

declare type WorkSpacesProps = {
  name: string;
} & AWSDependences;
declare const WorkSpaces: FC<WorkSpacesProps>;

declare type GameLiftProps = {
  name: string;
} & AWSDependences;
declare const GameLift: FC<GameLiftProps>;

declare type GameTechProps = {
  name: string;
} & AWSDependences;
declare const GameTech: FC<GameTechProps>;

declare const AutoScalingGroup: FC;

declare const AvailabilityZone: FC;

declare type AWSProps = {
  title?: string;
} & AWSContext;
declare const AWS: FC<AWSProps>;
declare const InvizAWS: FC<AWSContext>;

declare type CorporateDataCenterProps = {
  title?: string;
};
declare const CorporateDataCenter: FC<CorporateDataCenterProps>;

declare type EC2InstanceContentsProps = {
  title?: string;
};
declare const EC2InstanceContents: FC<EC2InstanceContentsProps>;

declare type ElasticBeanstalkContainerProps = {
  title?: string;
};
declare const ElasticBeanstalkContainer: FC<ElasticBeanstalkContainerProps>;

declare type GenericGroupProps = {
  type?: 'filled' | 'dashed';
  title: string;
};
declare const GenericGroup: FC<GenericGroupProps>;

declare type Props$1 = {
  name: string;
};
declare const Region: FC<Props$1>;

declare const SecurityGroup: FC;

declare type ServerContentsProps = {
  title?: string;
};
declare const ServerContents: FC<ServerContentsProps>;

declare type SpotFleetProps = {
  title?: string;
};
declare const SpotFleet: FC<SpotFleetProps>;

declare type StepFunctionsWorkflowProps = {
  title?: string;
};
declare const StepFunctionsWorkflow: FC<StepFunctionsWorkflowProps>;

declare type HasIP = {
  ip?: string;
};

declare type Type = 'VPC' | 'Private subnet' | 'Public subnet';
declare type Props = {
  type?: Type;
} & HasIP;
declare const VPC: FC<Props>;

declare type DeviceDefenderType = 'device jobs';
declare type DeviceDefenderProps = {
  type?: DeviceDefenderType;
  name: string;
} & AWSDependences;
declare const DeviceDefender: FC<DeviceDefenderProps>;

declare type FreeRTOSProps = {
  name: string;
} & AWSDependences;
declare const FreeRTOS: FC<FreeRTOSProps>;

declare type InternetOfThingsProps = {
  name: string;
} & AWSDependences;
declare const InternetOfThings: FC<InternetOfThingsProps>;

declare type IoTAnalyticsType = 'Channel' | 'Data set' | 'Pipeline' | 'Notebook' | 'Data store';
declare type IoTAnalyticsProps = {
  type?: IoTAnalyticsType;
  name: string;
} & AWSDependences;
declare const IoTAnalytics: FC<IoTAnalyticsProps>;

declare type IoTButtonProps = {
  name: string;
} & AWSDependences;
declare const IoTButton: FC<IoTButtonProps>;

declare type IoTCoreProps = {
  name: string;
} & AWSDependences;
declare const IoTCore: FC<IoTCoreProps>;

declare type IoTDeviceManagementProps = {
  name: string;
} & AWSDependences;
declare const IoTDeviceManagement: FC<IoTDeviceManagementProps>;

declare type IoTEventsProps = {
  name: string;
} & AWSDependences;
declare const IoTEvents: FC<IoTEventsProps>;

declare type IoTGreengrassType = 'Connector';
declare type IoTGreengrassProps = {
  type?: IoTGreengrassType;
  name: string;
} & AWSDependences;
declare const IoTGreengrass: FC<IoTGreengrassProps>;

declare type IoTResourceType =
  | 'action'
  | 'actuator'
  | 'Alexa enabled device'
  | 'Alexa skill'
  | 'Alexa voice service'
  | 'Certificate manager'
  | 'desired state'
  | 'Device gateway'
  | 'Echo'
  | 'Fire TV'
  | 'Fire TV stick'
  | 'hardware board'
  | 'HTTP/2 protocol'
  | 'HTTP protocol'
  | 'Lambda function'
  | 'MQTT protocol'
  | 'Over-the-air update'
  | 'policy'
  | 'reported-state'
  | 'rule'
  | 'sensor'
  | 'servo'
  | 'shadow'
  | 'simulator'
  | 'topic';
declare type IoTResourceProps = {
  type: IoTResourceType;
  name: string;
} & AWSDependences;
declare const IoTResource: FC<IoTResourceProps>;

declare type IoTSiteWiseProps = {
  name: string;
} & AWSDependences;
declare const IoTSiteWise: FC<IoTSiteWiseProps>;

declare type IoTThingType =
  | 'bank'
  | 'bicycle'
  | 'camera'
  | 'car'
  | 'cart'
  | 'coffee pot'
  | 'door lock'
  | 'factory'
  | 'generic'
  | 'house'
  | 'lightbulb'
  | 'medical emergency'
  | 'police emergency'
  | 'thermostat'
  | 'travel'
  | 'utility'
  | 'windfarm';
declare type IoTThingProps = {
  type: IoTThingType;
  name: string;
} & AWSDependences;
declare const IoTThing: FC<IoTThingProps>;

declare type IoTThingsGraphProps = {
  name: string;
} & AWSDependences;
declare const IoTThingsGraph: FC<IoTThingsGraphProps>;

declare type OneClickProps = {
  name: string;
} & AWSDependences;
declare const OneClick: FC<OneClickProps>;

declare type ApacheMXNetOnAWSProps = {
  name: string;
} & AWSDependences;
declare const ApacheMXNetOnAWS: FC<ApacheMXNetOnAWSProps>;

declare type AugmentedAIProps = {
  name: string;
} & AWSDependences;
declare const AugmentedAI: FC<AugmentedAIProps>;
declare const A2I: React.FC<AugmentedAIProps>;

declare type CodeGuruProps = {
  name: string;
} & AWSDependences;
declare const CodeGuru: FC<CodeGuruProps>;

declare type ComprehendProps = {
  name: string;
} & AWSDependences;
declare const Comprehend: FC<ComprehendProps>;

declare type DeepComposerProps = {
  name: string;
} & AWSDependences;
declare const DeepComposer: FC<DeepComposerProps>;

declare type DeepLearningAMIsProps = {
  name: string;
} & AWSDependences;
declare const DeepLearningAMIs: FC<DeepLearningAMIsProps>;

declare type DeepLearningContainersProps = {
  name: string;
} & AWSDependences;
declare const DeepLearningContainers: FC<DeepLearningContainersProps>;

declare type DeepLensProps = {
  name: string;
} & AWSDependences;
declare const DeepLens: FC<DeepLensProps>;

declare type DeepRacerProps = {
  name: string;
} & AWSDependences;
declare const DeepRacer: FC<DeepRacerProps>;

declare type ElasticInferenceProps = {
  name: string;
} & AWSDependences;
declare const ElasticInference: FC<ElasticInferenceProps>;

declare type ForecastProps = {
  name: string;
} & AWSDependences;
declare const Forecast: FC<ForecastProps>;

declare type FraudDetectorProps = {
  name: string;
} & AWSDependences;
declare const FraudDetector: FC<FraudDetectorProps>;

declare type KendraProps = {
  name: string;
} & AWSDependences;
declare const Kendra: FC<KendraProps>;

declare type LexProps = {
  name: string;
} & AWSDependences;
declare const Lex: FC<LexProps>;

declare type MachineLearningProps = {
  name: string;
} & AWSDependences;
declare const MachineLearning: FC<MachineLearningProps>;

declare type PersonalizeProps = {
  name: string;
} & AWSDependences;
declare const Personalize: FC<PersonalizeProps>;

declare type PollyProps = {
  name: string;
} & AWSDependences;
declare const Polly: FC<PollyProps>;

declare type RekognitionType = 'Image' | 'Video';
declare type RekognitionProps = {
  type?: RekognitionType;
  name: string;
} & AWSDependences;
declare const Rekognition: FC<RekognitionProps>;

declare type SageMakerType = 'Ground Truth' | 'Notebook' | 'Model' | 'Train';
declare type SageMakerProps = {
  type?: SageMakerType;
  name: string;
} & AWSDependences;
declare const SageMaker: FC<SageMakerProps>;

declare type TensorFlowOnAWSProps = {
  name: string;
} & AWSDependences;
declare const TensorFlowOnAWS: FC<TensorFlowOnAWSProps>;

declare type TextractProps = {
  name: string;
} & AWSDependences;
declare const Textract: FC<TextractProps>;

declare type TranscribeProps = {
  name: string;
} & AWSDependences;
declare const Transcribe: FC<TranscribeProps>;

declare type TranslateProps = {
  name: string;
} & AWSDependences;
declare const Translate: FC<TranslateProps>;

declare type AppConfigProps = {
  name: string;
} & AWSDependences;
declare const AppConfig: FC<AppConfigProps>;

declare type AutoScalingProps = {
  name: string;
} & AWSDependences;
declare const AutoScaling: FC<AutoScalingProps>;

declare type AWSConfigProps = {
  name: string;
} & AWSDependences;
declare const AWSConfig: FC<AWSConfigProps>;

declare type CloudFormationType = 'Change set' | 'Stack' | 'Template';
declare type CloudFormationProps = {
  type?: CloudFormationType;
  name: string;
} & AWSDependences;
declare const CloudFormation: FC<CloudFormationProps>;

declare type CloudTrailProps = {
  name: string;
} & AWSDependences;
declare const CloudTrail: FC<CloudTrailProps>;

declare type CloudWatchType = 'Alarm' | 'Rule' | 'Event' | 'Time based event';
declare type CloudWatchProps = {
  type?: CloudWatchType;
  name: string;
} & AWSDependences;
declare const CloudWatch: FC<CloudWatchProps>;

declare type ControlTowerProps = {
  name: string;
} & AWSDependences;
declare const ControlTower: FC<ControlTowerProps>;

declare type LicenseManagerProps = {
  name: string;
} & AWSDependences;
declare const LicenseManager: FC<LicenseManagerProps>;

declare type ManagedServicesCategory = 'customer-enablement' | 'management-governance';
declare type ManagedServicesProps = {
  category?: ManagedServicesCategory;
  name: string;
} & AWSDependences;
declare const ManagedServices: FC<ManagedServicesProps>;

declare type ManagementConsoleProps = {
  name: string;
} & AWSDependences;
declare const ManagementConsole: FC<ManagementConsoleProps>;

declare type ManagementGovernanceProps = {
  name: string;
} & AWSDependences;
declare const ManagementGovernance: FC<ManagementGovernanceProps>;

declare type OpsWorksType =
  | 'Apps'
  | 'Instances'
  | 'Monitoring'
  | 'Permissions'
  | 'Deployments'
  | 'Layers'
  | 'Resources'
  | 'Stack2';
declare type OpsWorksProps = {
  type?: OpsWorksType;
  name: string;
} & AWSDependences;
declare const OpsWorks: FC<OpsWorksProps>;

declare type OrganizationsType = 'Account' | 'Organizational unit';
declare type OrganizationsProps = {
  type?: OrganizationsType;
  name: string;
} & AWSDependences;
declare const Organizations: FC<OrganizationsProps>;

declare type PersonalHealthDashboardProps = {
  name: string;
} & AWSDependences;
declare const PersonalHealthDashboard: FC<PersonalHealthDashboardProps>;

declare type ServiceCatalogProps = {
  name: string;
} & AWSDependences;
declare const ServiceCatalog: FC<ServiceCatalogProps>;

declare type SystemsManagerType =
  | 'Automation'
  | 'Documents'
  | 'Patch manager'
  | 'Parameter store'
  | 'OpsCenter'
  | 'Inventory'
  | 'Maintenance windows'
  | 'State manager'
  | 'Run command';
declare type SystemsManagerProps = {
  type?: SystemsManagerType;
  name: string;
} & AWSDependences;
declare const SystemsManager: FC<SystemsManagerProps>;

declare type TrustedAdvisorType =
  | 'Checklist cost'
  | 'Checklist performance'
  | 'Checklist security'
  | 'Checklist fault tolerant'
  | 'Checklist';
declare type TrustedAdvisorProps = {
  type?: TrustedAdvisorType;
  name: string;
} & AWSDependences;
declare const TrustedAdvisor: FC<TrustedAdvisorProps>;

declare type WellArchitectedToolProps = {
  name: string;
} & AWSDependences;
declare const WellArchitectedTool: FC<WellArchitectedToolProps>;

declare type ElasticTranscoderProps = {
  name: string;
} & AWSDependences;
declare const ElasticTranscoder: FC<ElasticTranscoderProps>;

declare type ElementalConductorProps = {
  name: string;
} & AWSDependences;
declare const ElementalConductor: FC<ElementalConductorProps>;

declare type ElementalDeltaProps = {
  name: string;
} & AWSDependences;
declare const ElementalDelta: FC<ElementalDeltaProps>;

declare type ElementalLiveProps = {
  name: string;
} & AWSDependences;
declare const ElementalLive: FC<ElementalLiveProps>;

declare type ElementalMediaConnectProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaConnect: FC<ElementalMediaConnectProps>;

declare type ElementalMediaConvertProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaConvert: FC<ElementalMediaConvertProps>;

declare type ElementalMediaLiveProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaLive: FC<ElementalMediaLiveProps>;

declare type ElementalMediaPackageProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaPackage: FC<ElementalMediaPackageProps>;

declare type ElementalMediaStoreProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaStore: FC<ElementalMediaStoreProps>;

declare type ElementalMediaTailorProps = {
  name: string;
} & AWSDependences;
declare const ElementalMediaTailor: FC<ElementalMediaTailorProps>;

declare type ElementalServerProps = {
  name: string;
} & AWSDependences;
declare const ElementalServer: FC<ElementalServerProps>;

declare type KinesisVideoStreamsProps = {
  name: string;
} & AWSDependences;
declare const KinesisVideoStreams: FC<KinesisVideoStreamsProps>;

declare type MediaServicesProps = {
  name: string;
} & AWSDependences;
declare const MediaServices: FC<MediaServicesProps>;

declare type ApplicationDiscoveryServiceProps = {
  name: string;
} & AWSDependences;
declare const ApplicationDiscoveryService: FC<ApplicationDiscoveryServiceProps>;

declare type CloudEndureMigrationProps = {
  name: string;
} & AWSDependences;
declare const CloudEndureMigration: FC<CloudEndureMigrationProps>;

declare type DataSyncType = 'Agent';
declare type DataSyncProps = {
  type?: DataSyncType;
  name: string;
} & AWSDependences;
declare const DataSync: FC<DataSyncProps>;

declare type MigrationHubProps = {
  name: string;
} & AWSDependences;
declare const MigrationHub: FC<MigrationHubProps>;

declare type MigrationTransferProps = {
  name: string;
} & AWSDependences;
declare const MigrationTransfer: FC<MigrationTransferProps>;

declare type ServerMigrationServiceProps = {
  name: string;
} & AWSDependences;
declare const ServerMigrationService: FC<ServerMigrationServiceProps>;
declare const SMS: React.FC<ServerMigrationServiceProps>;

declare type TransferFamilyType = 'FTPS' | 'SFTP' | 'FTP';
declare type TransferFamilyProps = {
  type?: TransferFamilyType;
  name: string;
} & AWSDependences;
declare const TransferFamily: FC<TransferFamilyProps>;

declare type AmplifyProps = {
  name: string;
} & AWSDependences;
declare const Amplify: FC<AmplifyProps>;

declare type AppSyncCategory = 'mobile' | 'application-integration';
declare type AppSyncProps = {
  category?: AppSyncCategory;
  name: string;
} & AWSDependences;
declare const AppSync: FC<AppSyncProps>;

declare type DeviceFarmProps = {
  name: string;
} & AWSDependences;
declare const DeviceFarm: FC<DeviceFarmProps>;

declare type MobileProps = {
  name: string;
} & AWSDependences;
declare const Mobile: FC<MobileProps>;

declare type PinpointCategory = 'customer-engagement' | 'mobile';
declare type PinpointProps = {
  category?: PinpointCategory;
  name: string;
} & AWSDependences;
declare const Pinpoint: FC<PinpointProps>;

declare type AmazonVPCType =
  | 'Customer gateway'
  | 'Internet gateway'
  | 'Elastic network interface'
  | 'Elastic network adapter'
  | 'Endpoints'
  | 'Router'
  | 'Traffic mirroring'
  | 'NAT gateway'
  | 'VPN gateway'
  | 'Flow logs'
  | 'Network access control list'
  | 'VPN connection'
  | 'Peering connection';
declare type AmazonVPCProps = {
  type?: AmazonVPCType;
  name: string;
} & AWSDependences;
declare const AmazonVPC: FC<AmazonVPCProps>;

declare type APIGatewayCategory = 'networking-content-delivery' | 'mobile';
declare type APIGatewayType = 'Endpoint';
declare type APIGatewayProps = {
  category?: APIGatewayCategory;
  type?: APIGatewayType;
  name: string;
} & AWSDependences;
declare const APIGateway: FC<APIGatewayProps>;

declare type AppMeshProps = {
  name: string;
} & AWSDependences;
declare const AppMesh: FC<AppMeshProps>;

declare type ClientVPNProps = {
  name: string;
} & AWSDependences;
declare const ClientVPN: FC<ClientVPNProps>;

declare type CloudFrontType = 'Download distribution' | 'Edge location' | 'Streaming distribution';
declare type CloudFrontProps = {
  type?: CloudFrontType;
  name: string;
} & AWSDependences;
declare const CloudFront: FC<CloudFrontProps>;

declare type CloudMapProps = {
  name: string;
} & AWSDependences;
declare const CloudMap: FC<CloudMapProps>;

declare type DirectConnectProps = {
  name: string;
} & AWSDependences;
declare const DirectConnect: FC<DirectConnectProps>;

declare type ElasticLoadBalancingType = 'Application load balancer' | 'Classic load balancer' | 'Network load balancer';
declare type ElasticLoadBalancingProps = {
  type?: ElasticLoadBalancingType;
  name: string;
} & AWSDependences;
declare const ElasticLoadBalancing: FC<ElasticLoadBalancingProps>;

declare type GlobalAcceleratorProps = {
  name: string;
} & AWSDependences;
declare const GlobalAccelerator: FC<GlobalAcceleratorProps>;

declare type NetworkingContentDeliveryProps = {
  name: string;
} & AWSDependences;
declare const NetworkingContentDelivery: FC<NetworkingContentDeliveryProps>;

declare type PrivateLinkProps = {
  name: string;
} & AWSDependences;
declare const PrivateLink: FC<PrivateLinkProps>;

declare type Route53Type = 'Hosted zone' | 'Route table';
declare type Route53Props = {
  type?: Route53Type;
  name: string;
} & AWSDependences;
declare const Route53: FC<Route53Props>;

declare type SiteToSiteVPNProps = {
  name: string;
} & AWSDependences;
declare const SiteToSiteVPN: FC<SiteToSiteVPNProps>;

declare type TransitGatewayProps = {
  name: string;
} & AWSDependences;
declare const TransitGateway: FC<TransitGatewayProps>;

declare type BraketProps = {
  name: string;
} & AWSDependences;
declare const Braket: FC<BraketProps>;

declare type QuantumTechnologiesProps = {
  name: string;
} & AWSDependences;
declare const QuantumTechnologies: FC<QuantumTechnologiesProps>;

declare type RoboMakerType = 'Cloud extensions ROS' | 'Development environment' | 'Fleet management' | 'Simulation';
declare type RoboMakerProps = {
  type?: RoboMakerType;
  name: string;
} & AWSDependences;
declare const RoboMaker: FC<RoboMakerProps>;

declare type RoboticsProps = {
  name: string;
} & AWSDependences;
declare const Robotics: FC<RoboticsProps>;

declare type GroundStationProps = {
  name: string;
} & AWSDependences;
declare const GroundStation: FC<GroundStationProps>;

declare type SatelliteProps = {
  name: string;
} & AWSDependences;
declare const Satellite: FC<SatelliteProps>;

declare type ArtifactProps = {
  name: string;
} & AWSDependences;
declare const Artifact: FC<ArtifactProps>;

declare type CertificateManagerType = 'Certificate authority';
declare type CertificateManagerProps = {
  type?: CertificateManagerType;
  name: string;
} & AWSDependences;
declare const CertificateManager: FC<CertificateManagerProps>;

declare type CloudDirectoryProps = {
  name: string;
} & AWSDependences;
declare const CloudDirectory: FC<CloudDirectoryProps>;

declare type CloudHSMProps = {
  name: string;
} & AWSDependences;
declare const CloudHSM: FC<CloudHSMProps>;

declare type CognitoProps = {
  name: string;
} & AWSDependences;
declare const Cognito: FC<CognitoProps>;

declare type DetectiveProps = {
  name: string;
} & AWSDependences;
declare const Detective: FC<DetectiveProps>;

declare type DirectoryServiceType = 'Simple AD' | 'AD Connector' | 'AWS Managed Microsoft AD';
declare type DirectoryServiceProps = {
  type?: DirectoryServiceType;
  name: string;
} & AWSDependences;
declare const DirectoryService: FC<DirectoryServiceProps>;

declare type FirewallManagerProps = {
  name: string;
} & AWSDependences;
declare const FirewallManager: FC<FirewallManagerProps>;

declare type GuardDutyProps = {
  name: string;
} & AWSDependences;
declare const GuardDuty: FC<GuardDutyProps>;

declare type IAMType =
  | 'Add-on'
  | 'AWS STS Alternate'
  | 'AWS STS'
  | 'Data Encryption Key'
  | 'Encrypted Data'
  | 'Long term Security Credential'
  | 'MFA Token'
  | 'Permissions'
  | 'Role'
  | 'Temporary Security Credential';
declare type IAMProps = {
  type?: IAMType;
  name: string;
} & AWSDependences;
declare const IAM: FC<IAMProps>;

declare type InspectorType = 'Agent';
declare type InspectorProps = {
  type?: InspectorType;
  name: string;
} & AWSDependences;
declare const Inspector: FC<InspectorProps>;

declare type KeyManagementServiceProps = {
  name: string;
} & AWSDependences;
declare const KeyManagementService: FC<KeyManagementServiceProps>;
declare const KMS: React.FC<KeyManagementServiceProps>;

declare type MacieProps = {
  name: string;
} & AWSDependences;
declare const Macie: FC<MacieProps>;

declare type SecretsManagerProps = {
  name: string;
} & AWSDependences;
declare const SecretsManager: FC<SecretsManagerProps>;

declare type SecurityHubType = 'Finding';
declare type SecurityHubProps = {
  type?: SecurityHubType;
  name: string;
} & AWSDependences;
declare const SecurityHub: FC<SecurityHubProps>;

declare type SecurityIdentityComplianceProps = {
  name: string;
} & AWSDependences;
declare const SecurityIdentityCompliance: FC<SecurityIdentityComplianceProps>;

declare type ShieldType = 'Shield Advanced';
declare type ShieldProps = {
  type?: ShieldType;
  name: string;
} & AWSDependences;
declare const Shield: FC<ShieldProps>;

declare type SingleSignOnProps = {
  name: string;
} & AWSDependences;
declare const SingleSignOn: FC<SingleSignOnProps>;

declare type WAFType = 'Filtering rule';
declare type WAFProps = {
  type?: WAFType;
  name: string;
} & AWSDependences;
declare const WAF: FC<WAFProps>;

declare type BackupProps = {
  name: string;
} & AWSDependences;
declare const Backup: FC<BackupProps>;

declare type CloudEndureDisasterRecoveryProps = {
  name: string;
} & AWSDependences;
declare const CloudEndureDisasterRecovery: FC<CloudEndureDisasterRecoveryProps>;

declare type ElasticBlockStoreType = 'Snapshot' | 'Volume' | 'Multiple volumes';
declare type ElasticBlockStoreProps = {
  type?: ElasticBlockStoreType;
  name: string;
} & AWSDependences;
declare const ElasticBlockStore: FC<ElasticBlockStoreProps>;
declare const EBS: React.FC<ElasticBlockStoreProps>;

declare type ElasticFileSystemType = 'File system';
declare type ElasticFileSystemProps = {
  type?: ElasticFileSystemType;
  name: string;
} & AWSDependences;
declare const ElasticFileSystem: FC<ElasticFileSystemProps>;

declare type FSxProps = {
  name: string;
} & AWSDependences;
declare const FSx: FC<FSxProps>;

declare type FSxForLustreProps = {
  name: string;
} & AWSDependences;
declare const FSxForLustre: FC<FSxForLustreProps>;

declare type FSxForWindowsFileServerProps = {
  name: string;
} & AWSDependences;
declare const FSxForWindowsFileServer: FC<FSxForWindowsFileServerProps>;

declare type InfrequentAccessStorageClassProps = {
  name: string;
} & AWSDependences;
declare const InfrequentAccessStorageClass: FC<InfrequentAccessStorageClassProps>;

declare type S3Type = 'Bucket with Objects' | 'Bucket' | 'Object';
declare type S3Props = {
  type?: S3Type;
  name: string;
} & AWSDependences;
declare const S3: FC<S3Props>;

declare type S3GlacierType = 'Vault' | 'Archive';
declare type S3GlacierProps = {
  type?: S3GlacierType;
  name: string;
} & AWSDependences;
declare const S3Glacier: FC<S3GlacierProps>;

declare type SnowballType = 'Snowball import-export';
declare type SnowballProps = {
  type?: SnowballType;
  name: string;
} & AWSDependences;
declare const Snowball: FC<SnowballProps>;

declare type SnowballEdgeProps = {
  name: string;
} & AWSDependences;
declare const SnowballEdge: FC<SnowballEdgeProps>;

declare type SnowmobileProps = {
  name: string;
} & AWSDependences;
declare const Snowmobile: FC<SnowmobileProps>;

declare type StandardStorageClassProps = {
  name: string;
} & AWSDependences;
declare const StandardStorageClass: FC<StandardStorageClassProps>;

declare type StorageProps = {
  name: string;
} & AWSDependences;
declare const Storage: FC<StorageProps>;

declare type StorageGatewayType =
  | 'Non-cached volume'
  | 'Cached volume'
  | 'Volume gateway'
  | 'Virtual tape library'
  | 'Tape gateway'
  | 'File gateway';
declare type StorageGatewayProps = {
  type?: StorageGatewayType;
  name: string;
} & AWSDependences;
declare const StorageGateway: FC<StorageGatewayProps>;

export {
  A2I,
  APIGateway,
  APIGatewayCategory,
  APIGatewayProps,
  APIGatewayType,
  AWS,
  AWSConfig,
  AWSConfigProps,
  AWSProps,
  AlexaForBusiness,
  AlexaForBusinessProps,
  AmazonVPC,
  AmazonVPCProps,
  AmazonVPCType,
  Amplify,
  AmplifyProps,
  Analytics,
  AnalyticsProps,
  ApacheMXNetOnAWS,
  ApacheMXNetOnAWSProps,
  AppConfig,
  AppConfigProps,
  AppMesh,
  AppMeshProps,
  AppStream2,
  AppStream2Props,
  AppSync,
  AppSyncProps,
  ApplicationDiscoveryService,
  ApplicationDiscoveryServiceProps,
  ApplicationIntegration,
  ApplicationIntegrationProps,
  ArVr,
  ArVrProps,
  Artifact,
  ArtifactProps,
  Athena,
  AthenaProps,
  AugmentedAI,
  AugmentedAIProps,
  Aurora,
  AuroraProps,
  AutoScaling,
  AutoScalingGroup,
  AutoScalingProps,
  AvailabilityZone,
  Backup,
  BackupProps,
  Batch,
  BatchProps,
  Blockchain,
  BlockchainProps,
  Bottlerocket,
  BottlerocketProps,
  Braket,
  BraketProps,
  Budgets,
  BudgetsProps,
  BusinessApplications,
  BusinessApplicationsProps,
  CDK,
  CLI,
  CertificateManager,
  CertificateManagerProps,
  CertificateManagerType,
  Chime,
  ChimeProps,
  ClientVPN,
  ClientVPNProps,
  Cloud9,
  Cloud9Props,
  Cloud9Type,
  CloudDevelopmentKit,
  CloudDevelopmentKitProps,
  CloudDirectory,
  CloudDirectoryProps,
  CloudEndureDisasterRecovery,
  CloudEndureDisasterRecoveryProps,
  CloudEndureMigration,
  CloudEndureMigrationProps,
  CloudFormation,
  CloudFormationProps,
  CloudFormationType,
  CloudFront,
  CloudFrontProps,
  CloudFrontType,
  CloudHSM,
  CloudHSMProps,
  CloudMap,
  CloudMapProps,
  CloudSearch,
  CloudSearchProps,
  CloudSearchType,
  CloudTrail,
  CloudTrailProps,
  CloudWatch,
  CloudWatchProps,
  CloudWatchType,
  CodeBuild,
  CodeBuildProps,
  CodeCommit,
  CodeCommitProps,
  CodeDeploy,
  CodeDeployProps,
  CodeGuru,
  CodeGuruProps,
  CodePipeline,
  CodePipelineProps,
  CodeStar,
  CodeStarProps,
  Cognito,
  CognitoProps,
  CommandLineInterface,
  CommandLineInterfaceCategory,
  CommandLineInterfaceProps,
  Comprehend,
  ComprehendProps,
  Compute,
  ComputeOptimizer,
  ComputeOptimizerProps,
  ComputeProps,
  Connect,
  ConnectProps,
  ConsoleMobileApplication,
  ConsoleMobileApplicationProps,
  ContainerRegistry,
  ContainerRegistryProps,
  ContainerRegistryType,
  ContainerService,
  ContainerServiceProps,
  ContainerServiceType,
  ControlTower,
  ControlTowerProps,
  CorporateDataCenter,
  CorporateDataCenterProps,
  CostAndUsageReport,
  CostAndUsageReportProps,
  CostExplorer,
  CostExplorerProps,
  CostManagement,
  CostManagementProps,
  CustomerEnablement,
  CustomerEnablementProps,
  CustomerEngagement,
  CustomerEngagementProps,
  DataPipeline,
  DataPipelineProps,
  DataSync,
  DataSyncProps,
  DataSyncType,
  Database,
  DatabaseMigrationService,
  DatabaseMigrationServiceProps,
  DatabaseMigrationServiceType,
  DatabaseProps,
  DeepComposer,
  DeepComposerProps,
  DeepLearningAMIs,
  DeepLearningAMIsProps,
  DeepLearningContainers,
  DeepLearningContainersProps,
  DeepLens,
  DeepLensProps,
  DeepRacer,
  DeepRacerProps,
  Detective,
  DetectiveProps,
  DeveloperTools,
  DeveloperToolsProps,
  DeviceDefender,
  DeviceDefenderProps,
  DeviceDefenderType,
  DeviceFarm,
  DeviceFarmProps,
  DirectConnect,
  DirectConnectProps,
  DirectoryService,
  DirectoryServiceProps,
  DirectoryServiceType,
  DocumentDB,
  DocumentDBProps,
  DynamoDB,
  DynamoDBProps,
  DynamoDBType,
  EBS,
  EC2,
  EC2InstanceContents,
  EC2InstanceContentsProps,
  EC2Props,
  EC2Type,
  ECR,
  ECS,
  EKS,
  EMR,
  EMRProps,
  EMRType,
  ElastiCache,
  ElastiCacheProps,
  ElastiCacheType,
  ElasticBeanstalk,
  ElasticBeanstalkContainer,
  ElasticBeanstalkContainerProps,
  ElasticBeanstalkProps,
  ElasticBeanstalkType,
  ElasticBlockStore,
  ElasticBlockStoreProps,
  ElasticBlockStoreType,
  ElasticFileSystem,
  ElasticFileSystemProps,
  ElasticFileSystemType,
  ElasticInference,
  ElasticInferenceProps,
  ElasticKubernetesService,
  ElasticKubernetesServiceProps,
  ElasticLoadBalancing,
  ElasticLoadBalancingProps,
  ElasticLoadBalancingType,
  ElasticTranscoder,
  ElasticTranscoderProps,
  ElasticsearchService,
  ElasticsearchServiceProps,
  ElementalConductor,
  ElementalConductorProps,
  ElementalDelta,
  ElementalDeltaProps,
  ElementalLive,
  ElementalLiveProps,
  ElementalMediaConnect,
  ElementalMediaConnectProps,
  ElementalMediaConvert,
  ElementalMediaConvertProps,
  ElementalMediaLive,
  ElementalMediaLiveProps,
  ElementalMediaPackage,
  ElementalMediaPackageProps,
  ElementalMediaStore,
  ElementalMediaStoreProps,
  ElementalMediaTailor,
  ElementalMediaTailorProps,
  ElementalServer,
  ElementalServerProps,
  EndUserComputing,
  EndUserComputingProps,
  EventBridge,
  EventBridgeProps,
  EventBridgeType,
  ExpressWorkflows,
  ExpressWorkflowsProps,
  FSx,
  FSxForLustre,
  FSxForLustreProps,
  FSxForWindowsFileServer,
  FSxForWindowsFileServerProps,
  FSxProps,
  Fargate,
  FargateProps,
  FirewallManager,
  FirewallManagerProps,
  Forecast,
  ForecastProps,
  FraudDetector,
  FraudDetectorProps,
  FreeRTOS,
  FreeRTOSProps,
  GameLift,
  GameLiftProps,
  GameTech,
  GameTechProps,
  GenericGroup,
  GenericGroupProps,
  GlobalAccelerator,
  GlobalAcceleratorProps,
  Glue,
  GlueProps,
  GlueType,
  GroundStation,
  GroundStationProps,
  GuardDuty,
  GuardDutyProps,
  IAM,
  IAMProps,
  IAMType,
  IQ,
  IQProps,
  ImageBuilder,
  ImageBuilderProps,
  InfrequentAccessStorageClass,
  InfrequentAccessStorageClassProps,
  Inspector,
  InspectorProps,
  InspectorType,
  InternetOfThings,
  InternetOfThingsProps,
  InvizAWS,
  IoTAnalytics,
  IoTAnalyticsProps,
  IoTAnalyticsType,
  IoTButton,
  IoTButtonProps,
  IoTCore,
  IoTCoreProps,
  IoTDeviceManagement,
  IoTDeviceManagementProps,
  IoTEvents,
  IoTEventsProps,
  IoTGreengrass,
  IoTGreengrassProps,
  IoTGreengrassType,
  IoTResource,
  IoTResourceProps,
  IoTResourceType,
  IoTSiteWise,
  IoTSiteWiseProps,
  IoTThing,
  IoTThingProps,
  IoTThingType,
  IoTThingsGraph,
  IoTThingsGraphProps,
  KMS,
  Kendra,
  KendraProps,
  KeyManagementService,
  KeyManagementServiceProps,
  Kinesis,
  KinesisProps,
  KinesisType,
  KinesisVideoStreams,
  KinesisVideoStreamsProps,
  LakeFormation,
  LakeFormationProps,
  LakeFormationType,
  Lambda,
  LambdaProps,
  LambdaType,
  Lex,
  LexProps,
  LicenseManager,
  LicenseManagerProps,
  Lightsail,
  LightsailProps,
  LocalZones,
  LocalZonesProps,
  MCS,
  MQ,
  MQProps,
  MachineLearning,
  MachineLearningProps,
  Macie,
  MacieProps,
  ManagedApacheCassandraService,
  ManagedApacheCassandraServiceProps,
  ManagedBlockchain,
  ManagedBlockchainProps,
  ManagedBlockchainType,
  ManagedServices,
  ManagedServicesProps,
  ManagedStreamingForKafka,
  ManagedStreamingForKafkaProps,
  ManagementConsole,
  ManagementConsoleProps,
  ManagementGovernance,
  ManagementGovernanceProps,
  MediaServices,
  MediaServicesProps,
  MigrationHub,
  MigrationHubProps,
  MigrationTransfer,
  MigrationTransferProps,
  Mobile,
  MobileProps,
  Neptune,
  NeptuneProps,
  NetworkingContentDelivery,
  NetworkingContentDeliveryProps,
  OneClick,
  OneClickProps,
  OpsWorks,
  OpsWorksProps,
  OpsWorksType,
  Organizations,
  OrganizationsProps,
  OrganizationsType,
  Outposts,
  OutpostsProps,
  ParallelCluster,
  ParallelClusterProps,
  PersonalHealthDashboard,
  PersonalHealthDashboardProps,
  Personalize,
  PersonalizeProps,
  Pinpoint,
  PinpointCategory,
  PinpointProps,
  Polly,
  PollyProps,
  PrivateLink,
  PrivateLinkProps,
  ProfessionalServices,
  ProfessionalServicesProps,
  QLDB,
  QuantumLedgerDatabase,
  QuantumLedgerDatabaseCategory,
  QuantumLedgerDatabaseProps,
  QuantumTechnologies,
  QuantumTechnologiesProps,
  QuickSight,
  QuickSightProps,
  RDS,
  RDSProps,
  RDSType,
  Redshift,
  RedshiftCategory,
  RedshiftProps,
  RedshiftType,
  Region,
  Rekognition,
  RekognitionProps,
  RekognitionType,
  ReservedInstanceReporting,
  ReservedInstanceReportingProps,
  RoboMaker,
  RoboMakerProps,
  RoboMakerType,
  Robotics,
  RoboticsProps,
  Route53,
  Route53Props,
  Route53Type,
  S3,
  S3Glacier,
  S3GlacierProps,
  S3GlacierType,
  S3Props,
  S3Type,
  SES,
  SF,
  SMS,
  SNS,
  SQS,
  SageMaker,
  SageMakerProps,
  SageMakerType,
  Satellite,
  SatelliteProps,
  SavingsPlans,
  SavingsPlansProps,
  SecretsManager,
  SecretsManagerProps,
  SecurityGroup,
  SecurityHub,
  SecurityHubProps,
  SecurityHubType,
  SecurityIdentityCompliance,
  SecurityIdentityComplianceProps,
  ServerContents,
  ServerContentsProps,
  ServerMigrationService,
  ServerMigrationServiceProps,
  ServerlessApplicationRepository,
  ServerlessApplicationRepositoryProps,
  ServiceCatalog,
  ServiceCatalogProps,
  Shield,
  ShieldProps,
  ShieldType,
  SimpleEmailService,
  SimpleEmailServiceProps,
  SimpleEmailServiceType,
  SimpleNotificationService,
  SimpleNotificationServiceProps,
  SimpleNotificationServiceType,
  SimpleQueueService,
  SimpleQueueServiceProps,
  SimpleQueueServiceType,
  SingleSignOn,
  SingleSignOnProps,
  SiteToSiteVPN,
  SiteToSiteVPNProps,
  Snowball,
  SnowballEdge,
  SnowballEdgeProps,
  SnowballProps,
  SnowballType,
  Snowmobile,
  SnowmobileProps,
  SpotFleet,
  SpotFleetProps,
  StandardStorageClass,
  StandardStorageClassProps,
  StepFunctions,
  StepFunctionsProps,
  StepFunctionsWorkflow,
  StepFunctionsWorkflowProps,
  Storage,
  StorageGateway,
  StorageGatewayProps,
  StorageGatewayType,
  StorageProps,
  Sumerian,
  SumerianProps,
  Support,
  SupportProps,
  SystemsManager,
  SystemsManagerProps,
  SystemsManagerType,
  TensorFlowOnAWS,
  TensorFlowOnAWSProps,
  Textract,
  TextractProps,
  Thinkbox,
  ThinkboxKrakatoa,
  ThinkboxKrakatoaProps,
  ThinkboxProps,
  ThinkboxSequoia,
  ThinkboxSequoiaProps,
  ThinkboxStoke,
  ThinkboxStokeProps,
  ThinkboxXMesh,
  ThinkboxXMeshProps,
  Timestream,
  TimestreamProps,
  ToolsAndSDKs,
  ToolsAndSDKsProps,
  Transcribe,
  TranscribeProps,
  TransferFamily,
  TransferFamilyProps,
  TransferFamilyType,
  TransitGateway,
  TransitGatewayProps,
  Translate,
  TranslateProps,
  TrustedAdvisor,
  TrustedAdvisorProps,
  TrustedAdvisorType,
  VMwareCloudOnAWS,
  VMwareCloudOnAWSProps,
  VPC,
  VrAr,
  WAF,
  WAFProps,
  WAFType,
  Wavelength,
  WavelengthProps,
  WellArchitectedTool,
  WellArchitectedToolProps,
  WorkDocs,
  WorkDocsProps,
  WorkLink,
  WorkLinkProps,
  WorkMail,
  WorkMailProps,
  WorkSpaces,
  WorkSpacesProps,
  XRay,
  XRayProps,
};