public MetadataTypes GetMetadataTypes(IRequest req, MetadataTypesConfig config = null, Func<Operation, bool> predicate = null)
 {
     return GetMetadataTypesGenerator(config).GetMetadataTypes(req, predicate);
 }

 internal MetadataTypesGenerator GetMetadataTypesGenerator(MetadataTypesConfig config)
 {
     return new MetadataTypesGenerator(meta, config ?? defaults);
 }

 public VbNetGenerator(MetadataTypesConfig config)
 {
     Config = config;
 }

 public NativeTypesMetadata(ServiceMetadata meta, MetadataTypesConfig defaults)
 {
     this.meta = meta;
     this.defaults = defaults;
 }

        public static bool IgnoreType(this MetadataType type, MetadataTypesConfig config, List<string> overrideIncludeType = null)
        {
            // If is a systemType and export types doesn't include this
            if (type.IgnoreSystemType() && config.ExportTypes.All(x => x.Name != type.Name))
                return true;

            var includes = overrideIncludeType ?? config.IncludeTypes;
            if (includes != null && !includes.Contains(type.Name))
                return true;

            if (config.ExcludeTypes != null &&
                config.ExcludeTypes.Any(x => type.Name == x || type.Name.StartsWith(x + "`")))
                return true;

            return false;
        }

 public CSharpGenerator(MetadataTypesConfig config)
 {
     Config = config;
     feature = HostContext.GetPlugin<NativeTypesFeature>();
 }

        public static bool IgnoreType(this MetadataType type, MetadataTypesConfig config)
        {
            if (type.IgnoreSystemType())
                return true;

            if (config.IncludeTypes != null && !config.IncludeTypes.Contains(type.Name))
                return true;

            if (config.ExcludeTypes != null && config.ExcludeTypes.Contains(type.Name))
                return true;

            return false;
        }

 public MetadataTypesGenerator(ServiceMetadata meta, MetadataTypesConfig config)
 {
     this.meta = meta;
     this.config = config;
 }

 public JavaGenerator(MetadataTypesConfig config)
 {
     Config = config;
 }

 public MetadataTypes GetMetadataTypes(IRequest req, MetadataTypesConfig config = null)
 {
     return GetMetadataTypesGenerator(config).GetMetadataTypes(req);
 }

 public SwiftGenerator(MetadataTypesConfig config)
 {
     Config = config;
     feature = HostContext.GetPlugin<NativeTypesFeature>();
     AllTypes = new List<MetadataType>();
 }

 public MetadataTypes GetMetadataTypes(IRequest req, MetadataTypesConfig config = null)
 {
     return new MetadataTypesGenerator(meta, config ?? defaults).GetMetadataTypes(req);
 }

        public static bool IgnoreType(this MetadataType type, MetadataTypesConfig config)
        {
            if (type.IgnoreSystemType() && config.ExportTypes.All(x => x.Name != type.Name))
                return true;

            if (config.IncludeTypes != null && !config.IncludeTypes.Contains(type.Name))
                return true;

            if (config.ExcludeTypes != null && 
                config.ExcludeTypes.Any(x => type.Name == x || type.Name.StartsWith(x + "`")))
                return true;

            return false;
        }

 public static void RemoveIgnoredTypesForNet(this MetadataTypes metadata, MetadataTypesConfig config)
 {
     metadata.RemoveIgnoredTypes(config);
     //Don't include Exported Types in System 
     metadata.Types.RemoveAll(x => x.IgnoreSystemType()); 
 }

 public TypeScriptGenerator(MetadataTypesConfig config)
 {
     Config = config;
 }

        public static void RemoveIgnoredTypes(this MetadataTypes metadata, MetadataTypesConfig config)
        {
            var includeList = GetIncludeList(metadata, config);

            metadata.Types.RemoveAll(x => x.IgnoreType(config, includeList));

            var matchingResponseTypes = includeList != null 
                ? metadata.Operations.Where(x => x.Response != null && includeList.Contains(x.Response.Name))
                    .Map(x => x.Response).ToArray()
                : TypeConstants<MetadataType>.EmptyArray;

            metadata.Operations.RemoveAll(x => x.Request.IgnoreType(config, includeList));
            metadata.Operations.Each(x => {
                if (x.Response != null && x.Response.IgnoreType(config, includeList))
                {
                    x.Response = null;
                }
            });

            //When the included Type is a Response Type because defined in another Service that's not included
            //ref: https://forums.servicestack.net/t/class-is-missing-from-generated-code/3030
            foreach (var responseType in matchingResponseTypes)
            {
                if (!metadata.Operations.Any(x => x.Response != null && x.Response.Name == responseType.Name)
                    && metadata.Types.All(x => x.Name != responseType.Name))
                {
                    metadata.Types.Add(responseType);
                }
            }
        }

        public static List<string> GetIncludeList(MetadataTypes metadata, MetadataTypesConfig config)
        {
            const string wildCard = ".*";

            if (config.IncludeTypes == null)
                return null;

            var typesToExpand = config.IncludeTypes
                .Where(s => s.Length > 2 && s.EndsWith(wildCard))
                .Map(s => s.Substring(0, s.Length - 2));

            if (typesToExpand.Count == 0)
                return config.IncludeTypes;

            // From IncludeTypes get the corresponding MetadataTypes
            var includedMetadataTypes = metadata.Operations
                .Select(o => o.Request)
                .Where(t => typesToExpand.Contains(t.Name))
                .ToList();

            var includeSet = includedMetadataTypes
                .Where(x => x.ReturnMarkerTypeName != null)
                .Select(x => x.ReturnMarkerTypeName.Name)
                .ToHashSet();

            var includedResponses = metadata.Operations
                .Where(t => typesToExpand.Contains(t.Request.Name) && t.Response != null)
                .Select(o => o.Response)
                .ToList();
            includedResponses.ForEach(x => includeSet.Add(x.Name));

            var returnTypesForInclude = metadata.Operations
                .Where(x => x.Response != null && includeSet.Contains(x.Response.Name))
                .Map(x => x.Response);

            // GetReferencedTypes for both request + response objects
            var referenceTypes = includedMetadataTypes
                .Union(returnTypesForInclude)
                .Where(x => x != null)
                .SelectMany(x => x.GetReferencedTypeNames());

            return referenceTypes
                .Union(config.IncludeTypes)
                .Union(typesToExpand)
                .Union(returnTypesForInclude.Select(x => x.Name))
                .Distinct()
                .ToList();
        }

        public static void RemoveIgnoredTypes(this MetadataTypes metadata, MetadataTypesConfig config)
        {
            var includeList = GetIncludeList(metadata, config);

            metadata.Types.RemoveAll(x => x.IgnoreType(config, includeList));
            metadata.Operations.RemoveAll(x => x.Request.IgnoreType(config, includeList));
            metadata.Operations.Each(x => {
                if (x.Response != null && x.Response.IgnoreType(config, includeList))
                {
                    x.Response = null;
                }
            });
        }

 public CSharpGenerator(MetadataTypesConfig config)
 {
     Config = config;
 }

        public static string GetTypeName(this MetadataPropertyType prop, MetadataTypesConfig config, List<MetadataType> allTypes)
        {
            if (prop.IsValueType != true || prop.IsEnum == true)
                return prop.Type;

            if (prop.IsSystemType == true)
            {
                if (prop.Type != "Nullable`1" || prop.GenericArgs?.Length != 1)
                    return prop.Type;

                if (config.ExportValueTypes)
                    return prop.Type;

                // Find out if the ValueType is not a SystemType or Enum by looking if this Info is declared in another prop
                var genericArg = prop.GenericArgs[0];
                var typeInfo = allTypes.Where(x => x.Properties != null)
                    .SelectMany(x => x.Properties)
                    .FirstOrDefault(x => x.Type == genericArg);

                return typeInfo != null && typeInfo.IsSystemType != true && typeInfo.IsEnum != true
                    ? "String"
                    : prop.Type;
            }

            //Whether or not to emit the Struct Type Name, info: https://github.com/ServiceStack/Issues/issues/503#issuecomment-262133343
            return config.ExportValueTypes
                ? prop.Type
                : "String";
        }