// generateTypeNameGetter generates getter for original VPP type name into the provider writer
769010
func generateTypeNameGetter(w io.Writer, structName, msgName string) {
	fmt.Fprintf(w, `func (*%s) GetTypeName() string {
	return %q
}
`, structName, msgName)
}
900187
func NewResourceByType(typeName string) ResourceProperties {
	switch typeName {
	case "AWS::ApiGateway::Account":
		return &APIGatewayAccount{}
	case "AWS::ApiGateway::ApiKey":
		return &APIGatewayAPIKey{}
	case "AWS::ApiGateway::Authorizer":
		return &APIGatewayAuthorizer{}
	case "AWS::ApiGateway::BasePathMapping":
		return &APIGatewayBasePathMapping{}
	case "AWS::ApiGateway::ClientCertificate":
		return &APIGatewayClientCertificate{}
	case "AWS::ApiGateway::Deployment":
		return &APIGatewayDeployment{}
	case "AWS::ApiGateway::DocumentationPart":
		return &APIGatewayDocumentationPart{}
	case "AWS::ApiGateway::DocumentationVersion":
		return &APIGatewayDocumentationVersion{}
	case "AWS::ApiGateway::DomainName":
		return &APIGatewayDomainName{}
	case "AWS::ApiGateway::GatewayResponse":
		return &APIGatewayGatewayResponse{}
	case "AWS::ApiGateway::Method":
		return &APIGatewayMethod{}
	case "AWS::ApiGateway::Model":
		return &APIGatewayModel{}
	case "AWS::ApiGateway::RequestValidator":
		return &APIGatewayRequestValidator{}
	case "AWS::ApiGateway::Resource":
		return &APIGatewayResource{}
	case "AWS::ApiGateway::RestApi":
		return &APIGatewayRestAPI{}
	case "AWS::ApiGateway::Stage":
		return &APIGatewayStage{}
	case "AWS::ApiGateway::UsagePlan":
		return &APIGatewayUsagePlan{}
	case "AWS::ApiGateway::UsagePlanKey":
		return &APIGatewayUsagePlanKey{}
	case "AWS::ApiGateway::VpcLink":
		return &APIGatewayVPCLink{}
	case "AWS::AppSync::ApiKey":
		return &AppSyncAPIKey{}
	case "AWS::AppSync::DataSource":
		return &AppSyncDataSource{}
	case "AWS::AppSync::GraphQLApi":
		return &AppSyncGraphQLAPI{}
	case "AWS::AppSync::GraphQLSchema":
		return &AppSyncGraphQLSchema{}
	case "AWS::AppSync::Resolver":
		return &AppSyncResolver{}
	case "AWS::ApplicationAutoScaling::ScalableTarget":
		return &ApplicationAutoScalingScalableTarget{}
	case "AWS::ApplicationAutoScaling::ScalingPolicy":
		return &ApplicationAutoScalingScalingPolicy{}
	case "AWS::Athena::NamedQuery":
		return &AthenaNamedQuery{}
	case "AWS::AutoScaling::AutoScalingGroup":
		return &AutoScalingAutoScalingGroup{}
	case "AWS::AutoScaling::LaunchConfiguration":
		return &AutoScalingLaunchConfiguration{}
	case "AWS::AutoScaling::LifecycleHook":
		return &AutoScalingLifecycleHook{}
	case "AWS::AutoScaling::ScalingPolicy":
		return &AutoScalingScalingPolicy{}
	case "AWS::AutoScaling::ScheduledAction":
		return &AutoScalingScheduledAction{}
	case "AWS::AutoScalingPlans::ScalingPlan":
		return &AutoScalingPlansScalingPlan{}
	case "AWS::Batch::ComputeEnvironment":
		return &BatchComputeEnvironment{}
	case "AWS::Batch::JobDefinition":
		return &BatchJobDefinition{}
	case "AWS::Batch::JobQueue":
		return &BatchJobQueue{}
	case "AWS::Budgets::Budget":
		return &BudgetsBudget{}
	case "AWS::CertificateManager::Certificate":
		return &CertificateManagerCertificate{}
	case "AWS::Cloud9::EnvironmentEC2":
		return &Cloud9EnvironmentEC2{}
	case "AWS::CloudFormation::CustomResource":
		return &CloudFormationCustomResource{}
	case "AWS::CloudFormation::Stack":
		return &CloudFormationStack{}
	case "AWS::CloudFormation::WaitCondition":
		return &CloudFormationWaitCondition{}
	case "AWS::CloudFormation::WaitConditionHandle":
		return &CloudFormationWaitConditionHandle{}
	case "AWS::CloudFront::CloudFrontOriginAccessIdentity":
		return &CloudFrontCloudFrontOriginAccessIDentity{}
	case "AWS::CloudFront::Distribution":
		return &CloudFrontDistribution{}
	case "AWS::CloudFront::StreamingDistribution":
		return &CloudFrontStreamingDistribution{}
	case "AWS::CloudTrail::Trail":
		return &CloudTrailTrail{}
	case "AWS::CloudWatch::Alarm":
		return &CloudWatchAlarm{}
	case "AWS::CloudWatch::Dashboard":
		return &CloudWatchDashboard{}
	case "AWS::CodeBuild::Project":
		return &CodeBuildProject{}
	case "AWS::CodeCommit::Repository":
		return &CodeCommitRepository{}
	case "AWS::CodeDeploy::Application":
		return &CodeDeployApplication{}
	case "AWS::CodeDeploy::DeploymentConfig":
		return &CodeDeployDeploymentConfig{}
	case "AWS::CodeDeploy::DeploymentGroup":
		return &CodeDeployDeploymentGroup{}
	case "AWS::CodePipeline::CustomActionType":
		return &CodePipelineCustomActionType{}
	case "AWS::CodePipeline::Pipeline":
		return &CodePipelinePipeline{}
	case "AWS::Cognito::IdentityPool":
		return &CognitoIDentityPool{}
	case "AWS::Cognito::IdentityPoolRoleAttachment":
		return &CognitoIDentityPoolRoleAttachment{}
	case "AWS::Cognito::UserPool":
		return &CognitoUserPool{}
	case "AWS::Cognito::UserPoolClient":
		return &CognitoUserPoolClient{}
	case "AWS::Cognito::UserPoolGroup":
		return &CognitoUserPoolGroup{}
	case "AWS::Cognito::UserPoolUser":
		return &CognitoUserPoolUser{}
	case "AWS::Cognito::UserPoolUserToGroupAttachment":
		return &CognitoUserPoolUserToGroupAttachment{}
	case "AWS::Config::ConfigRule":
		return &ConfigConfigRule{}
	case "AWS::Config::ConfigurationRecorder":
		return &ConfigConfigurationRecorder{}
	case "AWS::Config::DeliveryChannel":
		return &ConfigDeliveryChannel{}
	case "AWS::DAX::Cluster":
		return &DAXCluster{}
	case "AWS::DAX::ParameterGroup":
		return &DAXParameterGroup{}
	case "AWS::DAX::SubnetGroup":
		return &DAXSubnetGroup{}
	case "AWS::DMS::Certificate":
		return &DMSCertificate{}
	case "AWS::DMS::Endpoint":
		return &DMSEndpoint{}
	case "AWS::DMS::EventSubscription":
		return &DMSEventSubscription{}
	case "AWS::DMS::ReplicationInstance":
		return &DMSReplicationInstance{}
	case "AWS::DMS::ReplicationSubnetGroup":
		return &DMSReplicationSubnetGroup{}
	case "AWS::DMS::ReplicationTask":
		return &DMSReplicationTask{}
	case "AWS::DataPipeline::Pipeline":
		return &DataPipelinePipeline{}
	case "AWS::DirectoryService::MicrosoftAD":
		return &DirectoryServiceMicrosoftAD{}
	case "AWS::DirectoryService::SimpleAD":
		return &DirectoryServiceSimpleAD{}
	case "AWS::DynamoDB::Table":
		return &DynamoDBTable{}
	case "AWS::EC2::CustomerGateway":
		return &EC2CustomerGateway{}
	case "AWS::EC2::DHCPOptions":
		return &EC2DHCPOptions{}
	case "AWS::EC2::EIP":
		return &EC2EIP{}
	case "AWS::EC2::EIPAssociation":
		return &EC2EIPAssociation{}
	case "AWS::EC2::EgressOnlyInternetGateway":
		return &EC2EgressOnlyInternetGateway{}
	case "AWS::EC2::FlowLog":
		return &EC2FlowLog{}
	case "AWS::EC2::Host":
		return &EC2Host{}
	case "AWS::EC2::Instance":
		return &EC2Instance{}
	case "AWS::EC2::InternetGateway":
		return &EC2InternetGateway{}
	case "AWS::EC2::LaunchTemplate":
		return &EC2LaunchTemplate{}
	case "AWS::EC2::NatGateway":
		return &EC2NatGateway{}
	case "AWS::EC2::NetworkAcl":
		return &EC2NetworkACL{}
	case "AWS::EC2::NetworkAclEntry":
		return &EC2NetworkACLEntry{}
	case "AWS::EC2::NetworkInterface":
		return &EC2NetworkInterface{}
	case "AWS::EC2::NetworkInterfaceAttachment":
		return &EC2NetworkInterfaceAttachment{}
	case "AWS::EC2::NetworkInterfacePermission":
		return &EC2NetworkInterfacePermission{}
	case "AWS::EC2::PlacementGroup":
		return &EC2PlacementGroup{}
	case "AWS::EC2::Route":
		return &EC2Route{}
	case "AWS::EC2::RouteTable":
		return &EC2RouteTable{}
	case "AWS::EC2::SecurityGroup":
		return &EC2SecurityGroup{}
	case "AWS::EC2::SecurityGroupEgress":
		return &EC2SecurityGroupEgress{}
	case "AWS::EC2::SecurityGroupIngress":
		return &EC2SecurityGroupIngress{}
	case "AWS::EC2::SpotFleet":
		return &EC2SpotFleet{}
	case "AWS::EC2::Subnet":
		return &EC2Subnet{}
	case "AWS::EC2::SubnetCidrBlock":
		return &EC2SubnetCidrBlock{}
	case "AWS::EC2::SubnetNetworkAclAssociation":
		return &EC2SubnetNetworkACLAssociation{}
	case "AWS::EC2::SubnetRouteTableAssociation":
		return &EC2SubnetRouteTableAssociation{}
	case "AWS::EC2::TrunkInterfaceAssociation":
		return &EC2TrunkInterfaceAssociation{}
	case "AWS::EC2::VPC":
		return &EC2VPC{}
	case "AWS::EC2::VPCCidrBlock":
		return &EC2VPCCidrBlock{}
	case "AWS::EC2::VPCDHCPOptionsAssociation":
		return &EC2VPCDHCPOptionsAssociation{}
	case "AWS::EC2::VPCEndpoint":
		return &EC2VPCEndpoint{}
	case "AWS::EC2::VPCGatewayAttachment":
		return &EC2VPCGatewayAttachment{}
	case "AWS::EC2::VPCPeeringConnection":
		return &EC2VPCPeeringConnection{}
	case "AWS::EC2::VPNConnection":
		return &EC2VPNConnection{}
	case "AWS::EC2::VPNConnectionRoute":
		return &EC2VPNConnectionRoute{}
	case "AWS::EC2::VPNGateway":
		return &EC2VPNGateway{}
	case "AWS::EC2::VPNGatewayRoutePropagation":
		return &EC2VPNGatewayRoutePropagation{}
	case "AWS::EC2::Volume":
		return &EC2Volume{}
	case "AWS::EC2::VolumeAttachment":
		return &EC2VolumeAttachment{}
	case "AWS::ECR::Repository":
		return &ECRRepository{}
	case "AWS::ECS::Cluster":
		return &ECSCluster{}
	case "AWS::ECS::Service":
		return &ECSService{}
	case "AWS::ECS::TaskDefinition":
		return &ECSTaskDefinition{}
	case "AWS::EFS::FileSystem":
		return &EFSFileSystem{}
	case "AWS::EFS::MountTarget":
		return &EFSMountTarget{}
	case "AWS::EMR::Cluster":
		return &EMRCluster{}
	case "AWS::EMR::InstanceFleetConfig":
		return &EMRInstanceFleetConfig{}
	case "AWS::EMR::InstanceGroupConfig":
		return &EMRInstanceGroupConfig{}
	case "AWS::EMR::SecurityConfiguration":
		return &EMRSecurityConfiguration{}
	case "AWS::EMR::Step":
		return &EMRStep{}
	case "AWS::ElastiCache::CacheCluster":
		return &ElastiCacheCacheCluster{}
	case "AWS::ElastiCache::ParameterGroup":
		return &ElastiCacheParameterGroup{}
	case "AWS::ElastiCache::ReplicationGroup":
		return &ElastiCacheReplicationGroup{}
	case "AWS::ElastiCache::SecurityGroup":
		return &ElastiCacheSecurityGroup{}
	case "AWS::ElastiCache::SecurityGroupIngress":
		return &ElastiCacheSecurityGroupIngress{}
	case "AWS::ElastiCache::SubnetGroup":
		return &ElastiCacheSubnetGroup{}
	case "AWS::ElasticBeanstalk::Application":
		return &ElasticBeanstalkApplication{}
	case "AWS::ElasticBeanstalk::ApplicationVersion":
		return &ElasticBeanstalkApplicationVersion{}
	case "AWS::ElasticBeanstalk::ConfigurationTemplate":
		return &ElasticBeanstalkConfigurationTemplate{}
	case "AWS::ElasticBeanstalk::Environment":
		return &ElasticBeanstalkEnvironment{}
	case "AWS::ElasticLoadBalancing::LoadBalancer":
		return &ElasticLoadBalancingLoadBalancer{}
	case "AWS::ElasticLoadBalancingV2::Listener":
		return &ElasticLoadBalancingV2Listener{}
	case "AWS::ElasticLoadBalancingV2::ListenerCertificate":
		return &ElasticLoadBalancingV2ListenerCertificate{}
	case "AWS::ElasticLoadBalancingV2::ListenerRule":
		return &ElasticLoadBalancingV2ListenerRule{}
	case "AWS::ElasticLoadBalancingV2::LoadBalancer":
		return &ElasticLoadBalancingV2LoadBalancer{}
	case "AWS::ElasticLoadBalancingV2::TargetGroup":
		return &ElasticLoadBalancingV2TargetGroup{}
	case "AWS::Elasticsearch::Domain":
		return &ElasticsearchDomain{}
	case "AWS::Events::Rule":
		return &EventsRule{}
	case "AWS::GameLift::Alias":
		return &GameLiftAlias{}
	case "AWS::GameLift::Build":
		return &GameLiftBuild{}
	case "AWS::GameLift::Fleet":
		return &GameLiftFleet{}
	case "AWS::Glue::Classifier":
		return &GlueClassifier{}
	case "AWS::Glue::Connection":
		return &GlueConnection{}
	case "AWS::Glue::Crawler":
		return &GlueCrawler{}
	case "AWS::Glue::Database":
		return &GlueDatabase{}
	case "AWS::Glue::DevEndpoint":
		return &GlueDevEndpoint{}
	case "AWS::Glue::Job":
		return &GlueJob{}
	case "AWS::Glue::Partition":
		return &GluePartition{}
	case "AWS::Glue::Table":
		return &GlueTable{}
	case "AWS::Glue::Trigger":
		return &GlueTrigger{}
	case "AWS::GuardDuty::Detector":
		return &GuardDutyDetector{}
	case "AWS::GuardDuty::Filter":
		return &GuardDutyFilter{}
	case "AWS::GuardDuty::IPSet":
		return &GuardDutyIPSet{}
	case "AWS::GuardDuty::Master":
		return &GuardDutyMaster{}
	case "AWS::GuardDuty::Member":
		return &GuardDutyMember{}
	case "AWS::GuardDuty::ThreatIntelSet":
		return &GuardDutyThreatIntelSet{}
	case "AWS::IAM::AccessKey":
		return &IAMAccessKey{}
	case "AWS::IAM::Group":
		return &IAMGroup{}
	case "AWS::IAM::InstanceProfile":
		return &IAMInstanceProfile{}
	case "AWS::IAM::ManagedPolicy":
		return &IAMManagedPolicy{}
	case "AWS::IAM::Policy":
		return &IAMPolicy{}
	case "AWS::IAM::Role":
		return &IAMRole{}
	case "AWS::IAM::User":
		return &IAMUser{}
	case "AWS::IAM::UserToGroupAddition":
		return &IAMUserToGroupAddition{}
	case "AWS::Inspector::AssessmentTarget":
		return &InspectorAssessmentTarget{}
	case "AWS::Inspector::AssessmentTemplate":
		return &InspectorAssessmentTemplate{}
	case "AWS::Inspector::ResourceGroup":
		return &InspectorResourceGroup{}
	case "AWS::IoT::Certificate":
		return &IoTCertificate{}
	case "AWS::IoT::Policy":
		return &IoTPolicy{}
	case "AWS::IoT::PolicyPrincipalAttachment":
		return &IoTPolicyPrincipalAttachment{}
	case "AWS::IoT::Thing":
		return &IoTThing{}
	case "AWS::IoT::ThingPrincipalAttachment":
		return &IoTThingPrincipalAttachment{}
	case "AWS::IoT::TopicRule":
		return &IoTTopicRule{}
	case "AWS::KMS::Alias":
		return &KMSAlias{}
	case "AWS::KMS::Key":
		return &KMSKey{}
	case "AWS::Kinesis::Stream":
		return &KinesisStream{}
	case "AWS::KinesisAnalytics::Application":
		return &KinesisAnalyticsApplication{}
	case "AWS::KinesisAnalytics::ApplicationOutput":
		return &KinesisAnalyticsApplicationOutput{}
	case "AWS::KinesisAnalytics::ApplicationReferenceDataSource":
		return &KinesisAnalyticsApplicationReferenceDataSource{}
	case "AWS::KinesisFirehose::DeliveryStream":
		return &KinesisFirehoseDeliveryStream{}
	case "AWS::Lambda::Alias":
		return &LambdaAlias{}
	case "AWS::Lambda::EventSourceMapping":
		return &LambdaEventSourceMapping{}
	case "AWS::Lambda::Function":
		return &LambdaFunction{}
	case "AWS::Lambda::Permission":
		return &LambdaPermission{}
	case "AWS::Lambda::Version":
		return &LambdaVersion{}
	case "AWS::Logs::Destination":
		return &LogsDestination{}
	case "AWS::Logs::LogGroup":
		return &LogsLogGroup{}
	case "AWS::Logs::LogStream":
		return &LogsLogStream{}
	case "AWS::Logs::MetricFilter":
		return &LogsMetricFilter{}
	case "AWS::Logs::SubscriptionFilter":
		return &LogsSubscriptionFilter{}
	case "AWS::OpsWorks::App":
		return &OpsWorksApp{}
	case "AWS::OpsWorks::ElasticLoadBalancerAttachment":
		return &OpsWorksElasticLoadBalancerAttachment{}
	case "AWS::OpsWorks::Instance":
		return &OpsWorksInstance{}
	case "AWS::OpsWorks::Layer":
		return &OpsWorksLayer{}
	case "AWS::OpsWorks::Stack":
		return &OpsWorksStack{}
	case "AWS::OpsWorks::UserProfile":
		return &OpsWorksUserProfile{}
	case "AWS::OpsWorks::Volume":
		return &OpsWorksVolume{}
	case "AWS::RDS::DBCluster":
		return &RDSDBCluster{}
	case "AWS::RDS::DBClusterParameterGroup":
		return &RDSDBClusterParameterGroup{}
	case "AWS::RDS::DBInstance":
		return &RDSDBInstance{}
	case "AWS::RDS::DBParameterGroup":
		return &RDSDBParameterGroup{}
	case "AWS::RDS::DBSecurityGroup":
		return &RDSDBSecurityGroup{}
	case "AWS::RDS::DBSecurityGroupIngress":
		return &RDSDBSecurityGroupIngress{}
	case "AWS::RDS::DBSubnetGroup":
		return &RDSDBSubnetGroup{}
	case "AWS::RDS::EventSubscription":
		return &RDSEventSubscription{}
	case "AWS::RDS::OptionGroup":
		return &RDSOptionGroup{}
	case "AWS::Redshift::Cluster":
		return &RedshiftCluster{}
	case "AWS::Redshift::ClusterParameterGroup":
		return &RedshiftClusterParameterGroup{}
	case "AWS::Redshift::ClusterSecurityGroup":
		return &RedshiftClusterSecurityGroup{}
	case "AWS::Redshift::ClusterSecurityGroupIngress":
		return &RedshiftClusterSecurityGroupIngress{}
	case "AWS::Redshift::ClusterSubnetGroup":
		return &RedshiftClusterSubnetGroup{}
	case "AWS::Route53::HealthCheck":
		return &Route53HealthCheck{}
	case "AWS::Route53::HostedZone":
		return &Route53HostedZone{}
	case "AWS::Route53::RecordSet":
		return &Route53RecordSet{}
	case "AWS::Route53::RecordSetGroup":
		return &Route53RecordSetGroup{}
	case "AWS::S3::Bucket":
		return &S3Bucket{}
	case "AWS::S3::BucketPolicy":
		return &S3BucketPolicy{}
	case "AWS::SDB::Domain":
		return &SDBDomain{}
	case "AWS::SES::ConfigurationSet":
		return &SESConfigurationSet{}
	case "AWS::SES::ConfigurationSetEventDestination":
		return &SESConfigurationSetEventDestination{}
	case "AWS::SES::ReceiptFilter":
		return &SESReceiptFilter{}
	case "AWS::SES::ReceiptRule":
		return &SESReceiptRule{}
	case "AWS::SES::ReceiptRuleSet":
		return &SESReceiptRuleSet{}
	case "AWS::SES::Template":
		return &SESTemplate{}
	case "AWS::SNS::Subscription":
		return &SNSSubscription{}
	case "AWS::SNS::Topic":
		return &SNSTopic{}
	case "AWS::SNS::TopicPolicy":
		return &SNSTopicPolicy{}
	case "AWS::SQS::Queue":
		return &SQSQueue{}
	case "AWS::SQS::QueuePolicy":
		return &SQSQueuePolicy{}
	case "AWS::SSM::Association":
		return &SSMAssociation{}
	case "AWS::SSM::Document":
		return &SSMDocument{}
	case "AWS::SSM::MaintenanceWindowTask":
		return &SSMMaintenanceWindowTask{}
	case "AWS::SSM::Parameter":
		return &SSMParameter{}
	case "AWS::SSM::PatchBaseline":
		return &SSMPatchBaseline{}
	case "AWS::ServiceCatalog::AcceptedPortfolioShare":
		return &ServiceCatalogAcceptedPortfolioShare{}
	case "AWS::ServiceCatalog::CloudFormationProduct":
		return &ServiceCatalogCloudFormationProduct{}
	case "AWS::ServiceCatalog::CloudFormationProvisionedProduct":
		return &ServiceCatalogCloudFormationProvisionedProduct{}
	case "AWS::ServiceCatalog::LaunchNotificationConstraint":
		return &ServiceCatalogLaunchNotificationConstraint{}
	case "AWS::ServiceCatalog::LaunchRoleConstraint":
		return &ServiceCatalogLaunchRoleConstraint{}
	case "AWS::ServiceCatalog::LaunchTemplateConstraint":
		return &ServiceCatalogLaunchTemplateConstraint{}
	case "AWS::ServiceCatalog::Portfolio":
		return &ServiceCatalogPortfolio{}
	case "AWS::ServiceCatalog::PortfolioPrincipalAssociation":
		return &ServiceCatalogPortfolioPrincipalAssociation{}
	case "AWS::ServiceCatalog::PortfolioProductAssociation":
		return &ServiceCatalogPortfolioProductAssociation{}
	case "AWS::ServiceCatalog::PortfolioShare":
		return &ServiceCatalogPortfolioShare{}
	case "AWS::ServiceCatalog::TagOption":
		return &ServiceCatalogTagOption{}
	case "AWS::ServiceCatalog::TagOptionAssociation":
		return &ServiceCatalogTagOptionAssociation{}
	case "AWS::ServiceDiscovery::Instance":
		return &ServiceDiscoveryInstance{}
	case "AWS::ServiceDiscovery::PrivateDnsNamespace":
		return &ServiceDiscoveryPrivateDNSNamespace{}
	case "AWS::ServiceDiscovery::PublicDnsNamespace":
		return &ServiceDiscoveryPublicDNSNamespace{}
	case "AWS::ServiceDiscovery::Service":
		return &ServiceDiscoveryService{}
	case "AWS::StepFunctions::Activity":
		return &StepFunctionsActivity{}
	case "AWS::StepFunctions::StateMachine":
		return &StepFunctionsStateMachine{}
	case "AWS::WAF::ByteMatchSet":
		return &WAFByteMatchSet{}
	case "AWS::WAF::IPSet":
		return &WAFIPSet{}
	case "AWS::WAF::Rule":
		return &WAFRule{}
	case "AWS::WAF::SizeConstraintSet":
		return &WAFSizeConstraintSet{}
	case "AWS::WAF::SqlInjectionMatchSet":
		return &WAFSQLInjectionMatchSet{}
	case "AWS::WAF::WebACL":
		return &WAFWebACL{}
	case "AWS::WAF::XssMatchSet":
		return &WAFXSSMatchSet{}
	case "AWS::WAFRegional::ByteMatchSet":
		return &WAFRegionalByteMatchSet{}
	case "AWS::WAFRegional::IPSet":
		return &WAFRegionalIPSet{}
	case "AWS::WAFRegional::Rule":
		return &WAFRegionalRule{}
	case "AWS::WAFRegional::SizeConstraintSet":
		return &WAFRegionalSizeConstraintSet{}
	case "AWS::WAFRegional::SqlInjectionMatchSet":
		return &WAFRegionalSQLInjectionMatchSet{}
	case "AWS::WAFRegional::WebACL":
		return &WAFRegionalWebACL{}
	case "AWS::WAFRegional::WebACLAssociation":
		return &WAFRegionalWebACLAssociation{}
	case "AWS::WAFRegional::XssMatchSet":
		return &WAFRegionalXSSMatchSet{}
	case "AWS::WorkSpaces::Workspace":
		return &WorkSpacesWorkspace{}

	default:
		for _, eachProvider := range customResourceProviders {
			customType := eachProvider(typeName)
			if nil != customType {
				return customType
			}
		}
	}
	return nil
}
505488
func mergeTypeName(name, rtName string, apiDef *APIDefinition) string {
	if apiDef == nil {
		log.Warning("passing nil API definition to mergeTypeName")
		return name
	}

	// check if this resource type is in library
	splt := strings.Split(rtName, ".")
	if len(splt) < 2 {
		// if not in library, we need to do nothing
		return name
	}

	// get the library object from API definition root object
	libName := splt[0]
	lib, ok := apiDef.Libraries[libName]
	if !ok {
		return name
	}

	// type not exist in the library
	if _, ok := lib.Types[name]; !ok {
		return name
	}

	return strings.Join([]string{libName, name}, ".")
}
597234
func (b *RouteBuilder) typeNameHandler(handler TypeNameHandleFunction) *RouteBuilder {
	b.typeNameHandleFunc = handler
	return b
}
755733
func (r *Redis) ClientGetName() ([]byte, error) {
	rp, err := r.ExecuteCommand("CLIENT", "GETNAME")
	if err != nil {
		return nil, err
	}
	return rp.BytesValue()
}
599847
func GetNamed(ttype Type) Named {
	unmodifiedType := ttype
	for {
		switch typ := unmodifiedType.(type) {
		case *List:
			unmodifiedType = typ.OfType
		case *NonNull:
			unmodifiedType = typ.OfType
		default:
			return unmodifiedType
		}
	}
}
266004
func (l VirtualDeviceList) TypeName(device types.BaseVirtualDevice) string {
	dtype := reflect.TypeOf(device)
	if dtype == nil {
		return ""
	}
	return dtype.Elem().Name()
}
283655
func (p protobufLocator) CastTypeName(name types.Name) string {
	if name.Package == p.localGoPackage {
		return name.Name
	}
	return name.String()
}
575856
func (g *grpc) typeName(str string) string {
	return g.gen.TypeName(g.objectNamed(str))
}
740176
func (m *metadata) InstanceType(ctx context.Context, name types.NodeName) (string, error) {
	instanceType, err := m.get(metadataTypeInstanceType)
	if err != nil {
		return "", fmt.Errorf("could not get instance type: %v", err)
	}

	return instanceType, nil
}
865496
func GetNameservers(resolvConf []byte, kind int) []string {
	nameservers := []string{}
	for _, line := range getLines(resolvConf, []byte("#")) {
		var ns [][]byte
		if kind == types.IP {
			ns = nsRegexp.FindSubmatch(line)
		} else if kind == types.IPv4 {
			ns = nsIPv4Regexpmatch.FindSubmatch(line)
		} else if kind == types.IPv6 {
			ns = nsIPv6Regexpmatch.FindSubmatch(line)
		}
		if len(ns) > 0 {
			nameservers = append(nameservers, string(ns[1]))
		}
	}
	return nameservers
}
519455
func (v *Argument) GetType() (o *Type) {
	if v != nil {
		o = v.Type
	}
	return
}
397010
func ProvidersGetter(pg GetProvidersFunc) func(*Configuration) error {
	return func(c *Configuration) error {
		c.tokenValidator.(*idTokenValidator).provGetter = pg
		return nil
	}
}
177483
func (r *RepositoryContent) GetType() string {
	if r == nil || r.Type == nil {
		return ""
	}
	return *r.Type
}
100007
func (f *oneofField) getter(g *Generator, mc *msgCtx) {
	// The discriminator type
	g.P("type ", f.goType, " interface {")
	g.P(f.goType, "()")
	g.P("}")
	g.P()
	// The subField types, fulfilling the discriminator type contract
	for _, sf := range f.subFields {
		g.P("type ", Annotate(mc.message.file, sf.fullPath, sf.oneofTypeName), " struct {")
		g.P(Annotate(mc.message.file, sf.fullPath, sf.goName), " ", sf.goType, " `", sf.tags, "`")
		g.P("}")
		g.P()
	}
	for _, sf := range f.subFields {
		g.P("func (*", sf.oneofTypeName, ") ", f.goType, "() {}")
		g.P()
	}
	// Getter for the oneof field
	g.P("func (m *", mc.goName, ") ", Annotate(mc.message.file, f.fullPath, f.getterName), "() ", f.goType, " {")
	g.P("if m != nil { return m.", f.goName, " }")
	g.P("return nil")
	g.P("}")
	g.P()
	// Getters for each oneof
	for _, sf := range f.subFields {
		if sf.deprecated != "" {
			g.P(sf.deprecated)
		}
		g.P("func (m *", mc.goName, ") ", Annotate(mc.message.file, sf.fullPath, sf.getterName), "() "+sf.goType+" {")
		g.P("if x, ok := m.", f.getterName, "().(*", sf.oneofTypeName, "); ok {")
		g.P("return x.", sf.goName)
		g.P("}")
		g.P("return ", sf.getterDef)
		g.P("}")
		g.P()
	}
}
1171694
func NewNamedType(name string) *NamedType {
	return &NamedType{token.NoPos, name, nil, true, make(map[string]Method)}
}
494624
func (g *Generator) genTypeDecoder(t reflect.Type, out string, tags fieldTags, indent int) error {
	ws := strings.Repeat("  ", indent)

	unmarshalerIface := reflect.TypeOf((*easyjson.Unmarshaler)(nil)).Elem()
	if reflect.PtrTo(t).Implements(unmarshalerIface) {
		fmt.Fprintln(g.out, ws+"("+out+").UnmarshalEasyJSON(in)")
		return nil
	}

	unmarshalerIface = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
	if reflect.PtrTo(t).Implements(unmarshalerIface) {
		fmt.Fprintln(g.out, ws+"if data := in.Raw(); in.Ok() {")
		fmt.Fprintln(g.out, ws+"  in.AddError( ("+out+").UnmarshalJSON(data) )")
		fmt.Fprintln(g.out, ws+"}")
		return nil
	}

	unmarshalerIface = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
	if reflect.PtrTo(t).Implements(unmarshalerIface) {
		fmt.Fprintln(g.out, ws+"if data := in.UnsafeBytes(); in.Ok() {")
		fmt.Fprintln(g.out, ws+"  in.AddError( ("+out+").UnmarshalText(data) )")
		fmt.Fprintln(g.out, ws+"}")
		return nil
	}

	err := g.genTypeDecoderNoCheck(t, out, tags, indent)
	return err
}