private static GeneratorOutput GenerateEnum(Spec spec, string @enum)
        {
            var targetInfo         = spec.Targets[Constants.TypeScriptTarget];
            var enumFileName       = TypeScriptFileUtilities.GetFileName(@enum, targetInfo.AppendGeneratedExtension);
            var enumMembers        = spec.Enums[@enum];
            var normalizedEnumName = SpecFunctions.ToPascalCase(@enum);
            var members            = new List <TypeScriptEnumMember>(enumMembers.Count);

            for (int i = 0; i < enumMembers.Count; i++)
            {
                members.Add(GenerateEnumMember(enumMembers[i]));
            }

            return(new GeneratorOutput
            {
                Path = Path.Combine(targetInfo.Path, enumFileName + "." + Constants.TypeScriptExtension),
                GenerationRoot = new TypeScriptFile
                {
                    Contents = new List <TypeScriptDeclarationOrStatement>
                    {
                        new TypeScriptEnum
                        {
                            Name = normalizedEnumName,
                            Members = members
                        },
                        new TypeScriptExportStatement {
                            IsDefault = true, Object = normalizedEnumName
                        }
                    }
                }
            });
        }
        public IEnumerable <GeneratorOutput> GenerateOutputs(Spec spec)
        {
            var targetInfo     = spec.Targets[Constants.TypeScriptTarget];
            var barrelContents = new List <TypeScriptDeclarationOrStatement>();
            var typeCount      = spec.Enums.Count + spec.Entities.Count;

            if (typeCount == 0)
            {
                return(Enumerable.Empty <GeneratorOutput>());
            }

            var result = new GeneratorOutput[typeCount + 1];
            var index  = 0;

            foreach (var @enum in spec.Enums)
            {
                var enumOutput = GenerateEnum(spec, @enum.Key);
                result[index++] = enumOutput;
                barrelContents.Add(new TypeScriptReExportStatement {
                    FileName = Path.GetFileNameWithoutExtension(enumOutput.Path)
                });
            }

            foreach (var entity in spec.Entities)
            {
                var entityFileName = TypeScriptFileUtilities.GetFileName(entity.Key, targetInfo.AppendGeneratedExtension);
                result[index++] =
                    new GeneratorOutput
                {
                    Path           = Path.Combine(targetInfo.Path, entityFileName + "." + Constants.TypeScriptExtension),
                    GenerationRoot = GenerateEntity(spec, entity.Key)
                };

                barrelContents.Add(new TypeScriptReExportStatement {
                    FileName = entityFileName
                });
            }

            result[index++] =
                new GeneratorOutput
            {
                // index.ts must always have '.ts' extension. '.generated.ts' is not applicable here
                // because it won't be recognized by module definition
                Path           = Path.Combine(targetInfo.Path, Path.ChangeExtension("index", Constants.TypeScriptExtension)),
                GenerationRoot = new TypeScriptFile {
                    Contents = barrelContents
                }
            };

            return(result);
        }
        public static IEnumerable <TypeScriptDeclarationOrStatement> GetImportStatementsForEntity(Spec spec, string entityName)
        {
            var targetInfo         = spec.Targets[Constants.TypeScriptTarget];
            var enumDependencies   = spec.GetDirectEnumDependencies(Constants.TypeScriptTarget, entityName);
            var entityDependencies = spec.GetDirectEntityDependencies(Constants.TypeScriptTarget, entityName);

            foreach (var @enum in enumDependencies)
            {
                yield return(new TypeScriptImportStatement {
                    ObjectName = SpecFunctions.ToPascalCase(@enum), File = TypeScriptFileUtilities.GetFileName(@enum, targetInfo.AppendGeneratedExtension)
                });
            }

            foreach (var entity in entityDependencies)
            {
                yield return(new TypeScriptImportStatement {
                    ObjectName = SpecFunctions.ToPascalCase(entity), File = TypeScriptFileUtilities.GetFileName(entity, targetInfo.AppendGeneratedExtension)
                });
            }
        }