diff --git a/README.md b/README.md
index d7f039e..a3f40e3 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,4 @@
-
-# Decodificador METAR e TAF em C#
+# METAR and TAF Decoder for C#
[](https://github.com/afonsoft/metar-decoder/blob/main/LICENSE)
[](https://sonarcloud.io/dashboard?id=afonsoft_metar-decoder)
@@ -11,103 +10,126 @@
[](https://sonarcloud.io/summary/new_code?id=afonsoft_metar-decoder)
[](https://github.com/afonsoft/metar-decoder/releases)
-## Descrição do Projeto
+> **[Leia em Portugues (pt-BR)](README.pt-br.md)**
-Este repositório contém uma biblioteca .NET para decodificar strings METAR (Meteorological Aerodrome Report) e TAF (Terminal Aerodrome Forecast). Ambas as bibliotecas são compatíveis com .NET Standard 2.0, .NET 6.0 e .NET 8.0, permitindo sua utilização em projetos .NET Core e .NET Framework.
+## Documentation / Documentacao
-### Decodificador METAR
+- **[Usage Guide (English)](docs/en-US/usage-guide.md)** - Complete guide with examples
+- **[API Reference (English)](docs/en-US/api-reference.md)** - All classes, properties and methods
+- **[Guia de Uso (Portugues)](docs/pt-BR/guia-de-uso.md)** - Guia completo com exemplos
+- **[Referencia da API (Portugues)](docs/pt-BR/referencia-api.md)** - Todas as classes, propriedades e metodos
-O decodificador METAR é uma ferramenta robusta para analisar e interpretar relatórios meteorológicos METAR brutos. METAR é um formato padronizado pela Organização da Aviação Civil Internacional (ICAO) para relatar informações meteorológicas, amplamente utilizado por pilotos e meteorologistas para previsão do tempo. A biblioteca processa a string METAR e a transforma em um objeto `DecodedMetar` estruturado, que contém todas as propriedades meteorológicas decodificadas, como vento de superfície, visibilidade, alcance visual da pista, tempo presente, camadas de nuvens, temperatura do ar, temperatura do ponto de orvalho e pressão.
+## Project Description
-### Decodificador TAF
+This repository contains a .NET library for decoding METAR (Meteorological Aerodrome Report) and TAF (Terminal Aerodrome Forecast) strings. Both libraries are compatible with .NET Standard 2.0, .NET 8.0, .NET 10.0, and .NET Framework 4.8, allowing use in .NET Core and .NET Framework projects.
-O decodificador TAF é uma biblioteca .NET para decodificar mensagens TAF (Terminal Aerodrome Forecast), que são previsões meteorológicas para aeródromos. Assim como o METAR, o formato TAF é altamente padronizado pela ICAO e é crucial para o planejamento de voos. A biblioteca analisa a string TAF e a converte em um objeto `DecodedTaf`, que inclui informações como tipo de relatório, código ICAO, data e hora de origem, período de previsão, vento de superfície, visibilidade, fenômenos meteorológicos, camadas de nuvens e temperaturas mínima e máxima. O decodificador TAF também é capaz de interpretar "evoluções" (mudanças na previsão ao longo do tempo), como `BECMG` (tornando-se) e `TEMPO` (temporário).
+### METAR Decoder
-Ambos os decodificadores oferecem modos de análise "estrito" e "não estrito". No modo não estrito, a análise continua mesmo que sejam encontrados erros de formato, e as exceções são registradas na propriedade `DecodingExceptions` do objeto decodificado. Valores numéricos com unidades (como velocidade, distância e pressão) são encapsulados em objetos `Value`, permitindo conversões de unidade flexíveis.
+The METAR decoder is a robust tool for parsing and interpreting raw METAR weather reports. METAR is a standardized format by the International Civil Aviation Organization (ICAO) for reporting weather information, widely used by pilots and meteorologists. The library processes METAR strings and transforms them into a structured `DecodedMetar` object containing all decoded meteorological properties such as surface wind, visibility, runway visual range, present weather, cloud layers, air temperature, dew point temperature, and pressure.
-Este projeto é amplamente baseado nas implementações de [SafranCassiopee/csharp-metar-decoder](https://github.com/SafranCassiopee/csharp-metar-decoder) e [SafranCassiopee/csharp-taf-decoder](https://github.com/SafranCassiopee/csharp-taf-decoder).
+### TAF Decoder
-## Status do Projeto
+The TAF decoder is a .NET library for decoding TAF (Terminal Aerodrome Forecast) messages, which are weather forecasts for aerodromes. Like METAR, the TAF format is highly standardized by ICAO and is crucial for flight planning. The library parses TAF strings and converts them into a `DecodedTaf` object, which includes information such as report type, ICAO code, origin date and time, forecast period, surface wind, visibility, weather phenomena, cloud layers, and minimum/maximum temperatures. The TAF decoder can also interpret "evolutions" (forecast changes over time), such as `BECMG` (becoming) and `TEMPO` (temporary).
-🚀 **Ativo e em Desenvolvimento** - Com pipelines modernos de CI/CD
+Both decoders offer "strict" and "non-strict" parsing modes. In non-strict mode, parsing continues even when format errors are encountered, and exceptions are logged in the `DecodingExceptions` property. Numeric values with units (such as speed, distance, and pressure) are encapsulated in `Value` objects, allowing flexible unit conversions.
-### ✨ Novidades Recentes
+This project is largely based on the implementations of [SafranCassiopee/csharp-metar-decoder](https://github.com/SafranCassiopee/csharp-metar-decoder) and [SafranCassiopee/csharp-taf-decoder](https://github.com/SafranCassiopee/csharp-taf-decoder).
-- **🧪 Cobertura de Testes ~98%** - 421 testes unitários com cobertura abrangente
-- **🐛 Fix DatetimeChunkDecoder** - Correção de bug de rollover de dia/mês inválido
-- **🆕 RTD Support** - Suporte completo para TAF reports com "Report Delayed"
-- **🔧 .NET 10.0** - Compatibilidade com a versão mais recente do .NET
-- **🚀 Workflows Modernos** - CI/CD automatizado com GitHub Actions
+## Project Status
-## 🔄 CI/CD e Workflows
+**Active and Under Development** - With modern CI/CD pipelines
-Este projeto utiliza pipelines modernos de GitHub Actions para garantir qualidade e automação:
+### Recent Changes
-### 📋 Workflows Disponíveis
+- **Test Coverage ~98%** - 421 unit tests with comprehensive coverage
+- **DatetimeChunkDecoder Fix** - Day/month rollover bug fix
+- **RTD Support** - Full support for TAF reports with "Report Delayed"
+- **.NET 10.0** - Compatibility with the latest .NET version
+- **Modern Workflows** - Automated CI/CD with GitHub Actions
-- **🚀 CI Build & Test** (`ci-build-test.yml`) - Pipeline completo de integração contínua
- - Build automatizado para .NET 8.0
- - Testes unitários com coverage
- - Security scans e performance tests
- - Criação automática de PRs
+## CI/CD and Workflows
-- **📊 Code Quality** (`code-quality.yml`) - Análise de qualidade de código
+This project uses modern GitHub Actions pipelines to ensure quality and automation:
+
+### Available Workflows
+
+- **CI Build & Test** (`ci-build-test.yml`) - Complete continuous integration pipeline
+ - Automated build for .NET 8.0
+ - Unit tests with coverage
+ - Security scans and performance tests
+ - Automatic PR creation
+
+- **Code Quality** (`code-quality.yml`) - Code quality analysis
- Qodana analysis
- SonarQube integration
- Snyk security scanning
- - Métricas de qualidade
+ - Quality metrics
-- **🔒 Security Scan** (`security-scan.yml`) - Scans de segurança
+- **Security Scan** (`security-scan.yml`) - Security scans
- CodeQL analysis
- Vulnerability scanning
- - Scans semanais automáticos
+ - Automatic weekly scans
-- **🚀 Publish NuGet** (`publish-all.yml`) - Publicação automatizada
- - Publicação para GitHub Packages
- - Publicação para NuGet.org
- - Criação automática de releases
+- **Publish NuGet** (`publish-all.yml`) - Automated publishing
+ - Publishing to GitHub Packages
+ - Publishing to NuGet.org
+ - Automatic release creation
-- **🔄 Auto Dependency Update** (`auto-pr-from-main.yml`) - Atualização automática
- - Verificação de dependências desatualizadas
- - Updates de segurança automáticos
- - PRs automáticos para updates
+- **Auto Dependency Update** (`auto-pr-from-main.yml`) - Automatic updates
+ - Check for outdated dependencies
+ - Automatic security updates
+ - Automatic PRs for updates
-### 🏆 Badges de Qualidade
+### Quality Badges
[](https://github.com/afonsoft/metar-decoder/actions/workflows/ci-build-test.yml)
[](https://github.com/afonsoft/metar-decoder/actions/workflows/code-quality.yml)
[](https://github.com/afonsoft/metar-decoder/actions/workflows/security-scan.yml)
-## Pacotes NuGet
+## NuGet Packages
-Os pacotes NuGet oficiais estão disponíveis para fácil integração em seus projetos:
+Official NuGet packages are available for easy integration into your projects:
-| Pacote | Versão | NuGet |
-| ------ | ------ | ------ |
-| [Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder/) | 1.0.8 | [](https://badge.fury.io/nu/Metar.Decoder) |
-| [Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder/) | 1.0.6 | [](https://badge.fury.io/nu/Taf.Decoder) |
+| Package | Version | NuGet |
+| ------- | ------- | ----- |
+| [Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder/) | 1.0.9 | [](https://badge.fury.io/nu/Metar.Decoder) |
+| [Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder/) | 1.0.7 | [](https://badge.fury.io/nu/Taf.Decoder) |
-## Pré-requisitos
+## Prerequisites
-Esta biblioteca é compatível com múltiplas versões do .NET:
+This library is compatible with multiple .NET versions:
-- **.NET Standard 2.0** - Compatibilidade máxima
-- **.NET 8.0** - LTS recomendado
-- **.NET 10.0** - Versão mais recente
-- **.NET Framework 4.8** - Suporte legado
+- **.NET Standard 2.0** - Maximum compatibility
+- **.NET 8.0** - Recommended LTS
+- **.NET 10.0** - Latest version
+- **.NET Framework 4.8** - Legacy support
-## Como Instalar
+## Installation
-### Com nuget.exe (recomendado)
+### NuGet Package Manager (recommended)
-No Console do Gerenciador de Pacotes no Visual Studio:
+In the Package Manager Console in Visual Studio:
```shell
-nuget install Metar.Decoder
-nuget install Taf.Decoder
+Install-Package Metar.Decoder
+Install-Package Taf.Decoder
```
-Adicione uma referência à biblioteca e, em seguida, adicione as seguintes diretivas `using`:
+### .NET CLI
+
+```shell
+dotnet add package Metar.Decoder
+dotnet add package Taf.Decoder
+```
+
+### PackageReference
+
+```xml
+
+
+```
+
+Add a reference to the library and then add the following `using` directives:
```csharp
using Metar.Decoder;
@@ -119,425 +141,330 @@ using Taf.Decoder;
using Taf.Decoder.Entity;
```
-### Manualmente
-
-Baixe a versão mais recente em [GitHub Releases](https://github.com/afonsoft/metar-decoder/releases).
+### Manual Installation
-Extraia o conteúdo onde desejar em seu projeto. A biblioteca em si está no diretório `Metar.Decoder/` e `Taf.Decoder/`; os outros diretórios não são obrigatórios para o funcionamento da biblioteca.
+Download the latest version from [GitHub Releases](https://github.com/afonsoft/metar-decoder/releases).
-Adicione os projetos `Metar.Decoder` e `Taf.Decoder` à sua solução e, em seguida, adicione uma referência a eles em seu próprio projeto. Finalmente, adicione as mesmas diretivas `using` mencionadas acima.
+Extract the contents wherever you want in your project. The library itself is in the `Metar.Decoder/` and `Taf.Decoder/` directories; the other directories are not required for the library to function.
-## Como Usar
+## Quick Start
-### Decodificador METAR
+### METAR Decoder
-Instancie o decodificador e execute-o em uma string METAR. O objeto retornado é um objeto `DecodedMetar` do qual você pode recuperar todas as propriedades meteorológicas decodificadas.
+Instantiate the decoder and run it on a METAR string. The returned object is a `DecodedMetar` object from which you can retrieve all decoded meteorological properties.
-Todos os valores que possuem uma unidade são baseados no objeto `Value`, que fornece as propriedades `ActualValue` e `ActualUnit`.
+All values that have a unit are based on the `Value` object, which provides the `ActualValue` and `ActualUnit` properties.
-Consulte a classe [`DecodedMetar`](src/Metar.Decoder/Entity/DecodedMetar.cs) para a estrutura do objeto resultante.
+See the [`DecodedMetar`](src/Metar.Decoder/Entity/DecodedMetar.cs) class for the resulting object structure.
```csharp
var d = MetarDecoder.ParseWithMode("METAR LFPO 231027Z AUTO 24004G09MPS 2500 1000NW R32/0400 R08C/0004D +FZRA VCSN //FEW015 17/10 Q1009 REFZRA WS R03");
-// Informações de contexto
-Console.WriteLine($"Válido: {d.IsValid}"); // true
-Console.WriteLine($"METAR Bruto: {d.RawMetar}"); // "METAR LFPO 231027Z AUTO 24004G09MPS 2500 1000NW R32/0400 R08C/0004D +FZRA VCSN //FEW015 17/10 Q1009 REFZRA WS R03"
-Console.WriteLine($"Tipo: {d.Type}"); // MetarType.METAR
+// Context information
+Console.WriteLine($"Valid: {d.IsValid}"); // true
+Console.WriteLine($"Raw METAR: {d.RawMetar}");
+Console.WriteLine($"Type: {d.Type}"); // MetarType.METAR
Console.WriteLine($"ICAO: {d.ICAO}"); // "LFPO"
-Console.WriteLine($"Dia: {d.Day}"); // 23
-Console.WriteLine($"Hora: {d.Time}"); // "10:27 UTC"
+Console.WriteLine($"Day: {d.Day}"); // 23
+Console.WriteLine($"Time: {d.Time}"); // "10:27 UTC"
Console.WriteLine($"Status: {d.Status}"); // "AUTO"
-// Vento de superfície
-var sw = d.SurfaceWind; // Objeto SurfaceWind
-Console.WriteLine($"Vento - Direção Média: {sw.MeanDirection.ActualValue}"); // 240
-Console.WriteLine($"Vento - Velocidade Média: {sw.MeanSpeed.ActualValue} {sw.MeanSpeed.ActualUnit}"); // 4 MeterPerSecond
-Console.WriteLine($"Vento - Variações de Velocidade: {sw.SpeedVariations.ActualValue}"); // 9
-
-// Visibilidade
-var v = d.Visibility; // Objeto Visibility
-Console.WriteLine($"Visibilidade Prevalecente: {v.PrevailingVisibility.ActualValue} {v.PrevailingVisibility.ActualUnit}"); // 2500 Meter
-Console.WriteLine($"Visibilidade Mínima: {v.MinimumVisibility.ActualValue}"); // 1000
-Console.WriteLine($"Direção da Visibilidade Mínima: {v.MinimumVisibilityDirection}"); // "NW"
-Console.WriteLine($"NDV: {v.NDV}"); // false
-
-// Alcance Visual da Pista (RVR)
-var rvr = d.RunwaysVisualRange; // Array de RunwayVisualRange
-Console.WriteLine($"RVR Pista 32: {rvr[0].VisualRange.ActualValue}"); // 400
-Console.WriteLine($"RVR Pista 08C: {rvr[1].VisualRange.ActualValue}"); // 4
-
-// Tempo Presente
-var pw = d.PresentWeather; // Array de WeatherPhenomenon
-Console.WriteLine($"Tempo Presente 1: {pw[0].IntensityProximity}{string.Join("", pw[0].Characteristics)}{string.Join("", pw[0].Types)}"); // "+FZRA"
-Console.WriteLine($"Tempo Presente 2: {pw[1].IntensityProximity}{string.Join("", pw[1].Types)}"); // "VCSN"
-
-// Nuvens
-var cld = d.Clouds; // Array de CloudLayer
-Console.WriteLine($"Nuvens - Quantidade: {cld[0].Amount}"); // FEW
-Console.WriteLine($"Nuvens - Altura da Base: {cld[0].BaseHeight.ActualValue} {cld[0].BaseHeight.ActualUnit}"); // 1500 Feet
-
-// Temperatura
-Console.WriteLine($"Temperatura do Ar: {d.AirTemperature.ActualValue} {d.AirTemperature.ActualUnit}"); // 17 DegreeCelsius
-Console.WriteLine($"Temperatura do Ponto de Orvalho: {d.DewPointTemperature.ActualValue}"); // 10
-
-// Pressão
-Console.WriteLine($"Pressão: {d.Pressure.ActualValue} {d.Pressure.ActualUnit}"); // 1009 HectoPascal
-
-// Tempo Recente
+// Surface Wind
+var sw = d.SurfaceWind;
+Console.WriteLine($"Wind - Mean Direction: {sw.MeanDirection.ActualValue}"); // 240
+Console.WriteLine($"Wind - Mean Speed: {sw.MeanSpeed.ActualValue} {sw.MeanSpeed.ActualUnit}"); // 4 MeterPerSecond
+Console.WriteLine($"Wind - Speed Variations: {sw.SpeedVariations.ActualValue}"); // 9
+
+// Visibility
+var v = d.Visibility;
+Console.WriteLine($"Prevailing Visibility: {v.PrevailingVisibility.ActualValue} {v.PrevailingVisibility.ActualUnit}"); // 2500 Meter
+Console.WriteLine($"Minimum Visibility: {v.MinimumVisibility.ActualValue}"); // 1000
+Console.WriteLine($"Minimum Visibility Direction: {v.MinimumVisibilityDirection}"); // "NW"
+
+// Runway Visual Range (RVR)
+var rvr = d.RunwaysVisualRange;
+Console.WriteLine($"RVR Runway 32: {rvr[0].VisualRange.ActualValue}"); // 400
+Console.WriteLine($"RVR Runway 08C: {rvr[1].VisualRange.ActualValue}"); // 4
+
+// Present Weather
+var pw = d.PresentWeather;
+Console.WriteLine($"Present Weather 1: {pw[0].IntensityProximity}{string.Join("", pw[0].Characteristics)}{string.Join("", pw[0].Types)}"); // "+FZRA"
+
+// Clouds
+var cld = d.Clouds;
+Console.WriteLine($"Clouds - Amount: {cld[0].Amount}"); // FEW
+Console.WriteLine($"Clouds - Base Height: {cld[0].BaseHeight.ActualValue} {cld[0].BaseHeight.ActualUnit}"); // 1500 Feet
+
+// Temperature
+Console.WriteLine($"Air Temperature: {d.AirTemperature.ActualValue} {d.AirTemperature.ActualUnit}"); // 17 DegreeCelsius
+Console.WriteLine($"Dew Point Temperature: {d.DewPointTemperature.ActualValue}"); // 10
+
+// Pressure
+Console.WriteLine($"Pressure: {d.Pressure.ActualValue} {d.Pressure.ActualUnit}"); // 1009 HectoPascal
+
+// Recent Weather
var rw = d.RecentWeather;
-Console.WriteLine($"Tempo Recente - Características: {rw.Characteristics}"); // "FZ"
-Console.WriteLine($"Tempo Recente - Tipos: {string.Join(", ", rw.Types)}"); // "RA"
+Console.WriteLine($"Recent Weather - Characteristics: {rw.Characteristics}"); // "FZ"
+Console.WriteLine($"Recent Weather - Types: {string.Join(", ", rw.Types)}"); // "RA"
-// Tesouras de Vento (Windshear)
-Console.WriteLine($"Windshear em Todas as Pistas: {d.WindshearAllRunways}"); // null (ou true/false se presente)
-Console.WriteLine($"Windshear em Pistas Específicas: {string.Join(", ", d.WindshearRunways)}"); // "03"
+// Windshear
+Console.WriteLine($"Windshear All Runways: {d.WindshearAllRunways}");
+Console.WriteLine($"Windshear Runways: {string.Join(", ", d.WindshearRunways)}"); // "03"
```
-### Decodificador TAF
+### TAF Decoder
-Instancie o decodificador e execute-o em uma string TAF. O objeto retornado é um objeto `DecodedTaf` do qual você pode recuperar todas as propriedades de previsão decodificadas.
+Instantiate the decoder and run it on a TAF string. The returned object is a `DecodedTaf` object from which you can retrieve all decoded forecast properties.
-Consulte a classe [`DecodedTaf`](src/Taf.Decoder/Entity/DecodedTaf.cs) para a estrutura do objeto resultante.
+See the [`DecodedTaf`](src/Taf.Decoder/Entity/DecodedTaf.cs) class for the resulting object structure.
-#### 🆕 Suporte a RTD (Report Delayed)
+#### RTD Support (Report Delayed)
-O decodificador agora suporta relatórios TAF marcados como "RTD" (Report Delayed), que indicam relatórios atrasados:
+The decoder now supports TAF reports marked as "RTD" (Report Delayed), which indicate delayed reports:
```csharp
-// Exemplo de TAF RTD (Report Delayed)
string rtdTaf = "RTD EKEB 190416Z 1905/1912 13006KT 0200 FZFG BKN001 TEMPO 1905/1907 2000 BR BKN003 BECMG 1907/1909 9000 NSW FEW002 PROB40 1909/1911 0400 FZFG BKN002=";
var decoder = new TafDecoder();
var result = decoder.Parse(rtdTaf);
-Console.WriteLine($"Tipo: {result.Type}"); // Saída: RTD
-Console.WriteLine($"ICAO: {result.Icao}"); // Saída: EKEB
-Console.WriteLine($"Válido: {result.IsValid}"); // Saída: True
+Console.WriteLine($"Type: {result.Type}"); // Output: RTD
+Console.WriteLine($"ICAO: {result.Icao}"); // Output: EKEB
+Console.WriteLine($"Valid: {result.IsValid}"); // Output: True
```
-#### Exemplo Completo de Uso
+#### Full TAF Usage Example
```csharp
var d = TafDecoder.ParseWithMode("TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025 TX12/0816Z TN04/0807Z");
-// Informações de contexto
-Console.WriteLine($"Válido: {d.IsValid}");
-Console.WriteLine($"TAF Bruto: {d.RawTaf}");
-Console.WriteLine($"Tipo: {d.Type}"); // Pode ser: TAF, TAFAMD, TAFCOR, RTD
+// Context information
+Console.WriteLine($"Valid: {d.IsValid}");
+Console.WriteLine($"Raw TAF: {d.RawTaf}");
+Console.WriteLine($"Type: {d.Type}"); // Can be: TAF, TAFAMD, TAFCOR, RTD
Console.WriteLine($"ICAO: {d.Icao}");
-Console.WriteLine($"Dia: {d.Day}");
-Console.WriteLine($"Hora: {d.Time}");
+Console.WriteLine($"Day: {d.Day}");
+Console.WriteLine($"Time: {d.Time}");
-// Período de Previsão
+// Forecast Period
var fp = d.ForecastPeriod;
-Console.WriteLine($"Período de Previsão - Do Dia: {fp.FromDay}");
-Console.WriteLine($"Período de Previsão - Da Hora: {fp.FromHour}");
-Console.WriteLine($"Período de Previsão - Ao Dia: {fp.ToDay}");
-Console.WriteLine($"Período de Previsão - À Hora: {fp.ToHour}");
+Console.WriteLine($"Forecast Period - From Day: {fp.FromDay}");
+Console.WriteLine($"Forecast Period - From Hour: {fp.FromHour}");
+Console.WriteLine($"Forecast Period - To Day: {fp.ToDay}");
+Console.WriteLine($"Forecast Period - To Hour: {fp.ToHour}");
-// Vento de superfície
+// Surface Wind
var swTaf = d.SurfaceWind;
-Console.WriteLine($"TAF Vento - Direção Média: {swTaf.MeanDirection.ActualValue}");
-Console.WriteLine($"TAF Vento - Velocidade Média: {swTaf.MeanSpeed.ActualValue} {swTaf.MeanSpeed.ActualUnit}");
+Console.WriteLine($"TAF Wind - Mean Direction: {swTaf.MeanDirection.ActualValue}");
+Console.WriteLine($"TAF Wind - Mean Speed: {swTaf.MeanSpeed.ActualValue} {swTaf.MeanSpeed.ActualUnit}");
-// Visibilidade
+// Visibility
var vTaf = d.Visibility;
-Console.WriteLine($"TAF Visibilidade Prevalecente: {vTaf.ActualVisibility.ActualValue} {vTaf.ActualVisibility.ActualUnit}");
+Console.WriteLine($"TAF Prevailing Visibility: {vTaf.ActualVisibility.ActualValue} {vTaf.ActualVisibility.ActualUnit}");
Console.WriteLine($"TAF CAVOK: {d.Cavok}");
-// Nuvens
+// Clouds
var cldTaf = d.Clouds;
if (cldTaf.Count > 0)
{
- Console.WriteLine($"TAF Nuvens - Quantidade: {cldTaf[0].Amount}");
- Console.WriteLine($"TAF Nuvens - Altura da Base: {cldTaf[0].BaseHeight.ActualValue} {cldTaf[0].BaseHeight.ActualUnit}");
+ Console.WriteLine($"TAF Clouds - Amount: {cldTaf[0].Amount}");
+ Console.WriteLine($"TAF Clouds - Base Height: {cldTaf[0].BaseHeight.ActualValue} {cldTaf[0].BaseHeight.ActualUnit}");
}
-// Temperaturas (Mínima e Máxima)
+// Temperatures (Minimum and Maximum)
var minTemp = d.MinimumTemperature;
if (minTemp != null)
{
- Console.WriteLine($"Temperatura Mínima: {minTemp.TemperatureValue.ActualValue} {minTemp.TemperatureValue.ActualUnit} no dia {minTemp.Day} às {minTemp.Hour}Z");
+ Console.WriteLine($"Minimum Temperature: {minTemp.TemperatureValue.ActualValue} {minTemp.TemperatureValue.ActualUnit} on day {minTemp.Day} at {minTemp.Hour}Z");
}
var maxTemp = d.MaximumTemperature;
if (maxTemp != null)
{
- Console.WriteLine($"Temperatura Máxima: {maxTemp.TemperatureValue.ActualValue} {maxTemp.TemperatureValue.ActualUnit} no dia {maxTemp.Day} às {maxTemp.Hour}Z");
+ Console.WriteLine($"Maximum Temperature: {maxTemp.TemperatureValue.ActualValue} {maxTemp.TemperatureValue.ActualUnit} on day {maxTemp.Day} at {maxTemp.Hour}Z");
}
-// Fenômenos Meteorológicos
+// Weather Phenomena
var wpTaf = d.WeatherPhenomenons;
if (wpTaf.Count > 0)
{
- Console.WriteLine($"TAF Fenômeno Meteorológico: {wpTaf[0].IntensityProximity}{string.Join("", wpTaf[0].Characteristics)}{string.Join("", wpTaf[0].Types)}");
+ Console.WriteLine($"TAF Weather Phenomenon: {wpTaf[0].IntensityProximity}{string.Join("", wpTaf[0].Characteristics)}{string.Join("", wpTaf[0].Types)}");
}
-// Evoluções (BECMG, TEMPO, etc.)
+// Evolutions (BECMG, TEMPO, etc.)
foreach (var evolution in d.Evolutions)
{
- Console.WriteLine($"Evolução: {evolution.Type} de {evolution.FromDay}{evolution.FromHour}Z a {evolution.ToDay}{evolution.ToHour}Z");
- // Acessar propriedades específicas da evolução, como vento, visibilidade, nuvens, etc.
+ Console.WriteLine($"Evolution: {evolution.Type} from {evolution.FromDay}{evolution.FromHour}Z to {evolution.ToDay}{evolution.ToHour}Z");
}
```
-#### Tipos de Relatório TAF Suportados
+#### Supported TAF Report Types
-| Tipo | Descrição | Exemplo |
-|------|-----------|---------|
-| `TAF` | Relatório TAF padrão | `TAF LEMD 080500Z...` |
-| `TAFAMD` | Relatório TAF amendado | `TAF AMD LEMD 080500Z...` |
-| `TAFCOR` | Relatório TAF corrigido | `TAF COR LEMD 080500Z...` |
-| `RTD` | Relatório TAF atrasado | `RTD EKEB 190416Z...` |
+| Type | Description | Example |
+|------|-------------|---------|
+| `TAF` | Standard TAF report | `TAF LEMD 080500Z...` |
+| `TAFAMD` | Amended TAF report | `TAF AMD LEMD 080500Z...` |
+| `TAFCOR` | Corrected TAF report | `TAF COR LEMD 080500Z...` |
+| `RTD` | Delayed TAF report | `RTD EKEB 190416Z...` |
-### Sobre Objetos de Valor (`Value`)
+### About Value Objects
-No exemplo acima, assume-se que todos os parâmetros solicitados estão disponíveis. No mundo real, alguns campos não são obrigatórios, portanto, é importante verificar se o objeto `Value` (contendo tanto o valor quanto sua unidade) não é nulo antes de usá-lo. O que você faz caso seja nulo fica a seu critério.
+In the example above, it is assumed that all requested parameters are available. In the real world, some fields are not mandatory, so it is important to check if the `Value` object (containing both the value and its unit) is not null before using it.
-Aqui está um exemplo:
+Here is an example:
```csharp
-// verifica se o ponto de orvalho não é nulo e atribui um valor padrão se for
var dew_point = d.DewPointTemperature;
if (dew_point == null)
{
dew_point = new Value(999, Value.Unit.DegreeCelsius);
}
-// o objeto dew_point agora pode ser acessado com segurança
Console.WriteLine(dew_point.ActualValue);
Console.WriteLine(dew_point.ActualUnit);
```
-Os objetos `Value` também contêm sua unidade, que pode ser acessada com a propriedade `ActualUnit`. Ao acessar a propriedade `ActualValue`, você obterá o valor nesta unidade.
+`Value` objects also contain their unit, which can be accessed with the `ActualUnit` property. When accessing the `ActualValue` property, you get the value in this unit.
-Se você deseja obter o valor diretamente em outra unidade, pode chamar `GetConvertedValue(unit)`. Os valores suportados são velocidade, distância e pressão.
+If you want to get the value directly in another unit, you can call `GetConvertedValue(unit)`. Supported values are speed, distance, and pressure.
-Aqui estão todas as unidades disponíveis para conversão:
+Here are all available units for conversion:
```csharp
-// unidades de velocidade:
+// Speed units:
// Value.Unit.MeterPerSecond
// Value.Unit.KilometerPerHour
// Value.Unit.Knot
-// unidades de distância:
+// Distance units:
// Value.Unit.Meter
// Value.Unit.Feet
// Value.Unit.StatuteMile
-// unidades de pressão:
+// Pressure units:
// Value.Unit.HectoPascal
// Value.Unit.MercuryInch
-// usar conversão em tempo real
+// Using real-time conversion
var distance_in_sm = visibility.GetConvertedValue(Value.Unit.StatuteMile);
var speed_kph = speed.GetConvertedValue(Value.Unit.KilometerPerHour);
```
-### Sobre Erros de Análise
+### About Parsing Errors
-Quando um formato inesperado é encontrado para uma parte do METAR/TAF, o erro de análise é registrado no próprio objeto `DecodedMetar` ou `DecodedTaf`.
+When an unexpected format is found for a part of the METAR/TAF, the parsing error is logged in the `DecodedMetar` or `DecodedTaf` object itself.
-Todos os erros de análise para um METAR/TAF podem ser acessados através da propriedade `DecodingExceptions`.
+All parsing errors for a METAR/TAF can be accessed through the `DecodingExceptions` property.
-Por padrão, a análise continuará quando um formato incorreto for encontrado. No entanto, o analisador também oferece um modo "estrito" onde a análise para assim que uma não conformidade é detectada. O modo pode ser definido globalmente para um objeto `MetarDecoder`/`TafDecoder`, ou apenas uma vez, como você pode ver neste exemplo:
+By default, parsing will continue when an incorrect format is found. However, the parser also offers a "strict" mode where parsing stops as soon as a non-compliance is detected. The mode can be set globally for a `MetarDecoder`/`TafDecoder` object, or just once, as shown in this example:
```csharp
var decoder = new MetarDecoder();
-decoder.SetStrictParsing(true);
-// altera o modo de análise global para "estrito"
+// Change global parsing mode to "strict"
decoder.SetStrictParsing(true);
-// esta análise será feita no modo estrito
+// This parse will be done in strict mode
decoder.Parse("...");
-// mas esta ignorará o modo global e será feita no modo não estrito
+// But this will ignore the global mode and parse in non-strict mode
decoder.ParseNotStrict("...");
-// altera o modo de análise global para "não estrito"
+// Change global parsing mode to "non-strict"
decoder.SetStrictParsing(false);
-// esta análise será feita no modo não estrito
+// This parse will be done in non-strict mode
decoder.Parse("...");
-// mas esta ignorará o modo global e será feita no modo estrito
+// But this will ignore the global mode and parse in strict mode
decoder.ParseStrict("...");
```
-### Sobre Erros de Análise (Novamente)
+### About Parsing Errors (Advanced)
-No modo não estrito, é possível obter um erro de análise para um determinado decodificador de "chunk", enquanto ainda obtém as informações decodificadas para este "chunk" no final. Como isso é possível?
+In non-strict mode, it is possible to get a parsing error for a given chunk decoder while still getting the decoded information for that chunk. How is this possible?
-Isso ocorre porque o modo não estrito não apenas continua a decodificação onde há um erro, mas também tenta a análise novamente no "próximo chunk" (com base no separador de espaço em branco). No entanto, todos os erros na primeira tentativa permanecerão registrados, mesmo que a segunda tentativa tenha sido bem-sucedida.
+This happens because non-strict mode not only continues decoding where there is an error but also retries parsing on the "next chunk" (based on the whitespace separator). However, all errors from the first attempt will remain logged, even if the second attempt was successful.
-Por exemplo, se você tiver o "chunk" `AAA 12003KPH ...` fornecido ao decodificador de "chunk" `SurfaceWind`. Este decodificador falhará em `AAA`, tentará decodificar `12003KPH` e terá sucesso. A primeira exceção para o decodificador de vento de superfície será mantida, mas o objeto `SurfaceWind` será preenchido com algumas informações.
+For example, if you have the chunk `AAA 12003KPH ...` fed to the `SurfaceWind` chunk decoder, it will fail on `AAA`, then try to decode `12003KPH` and succeed. The first exception for the surface wind decoder will be kept, but the `SurfaceWind` object will be populated with some information.
-Tudo isso não se aplica ao modo estrito, pois a análise é interrompida no primeiro erro de análise neste caso.
+This does not apply to strict mode, as parsing is stopped at the first parsing error in that case.
-## 🤝 Como Contribuir
+## Contributing
-### Processo de Desenvolvimento
+### Development Process
-1. **Crie uma branch** a partir da `main`:
+1. **Create a branch** from `main`:
```bash
- git checkout -b feature/sua-feature
+ git checkout -b feature/your-feature
```
-2. **Faça suas alterações** seguindo as boas práticas
+2. **Make your changes** following best practices
-3. **Os workflows automáticos** serão executados:
- - 🚀 **CI Build & Test** - Valida seu código
- - 📊 **Code Quality** - Analisa qualidade
- - 🔒 **Security Scan** - Verifica segurança
+3. **Automated workflows** will run:
+ - **CI Build & Test** - Validates your code
+ - **Code Quality** - Analyzes quality
+ - **Security Scan** - Checks security
-4. **Pull Request Automático**: Se estiver em branches `feature/*`, `bug/*` ou `hotfix/*`, um PR será criado automaticamente para `main`
+4. **Automatic Pull Request**: If on `feature/*`, `bug/*`, or `hotfix/*` branches, a PR will be created automatically to `main`
-5. **Review e Merge**: Após aprovação, seu código será mergeado
+5. **Review and Merge**: After approval, your code will be merged
-### 🏗️ Estrutura do Repositório
+## Repository Structure
```
.
-├── CHANGELOG.md # Histórico de todas as mudanças notáveis no projeto.
-├── EAF.ico # Ícone do projeto.
-├── EAF.png # Imagem do projeto.
-├── LICENSE # Arquivo de licença do projeto.
-├── MetarDecoder.sln # Solução principal do Visual Studio para o projeto.
-├── README.md # Este arquivo de documentação do projeto.
-├── .github/ # Configurações do GitHub e workflows.
-│ ├── ISSUE_TEMPLATE.md # Template para issues.
-│ ├── PULL_REQUEST_TEMPLATE.md # Template para pull requests.
-│ └── workflows/ # GitHub Actions workflows.
-│ ├── ci-build-test.yml # Pipeline completo de CI/CD.
-│ ├── code-quality.yml # Análise de qualidade de código.
-│ ├── security-scan.yml # Scans de segurança automatizados.
-│ ├── publish-all.yml # Publicação de pacotes NuGet.
-│ ├── auto-pr-from-main.yml # Atualização automática de dependências.
-│ └── ... # Outros workflows de suporte.
-├── appveyor.yml # Configuração para integração contínua com AppVeyor.
-├── docs/ # Documentação gerada, incluindo arquivos de ajuda e XML.
-│ ├── Working/ # Documentação em andamento ou arquivos temporários de documentação.
-│ │ └── Taf.Decoder.xml # Arquivo XML de documentação para o decodificador TAF.
-│ └── media/ # Imagens e outros recursos de mídia para a documentação.
-│ ├── AlertCaution.png
-│ ├── AlertLanguage.png
-│ ├── AlertNote.png
-│ ├── AlertSecurity.png
-│ ├── AlertToDo.png
-│ └── ... (outros arquivos .md gerados para documentação)
-├── metar.docs.shfbproj # Projeto Sandcastle Help File Builder para gerar a documentação.
-├── metar.docs.sln # Solução do Visual Studio para o projeto de documentação.
-├── nuget.config # Configurações do NuGet para o projeto.
-├── sonar/ # Arquivos relacionados à análise de código com SonarQube/SonarCloud.
-│ ├── Google.Protobuf.dll
-│ ├── Newtonsoft.Json.dll
-│ ├── SonarQube.Analysis.xml
-│ ├── SonarScanner.MSBuild.Common.dll
-│ ├── SonarScanner.MSBuild.PostProcessor.dll
-│ ├── SonarScanner.MSBuild.PreProcessor.dll
-│ ├── SonarScanner.MSBuild.Shim.dll
-│ ├── SonarScanner.MSBuild.Tasks.dll
-│ ├── SonarScanner.MSBuild.dll
-│ ├── SonarScanner.MSBuild.runtimeconfig.json
-│ └── Targets/ # Arquivos de destino para integração do SonarQube com MSBuild.
-│ ├── SonarQube.Integration.ImportBefore.targets
-│ └── SonarQube.Integration.targets
-│ └── sonar-scanner-4.8.0.2856/ # Diretório do SonarScanner.
-│ ├── bin/ # Binários do SonarScanner.
-│ ├── conf/ # Arquivos de configuração do SonarScanner.
-│ └── lib/ # Bibliotecas do SonarScanner.
-├── sonarcloud.bat # Script em lote para execução da análise do SonarCloud.
-├── src/ # Código-fonte principal do projeto.
-│ ├── Metar.Decoder/ # Projeto da biblioteca para decodificação de METAR.
-│ │ ├── ChunkDecoder/ # Decodificadores de "chunks" individuais do METAR.
-│ │ │ ├── Abstract/ # Classes abstratas e interfaces para decodificadores de "chunks".
-│ │ │ │ ├── IMetarChunkDecoder.cs
-│ │ │ │ └── MetarChunkDecoder.cs
-│ │ │ ├── CloudChunkDecoder.cs # Decodificador para informações de nuvens.
-│ │ │ ├── DatetimeChunkDecoder.cs # Decodificador para data e hora da observação.
-│ │ │ ├── IcaoChunkDecoder.cs # Decodificador para o código ICAO do aeroporto.
-│ │ │ ├── PresentWeatherChunkDecoder.cs # Decodificador para fenômenos meteorológicos presentes.
-│ │ │ ├── PressureChunkDecoder.cs # Decodificador para informações de pressão.
-│ │ │ ├── RecentWeatherChunkDecoder.cs # Decodificador para tempo recente.
-│ │ │ ├── ReportStatusChunkDecoder.cs # Decodificador para o status do relatório (e.g., AUTO, NIL).
-│ │ │ ├── ReportTypeChunkDecoder.cs # Decodificador para o tipo de relatório (e.g., METAR, SPECI).
-│ │ │ ├── RunwayVisualRangeChunkDecoder.cs # Decodificador para alcance visual da pista.
-│ │ │ ├── SurfaceWindChunkDecoder.cs # Decodificador para informações de vento de superfície.
-│ │ │ ├── TemperatureChunkDecoder.cs # Decodificador para informações de temperatura.
-│ │ │ ├── VisibilityChunkDecoder.cs # Decodificador para informações de visibilidade.
-│ │ │ └── WindShearChunkDecoder.cs # Decodificador para informações de tesoura de vento.
-│ │ ├── EAF.ico
-│ │ ├── EAF.png
-│ │ ├── Entity/ # Classes de entidade que representam os dados decodificados do METAR.
-│ │ │ ├── CloudLayer.cs # Representa uma camada de nuvens.
-│ │ │ ├── DecodedMetar.cs # Objeto principal que contém o METAR decodificado.
-│ │ │ ├── PresentWeather.cs # Representa fenômenos meteorológicos presentes.
-│ │ │ ├── RunwayVisualRange.cs # Representa o alcance visual da pista.
-│ │ │ ├── SurfaceWind.cs # Representa o vento de superfície.
-│ │ │ ├── Value.cs # Classe genérica para valores com unidades.
-│ │ │ ├── Visibility.cs # Representa informações de visibilidade.
-│ │ │ └── WeatherPhenomenon.cs # Representa um fenômeno meteorológico.
-│ │ ├── Exception/ # Classes de exceção específicas do decodificador METAR.
-│ │ │ └── MetarChunkDecoderException.cs
-│ │ ├── Metar.Decoder.csproj # Arquivo de projeto C# para a biblioteca Metar.Decoder.
-│ │ └── MetarDecoder.cs # Lógica principal do decodificador METAR.
-│ └── Taf.Decoder/ # Projeto da biblioteca para decodificação de TAF.
-│ ├── ChunkDecoder/ # Decodificadores de "chunks" individuais do TAF.
-│ │ ├── Abstract/ # Classes abstratas e interfaces para decodificadores de "chunks" TAF.
-│ │ │ ├── ITafChunkDecoder.cs
-│ │ │ └── TafChunkDecoder.cs
-│ │ ├── CloudChunkDecoder.cs
-│ │ ├── DatetimeChunkDecoder.cs
-│ │ ├── EvolutionChunkDecoder.cs # Decodificador para evoluções (BECMG, TEMPO).
-│ │ ├── ForecastPeriodChunkDecoder.cs # Decodificador para o período de previsão.
-│ │ ├── IcaoChunkDecoder.cs
-│ │ ├── ReportTypeChunkDecoder.cs
-│ │ ├── SurfaceWindChunkDecoder.cs
-│ │ ├── TemperatureChunkDecoder.cs
-│ │ ├── VisibilityChunkDecoder.cs
-│ │ └── WeatherChunkDecoder.cs
-│ ├── EAF.ico
-│ ├── EAF.png
-│ ├── Entity/ # Classes de entidade que representam os dados decodificados do TAF.
-│ │ ├── BaseEntity.cs
-│ │ ├── CloudLayer.cs
-│ │ ├── DecodedTaf.cs # Objeto principal que contém o TAF decodificado.
-│ │ ├── Evolution.cs # Representa uma evolução na previsão.
-│ │ ├── ForecastPeriod.cs # Representa o período de previsão.
-│ │ ├── SurfaceWind.cs
-│ │ ├── Temperature.cs
-│ │ ├── Value.cs
-│ │ ├── Visibility.cs
-│ │ └── WeatherPhenomenon.cs
-│ ├── Exception/ # Classes de exceção específicas do decodificador TAF.
-│ │ └── TafChunkDecoderException.cs
-│ ├── README.md # README específico para o decodificador TAF (será consolidado no README principal).
-│ ├── Taf.Decoder.csproj # Arquivo de projeto C# para a biblioteca Taf.Decoder.
-│ └── TafDecoder.cs # Lógica principal do decodificador TAF.
-└── tests/ # Projetos de teste para as bibliotecas.
- ├── Metar.Decoder.Tests/ # Testes para o decodificador METAR.
- │ ├── BasicTest.cs
- │ ├── ChunkDecoder/ # Testes para os decodificadores de "chunks" do METAR.
- │ ├── Entity/ # Testes para as entidades do METAR.
- │ │ ├── DecodedMetarExtendedTest.cs
- │ │ ├── MetarExceptionExtendedTest.cs
- │ │ ├── PresentWeatherTest.cs
- │ │ └── ValueExtendedTest.cs
- │ ├── Integration.cs
- │ ├── MetarChunkDecoderExceptionTest.cs
- │ ├── MetarDecoderTest.cs
- │ └── ValueTest.cs
- └── Taf.Decoder.Tests/ # Testes para o decodificador TAF.
- ├── BasicTest.cs
- ├── ChunkDecoder/ # Testes para os decodificadores de "chunks" do TAF.
- │ └── TafChunkDecoderBaseTest.cs
- ├── Entity/ # Testes para as entidades do TAF.
- │ ├── ForecastPeriodTest.cs
- │ ├── TafExceptionExtendedTest.cs
- │ └── ValueExtendedTest.cs
- ├── Taf.Decoder.Tests.csproj
- ├── TafDecoderTest.cs
- ├── ValueTest.cs
- └── packages.config
+├── CHANGELOG.md # History of all notable changes in the project.
+├── EAF.ico # Project icon.
+├── EAF.png # Project image.
+├── LICENSE # Project license file.
+├── MetarDecoder.sln # Main Visual Studio solution for the project.
+├── README.md # This project documentation file (en-US).
+├── README.pt-br.md # Project documentation in Portuguese (pt-BR).
+├── docs/ # Documentation with guides and API reference.
+│ ├── en-US/ # English documentation.
+│ │ ├── usage-guide.md # Complete usage guide with examples.
+│ │ └── api-reference.md # API reference for all classes and methods.
+│ └── pt-BR/ # Portuguese documentation.
+│ ├── guia-de-uso.md # Guia completo de uso com exemplos.
+│ └── referencia-api.md # Referencia da API para todas as classes e metodos.
+├── src/ # Main source code of the project.
+│ ├── Metar.Decoder/ # Library project for METAR decoding.
+│ │ ├── ChunkDecoder/ # Individual METAR "chunk" decoders.
+│ │ │ ├── Abstract/ # Abstract classes and interfaces.
+│ │ │ ├── CloudChunkDecoder.cs
+│ │ │ ├── DatetimeChunkDecoder.cs
+│ │ │ ├── IcaoChunkDecoder.cs
+│ │ │ ├── PresentWeatherChunkDecoder.cs
+│ │ │ ├── PressureChunkDecoder.cs
+│ │ │ ├── RecentWeatherChunkDecoder.cs
+│ │ │ ├── ReportStatusChunkDecoder.cs
+│ │ │ ├── ReportTypeChunkDecoder.cs
+│ │ │ ├── RunwayVisualRangeChunkDecoder.cs
+│ │ │ ├── SurfaceWindChunkDecoder.cs
+│ │ │ ├── TemperatureChunkDecoder.cs
+│ │ │ ├── TrendChunkDecoder.cs
+│ │ │ ├── VisibilityChunkDecoder.cs
+│ │ │ └── WindShearChunkDecoder.cs
+│ │ ├── Entity/ # Entity classes representing decoded METAR data.
+│ │ │ ├── CloudLayer.cs
+│ │ │ ├── DecodedMetar.cs
+│ │ │ ├── PresentWeather.cs
+│ │ │ ├── RunwayVisualRange.cs
+│ │ │ ├── SurfaceWind.cs
+│ │ │ ├── Value.cs
+│ │ │ ├── Visibility.cs
+│ │ │ └── WeatherPhenomenon.cs
+│ │ └── Exception/ # Custom exception classes.
+│ │ └── MetarChunkDecoderException.cs
+│ └── Taf.Decoder/ # Library project for TAF decoding.
+│ ├── ChunkDecoder/ # Individual TAF "chunk" decoders.
+│ ├── Entity/ # Entity classes representing decoded TAF data.
+│ └── Exception/ # Custom exception classes.
+├── tests/ # Unit tests.
+│ ├── Metar.Decoder.Tests/ # Tests for METAR decoder.
+│ └── Taf.Decoder.Tests/ # Tests for TAF decoder.
+└── .github/workflows/ # GitHub Actions workflows.
+```
+
+## License
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
diff --git a/README.pt-br.md b/README.pt-br.md
new file mode 100644
index 0000000..0335b23
--- /dev/null
+++ b/README.pt-br.md
@@ -0,0 +1,395 @@
+# Decodificador METAR e TAF em C#
+
+[](https://github.com/afonsoft/metar-decoder/blob/main/LICENSE)
+[](https://sonarcloud.io/dashboard?id=afonsoft_metar-decoder)
+[](https://sonarcloud.io/dashboard?id=afonsoft_metar-decoder)
+
+[](https://sonarcloud.io/dashboard?id=afonsoft_metar-decoder)
+[](https://github.com/afonsoft/metar-decoder/issues)
+[](https://sonarcloud.io/summary/new_code?id=afonsoft_metar-decoder)
+[](https://sonarcloud.io/summary/new_code?id=afonsoft_metar-decoder)
+[](https://github.com/afonsoft/metar-decoder/releases)
+
+> **[Read in English (en-US)](README.md)**
+
+## Documentacao
+
+- **[Guia de Uso (Portugues)](docs/pt-BR/guia-de-uso.md)** - Guia completo com exemplos
+- **[Referencia da API (Portugues)](docs/pt-BR/referencia-api.md)** - Todas as classes, propriedades e metodos
+- **[Usage Guide (English)](docs/en-US/usage-guide.md)** - Complete guide with examples
+- **[API Reference (English)](docs/en-US/api-reference.md)** - All classes, properties and methods
+
+## Descricao do Projeto
+
+Este repositorio contem uma biblioteca .NET para decodificar strings METAR (Meteorological Aerodrome Report) e TAF (Terminal Aerodrome Forecast). Ambas as bibliotecas sao compativeis com .NET Standard 2.0, .NET 8.0, .NET 10.0 e .NET Framework 4.8, permitindo sua utilizacao em projetos .NET Core e .NET Framework.
+
+### Decodificador METAR
+
+O decodificador METAR e uma ferramenta robusta para analisar e interpretar relatorios meteorologicos METAR brutos. METAR e um formato padronizado pela Organizacao da Aviacao Civil Internacional (ICAO) para relatar informacoes meteorologicas, amplamente utilizado por pilotos e meteorologistas para previsao do tempo. A biblioteca processa a string METAR e a transforma em um objeto `DecodedMetar` estruturado, que contem todas as propriedades meteorologicas decodificadas, como vento de superficie, visibilidade, alcance visual da pista, tempo presente, camadas de nuvens, temperatura do ar, temperatura do ponto de orvalho e pressao.
+
+### Decodificador TAF
+
+O decodificador TAF e uma biblioteca .NET para decodificar mensagens TAF (Terminal Aerodrome Forecast), que sao previsoes meteorologicas para aerodromos. Assim como o METAR, o formato TAF e altamente padronizado pela ICAO e e crucial para o planejamento de voos. A biblioteca analisa a string TAF e a converte em um objeto `DecodedTaf`, que inclui informacoes como tipo de relatorio, codigo ICAO, data e hora de origem, periodo de previsao, vento de superficie, visibilidade, fenomenos meteorologicos, camadas de nuvens e temperaturas minima e maxima. O decodificador TAF tambem e capaz de interpretar "evolucoes" (mudancas na previsao ao longo do tempo), como `BECMG` (tornando-se) e `TEMPO` (temporario).
+
+Ambos os decodificadores oferecem modos de analise "estrito" e "nao estrito". No modo nao estrito, a analise continua mesmo que sejam encontrados erros de formato, e as excecoes sao registradas na propriedade `DecodingExceptions` do objeto decodificado. Valores numericos com unidades (como velocidade, distancia e pressao) sao encapsulados em objetos `Value`, permitindo conversoes de unidade flexiveis.
+
+Este projeto e amplamente baseado nas implementacoes de [SafranCassiopee/csharp-metar-decoder](https://github.com/SafranCassiopee/csharp-metar-decoder) e [SafranCassiopee/csharp-taf-decoder](https://github.com/SafranCassiopee/csharp-taf-decoder).
+
+## Status do Projeto
+
+**Ativo e em Desenvolvimento** - Com pipelines modernos de CI/CD
+
+### Novidades Recentes
+
+- **Cobertura de Testes ~98%** - 421 testes unitarios com cobertura abrangente
+- **Fix DatetimeChunkDecoder** - Correcao de bug de rollover de dia/mes invalido
+- **Suporte RTD** - Suporte completo para relatorios TAF com "Report Delayed"
+- **.NET 10.0** - Compatibilidade com a versao mais recente do .NET
+- **Workflows Modernos** - CI/CD automatizado com GitHub Actions
+
+## CI/CD e Workflows
+
+Este projeto utiliza pipelines modernos de GitHub Actions para garantir qualidade e automacao:
+
+### Workflows Disponiveis
+
+- **CI Build & Test** (`ci-build-test.yml`) - Pipeline completo de integracao continua
+ - Build automatizado para .NET 8.0
+ - Testes unitarios com coverage
+ - Security scans e performance tests
+ - Criacao automatica de PRs
+
+- **Code Quality** (`code-quality.yml`) - Analise de qualidade de codigo
+ - Qodana analysis
+ - SonarQube integration
+ - Snyk security scanning
+ - Metricas de qualidade
+
+- **Security Scan** (`security-scan.yml`) - Scans de seguranca
+ - CodeQL analysis
+ - Vulnerability scanning
+ - Scans semanais automaticos
+
+- **Publish NuGet** (`publish-all.yml`) - Publicacao automatizada
+ - Publicacao para GitHub Packages
+ - Publicacao para NuGet.org
+ - Criacao automatica de releases
+
+- **Auto Dependency Update** (`auto-pr-from-main.yml`) - Atualizacao automatica
+ - Verificacao de dependencias desatualizadas
+ - Updates de seguranca automaticos
+ - PRs automaticos para updates
+
+### Badges de Qualidade
+
+[](https://github.com/afonsoft/metar-decoder/actions/workflows/ci-build-test.yml)
+[](https://github.com/afonsoft/metar-decoder/actions/workflows/code-quality.yml)
+[](https://github.com/afonsoft/metar-decoder/actions/workflows/security-scan.yml)
+
+## Pacotes NuGet
+
+Os pacotes NuGet oficiais estao disponiveis para facil integracao em seus projetos:
+
+| Pacote | Versao | NuGet |
+| ------ | ------ | ----- |
+| [Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder/) | 1.0.9 | [](https://badge.fury.io/nu/Metar.Decoder) |
+| [Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder/) | 1.0.7 | [](https://badge.fury.io/nu/Taf.Decoder) |
+
+## Pre-requisitos
+
+Esta biblioteca e compativel com multiplas versoes do .NET:
+
+- **.NET Standard 2.0** - Compatibilidade maxima
+- **.NET 8.0** - LTS recomendado
+- **.NET 10.0** - Versao mais recente
+- **.NET Framework 4.8** - Suporte legado
+
+## Como Instalar
+
+### NuGet Package Manager (recomendado)
+
+No Console do Gerenciador de Pacotes no Visual Studio:
+
+```shell
+Install-Package Metar.Decoder
+Install-Package Taf.Decoder
+```
+
+### .NET CLI
+
+```shell
+dotnet add package Metar.Decoder
+dotnet add package Taf.Decoder
+```
+
+### PackageReference
+
+```xml
+
+
+```
+
+Adicione uma referencia a biblioteca e, em seguida, adicione as seguintes diretivas `using`:
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+```
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+```
+
+### Manualmente
+
+Baixe a versao mais recente em [GitHub Releases](https://github.com/afonsoft/metar-decoder/releases).
+
+## Inicio Rapido
+
+### Decodificador METAR
+
+Instancie o decodificador e execute-o em uma string METAR. O objeto retornado e um objeto `DecodedMetar` do qual voce pode recuperar todas as propriedades meteorologicas decodificadas.
+
+Todos os valores que possuem uma unidade sao baseados no objeto `Value`, que fornece as propriedades `ActualValue` e `ActualUnit`.
+
+Consulte a classe [`DecodedMetar`](src/Metar.Decoder/Entity/DecodedMetar.cs) para a estrutura do objeto resultante.
+
+```csharp
+var d = MetarDecoder.ParseWithMode("METAR LFPO 231027Z AUTO 24004G09MPS 2500 1000NW R32/0400 R08C/0004D +FZRA VCSN //FEW015 17/10 Q1009 REFZRA WS R03");
+
+// Informacoes de contexto
+Console.WriteLine($"Valido: {d.IsValid}"); // true
+Console.WriteLine($"METAR Bruto: {d.RawMetar}");
+Console.WriteLine($"Tipo: {d.Type}"); // MetarType.METAR
+Console.WriteLine($"ICAO: {d.ICAO}"); // "LFPO"
+Console.WriteLine($"Dia: {d.Day}"); // 23
+Console.WriteLine($"Hora: {d.Time}"); // "10:27 UTC"
+Console.WriteLine($"Status: {d.Status}"); // "AUTO"
+
+// Vento de superficie
+var sw = d.SurfaceWind;
+Console.WriteLine($"Vento - Direcao Media: {sw.MeanDirection.ActualValue}"); // 240
+Console.WriteLine($"Vento - Velocidade Media: {sw.MeanSpeed.ActualValue} {sw.MeanSpeed.ActualUnit}"); // 4 MeterPerSecond
+Console.WriteLine($"Vento - Variacoes de Velocidade: {sw.SpeedVariations.ActualValue}"); // 9
+
+// Visibilidade
+var v = d.Visibility;
+Console.WriteLine($"Visibilidade Prevalecente: {v.PrevailingVisibility.ActualValue} {v.PrevailingVisibility.ActualUnit}"); // 2500 Meter
+Console.WriteLine($"Visibilidade Minima: {v.MinimumVisibility.ActualValue}"); // 1000
+Console.WriteLine($"Direcao da Visibilidade Minima: {v.MinimumVisibilityDirection}"); // "NW"
+
+// Alcance Visual da Pista (RVR)
+var rvr = d.RunwaysVisualRange;
+Console.WriteLine($"RVR Pista 32: {rvr[0].VisualRange.ActualValue}"); // 400
+Console.WriteLine($"RVR Pista 08C: {rvr[1].VisualRange.ActualValue}"); // 4
+
+// Tempo Presente
+var pw = d.PresentWeather;
+Console.WriteLine($"Tempo Presente 1: {pw[0].IntensityProximity}{string.Join("", pw[0].Characteristics)}{string.Join("", pw[0].Types)}"); // "+FZRA"
+
+// Nuvens
+var cld = d.Clouds;
+Console.WriteLine($"Nuvens - Quantidade: {cld[0].Amount}"); // FEW
+Console.WriteLine($"Nuvens - Altura da Base: {cld[0].BaseHeight.ActualValue} {cld[0].BaseHeight.ActualUnit}"); // 1500 Feet
+
+// Temperatura
+Console.WriteLine($"Temperatura do Ar: {d.AirTemperature.ActualValue} {d.AirTemperature.ActualUnit}"); // 17 DegreeCelsius
+Console.WriteLine($"Temperatura do Ponto de Orvalho: {d.DewPointTemperature.ActualValue}"); // 10
+
+// Pressao
+Console.WriteLine($"Pressao: {d.Pressure.ActualValue} {d.Pressure.ActualUnit}"); // 1009 HectoPascal
+
+// Tempo Recente
+var rw = d.RecentWeather;
+Console.WriteLine($"Tempo Recente - Caracteristicas: {rw.Characteristics}"); // "FZ"
+Console.WriteLine($"Tempo Recente - Tipos: {string.Join(", ", rw.Types)}"); // "RA"
+
+// Tesouras de Vento (Windshear)
+Console.WriteLine($"Windshear em Todas as Pistas: {d.WindshearAllRunways}");
+Console.WriteLine($"Windshear em Pistas Especificas: {string.Join(", ", d.WindshearRunways)}"); // "03"
+```
+
+### Decodificador TAF
+
+Instancie o decodificador e execute-o em uma string TAF. O objeto retornado e um objeto `DecodedTaf` do qual voce pode recuperar todas as propriedades de previsao decodificadas.
+
+Consulte a classe [`DecodedTaf`](src/Taf.Decoder/Entity/DecodedTaf.cs) para a estrutura do objeto resultante.
+
+#### Suporte a RTD (Report Delayed)
+
+O decodificador agora suporta relatorios TAF marcados como "RTD" (Report Delayed), que indicam relatorios atrasados:
+
+```csharp
+string rtdTaf = "RTD EKEB 190416Z 1905/1912 13006KT 0200 FZFG BKN001 TEMPO 1905/1907 2000 BR BKN003 BECMG 1907/1909 9000 NSW FEW002 PROB40 1909/1911 0400 FZFG BKN002=";
+var decoder = new TafDecoder();
+var result = decoder.Parse(rtdTaf);
+
+Console.WriteLine($"Tipo: {result.Type}"); // Saida: RTD
+Console.WriteLine($"ICAO: {result.Icao}"); // Saida: EKEB
+Console.WriteLine($"Valido: {result.IsValid}"); // Saida: True
+```
+
+#### Exemplo Completo de Uso TAF
+
+```csharp
+var d = TafDecoder.ParseWithMode("TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025 TX12/0816Z TN04/0807Z");
+
+// Informacoes de contexto
+Console.WriteLine($"Valido: {d.IsValid}");
+Console.WriteLine($"TAF Bruto: {d.RawTaf}");
+Console.WriteLine($"Tipo: {d.Type}"); // Pode ser: TAF, TAFAMD, TAFCOR, RTD
+Console.WriteLine($"ICAO: {d.Icao}");
+Console.WriteLine($"Dia: {d.Day}");
+Console.WriteLine($"Hora: {d.Time}");
+
+// Periodo de Previsao
+var fp = d.ForecastPeriod;
+Console.WriteLine($"Periodo de Previsao - Do Dia: {fp.FromDay}");
+Console.WriteLine($"Periodo de Previsao - Da Hora: {fp.FromHour}");
+Console.WriteLine($"Periodo de Previsao - Ao Dia: {fp.ToDay}");
+Console.WriteLine($"Periodo de Previsao - A Hora: {fp.ToHour}");
+
+// Vento de superficie
+var swTaf = d.SurfaceWind;
+Console.WriteLine($"TAF Vento - Direcao Media: {swTaf.MeanDirection.ActualValue}");
+Console.WriteLine($"TAF Vento - Velocidade Media: {swTaf.MeanSpeed.ActualValue} {swTaf.MeanSpeed.ActualUnit}");
+
+// Visibilidade
+var vTaf = d.Visibility;
+Console.WriteLine($"TAF Visibilidade Prevalecente: {vTaf.ActualVisibility.ActualValue} {vTaf.ActualVisibility.ActualUnit}");
+Console.WriteLine($"TAF CAVOK: {d.Cavok}");
+
+// Nuvens
+var cldTaf = d.Clouds;
+if (cldTaf.Count > 0)
+{
+ Console.WriteLine($"TAF Nuvens - Quantidade: {cldTaf[0].Amount}");
+ Console.WriteLine($"TAF Nuvens - Altura da Base: {cldTaf[0].BaseHeight.ActualValue} {cldTaf[0].BaseHeight.ActualUnit}");
+}
+
+// Temperaturas (Minima e Maxima)
+var minTemp = d.MinimumTemperature;
+if (minTemp != null)
+{
+ Console.WriteLine($"Temperatura Minima: {minTemp.TemperatureValue.ActualValue} {minTemp.TemperatureValue.ActualUnit} no dia {minTemp.Day} as {minTemp.Hour}Z");
+}
+var maxTemp = d.MaximumTemperature;
+if (maxTemp != null)
+{
+ Console.WriteLine($"Temperatura Maxima: {maxTemp.TemperatureValue.ActualValue} {maxTemp.TemperatureValue.ActualUnit} no dia {maxTemp.Day} as {maxTemp.Hour}Z");
+}
+
+// Fenomenos Meteorologicos
+var wpTaf = d.WeatherPhenomenons;
+if (wpTaf.Count > 0)
+{
+ Console.WriteLine($"TAF Fenomeno Meteorologico: {wpTaf[0].IntensityProximity}{string.Join("", wpTaf[0].Characteristics)}{string.Join("", wpTaf[0].Types)}");
+}
+
+// Evolucoes (BECMG, TEMPO, etc.)
+foreach (var evolution in d.Evolutions)
+{
+ Console.WriteLine($"Evolucao: {evolution.Type} de {evolution.FromDay}{evolution.FromHour}Z a {evolution.ToDay}{evolution.ToHour}Z");
+}
+```
+
+#### Tipos de Relatorio TAF Suportados
+
+| Tipo | Descricao | Exemplo |
+|------|-----------|---------|
+| `TAF` | Relatorio TAF padrao | `TAF LEMD 080500Z...` |
+| `TAFAMD` | Relatorio TAF amendado | `TAF AMD LEMD 080500Z...` |
+| `TAFCOR` | Relatorio TAF corrigido | `TAF COR LEMD 080500Z...` |
+| `RTD` | Relatorio TAF atrasado | `RTD EKEB 190416Z...` |
+
+### Sobre Objetos de Valor (`Value`)
+
+No exemplo acima, assume-se que todos os parametros solicitados estao disponiveis. No mundo real, alguns campos nao sao obrigatorios, portanto, e importante verificar se o objeto `Value` (contendo tanto o valor quanto sua unidade) nao e nulo antes de usa-lo.
+
+```csharp
+var dew_point = d.DewPointTemperature;
+if (dew_point == null)
+{
+ dew_point = new Value(999, Value.Unit.DegreeCelsius);
+}
+
+Console.WriteLine(dew_point.ActualValue);
+Console.WriteLine(dew_point.ActualUnit);
+```
+
+Os objetos `Value` tambem contem sua unidade, que pode ser acessada com a propriedade `ActualUnit`. Ao acessar a propriedade `ActualValue`, voce obtera o valor nesta unidade.
+
+Se voce deseja obter o valor diretamente em outra unidade, pode chamar `GetConvertedValue(unit)`. Os valores suportados sao velocidade, distancia e pressao.
+
+Unidades disponiveis para conversao:
+
+```csharp
+// Unidades de velocidade:
+// Value.Unit.MeterPerSecond
+// Value.Unit.KilometerPerHour
+// Value.Unit.Knot
+
+// Unidades de distancia:
+// Value.Unit.Meter
+// Value.Unit.Feet
+// Value.Unit.StatuteMile
+
+// Unidades de pressao:
+// Value.Unit.HectoPascal
+// Value.Unit.MercuryInch
+
+// Usando conversao em tempo real
+var distance_in_sm = visibility.GetConvertedValue(Value.Unit.StatuteMile);
+var speed_kph = speed.GetConvertedValue(Value.Unit.KilometerPerHour);
+```
+
+### Sobre Erros de Analise
+
+Quando um formato inesperado e encontrado, o erro de analise e registrado no proprio objeto `DecodedMetar` ou `DecodedTaf`. Todos os erros podem ser acessados atraves da propriedade `DecodingExceptions`.
+
+Por padrao, a analise continuara quando um formato incorreto for encontrado. O analisador tambem oferece um modo "estrito" onde a analise para assim que uma nao conformidade e detectada:
+
+```csharp
+var decoder = new MetarDecoder();
+
+// Altera o modo de analise global para "estrito"
+decoder.SetStrictParsing(true);
+
+// Esta analise sera feita no modo estrito
+decoder.Parse("...");
+
+// Esta ignorara o modo global e sera feita no modo nao estrito
+decoder.ParseNotStrict("...");
+
+// Altera o modo de analise global para "nao estrito"
+decoder.SetStrictParsing(false);
+
+// Esta analise sera feita no modo nao estrito
+decoder.Parse("...");
+
+// Esta ignorara o modo global e sera feita no modo estrito
+decoder.ParseStrict("...");
+```
+
+## Como Contribuir
+
+1. **Crie uma branch** a partir da `main`:
+ ```bash
+ git checkout -b feature/sua-feature
+ ```
+
+2. **Faca suas alteracoes** seguindo as boas praticas
+
+3. **Os workflows automaticos** serao executados:
+ - **CI Build & Test** - Valida seu codigo
+ - **Code Quality** - Analisa qualidade
+ - **Security Scan** - Verifica seguranca
+
+4. **Pull Request Automatico**: Se estiver em branches `feature/*`, `bug/*` ou `hotfix/*`, um PR sera criado automaticamente para `main`
+
+5. **Review e Merge**: Apos aprovacao, seu codigo sera mergeado
+
+## Licenca
+
+Este projeto esta licenciado sob a Licenca MIT. Consulte o arquivo [LICENSE](LICENSE) para mais detalhes.
diff --git a/docs/en-US/api-reference.md b/docs/en-US/api-reference.md
new file mode 100644
index 0000000..6b18d2a
--- /dev/null
+++ b/docs/en-US/api-reference.md
@@ -0,0 +1,443 @@
+# Metar.Decoder & Taf.Decoder - API Reference (en-US)
+
+Complete reference for all public classes, properties, methods, and enumerations.
+
+## Table of Contents
+
+- [Metar.Decoder Namespace](#metardecoder-namespace)
+ - [MetarDecoder](#metardecoder-class)
+ - [DecodedMetar](#decodedmetar-class)
+ - [SurfaceWind](#surfacewind-class)
+ - [Visibility](#visibility-class)
+ - [RunwayVisualRange](#runwayvisualrange-class)
+ - [CloudLayer](#cloudlayer-class)
+ - [WeatherPhenomenon](#weatherphenomenon-class)
+ - [Value](#value-class)
+ - [MetarChunkDecoderException](#metarchunkdecoderexception-class)
+- [Taf.Decoder Namespace](#tafdecoder-namespace)
+ - [TafDecoder](#tafdecoder-class)
+ - [DecodedTaf](#decodedtaf-class)
+ - [ForecastPeriod](#forecastperiod-class)
+ - [Temperature](#temperature-class)
+ - [Evolution](#evolution-class)
+- [Enumerations](#enumerations)
+ - [MetarType](#metartype)
+ - [MetarStatus](#metarstatus)
+ - [TafType](#taftype)
+ - [Value.Unit](#valueunit)
+
+---
+
+## Metar.Decoder Namespace
+
+### MetarDecoder Class
+
+Main class for decoding METAR weather report strings.
+
+**Namespace**: `Metar.Decoder`
+
+#### Constants
+
+| Constant | Type | Value | Description |
+|----------|------|-------|-------------|
+| `ResultKey` | `string` | `"Result"` | Key used internally for decoded data results |
+| `RemainingMetarKey` | `string` | `"RemainingMetar"` | Key used internally for remaining unparsed string |
+| `ExceptionKey` | `string` | `"Exception"` | Key used internally for parsing exceptions |
+
+#### Constructors
+
+```csharp
+public MetarDecoder()
+```
+
+Creates a new instance of the METAR decoder. Sets a process-wide regex timeout of 500ms for safety.
+
+#### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `Parse(string rawMetar)` | `DecodedMetar` | Decodes a METAR string using the global strict parsing setting |
+| `ParseStrict(string rawMetar)` | `DecodedMetar` | Decodes a METAR string in strict mode (stops on first error) |
+| `ParseNotStrict(string rawMetar)` | `DecodedMetar` | Decodes a METAR string in non-strict mode (continues on errors) |
+| `ParseWithMode(string rawMetar, bool isStrict = false)` | `DecodedMetar` | **Static**. Decodes a METAR string with the specified parsing mode |
+| `SetStrictParsing(bool isStrict)` | `void` | Sets the global parsing mode for this decoder instance |
+
+---
+
+### DecodedMetar Class
+
+Represents a fully decoded METAR weather report.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+#### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `RawMetar` | `string` | The original raw METAR string (trimmed) |
+| `Type` | `MetarType` | Report type (`METAR`, `METAR_COR`, `SPECI`, `SPECI_COR`, `NULL`) |
+| `ICAO` | `string` | ICAO 4-letter airport identifier (e.g., `"LFPO"`, `"KJFK"`) |
+| `Day` | `int?` | Day of the month of observation (1-31) |
+| `Time` | `string` | Time of observation as formatted string (e.g., `"10:27 UTC"`) |
+| `ObservationDateTime` | `DateTime?` | Full date/time of observation (computed from day and time) |
+| `Status` | `string` | Report status: `"AUTO"` (automated), `"NIL"` (missing), or empty |
+| `SurfaceWind` | `SurfaceWind` | Surface wind data (direction, speed, gusts, variability) |
+| `Visibility` | `Visibility` | Visibility data (prevailing, minimum, direction, NDV) |
+| `Cavok` | `bool` | `true` if CAVOK (Ceiling And Visibility OK) was reported |
+| `RunwaysVisualRange` | `List` | Runway visual range data for each reported runway |
+| `PresentWeather` | `List` | Current weather conditions (rain, snow, fog, etc.) |
+| `Clouds` | `List` | Cloud layers with amount, base height, and cloud type |
+| `AirTemperature` | `Value` | Air temperature (unit: `DegreeCelsius`) |
+| `DewPointTemperature` | `Value` | Dew point temperature (unit: `DegreeCelsius`) |
+| `Pressure` | `Value` | Atmospheric pressure, QNH or altimeter setting |
+| `RecentWeather` | `WeatherPhenomenon` | Weather that occurred recently but is no longer occurring |
+| `WindshearAllRunways` | `bool?` | `true` if windshear reported on all runways (WS ALL RWY) |
+| `WindshearRunways` | `List` | Specific runway identifiers with windshear (e.g., `["03", "21"]`) |
+| `TrendType` | `string` | Trend forecast type: `"NOSIG"`, `"BECMG"`, `"TEMPO"`, or empty |
+| `TrendForecast` | `string` | Raw content of the trend forecast section |
+| `Remark` | `string` | Raw content of the remarks section (after RMK keyword) |
+| `SeaLevelPressure` | `Value` | Sea-level pressure from remarks (SLPnnn format) |
+| `DecodingExceptions` | `ReadOnlyCollection` | List of all parsing errors |
+
+#### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `IsValid` | `bool` | Returns `true` if no decoding exceptions occurred |
+| `AddDecodingException(MetarChunkDecoderException ex)` | `void` | Adds a decoding exception to the list |
+| `ResetDecodingExceptions()` | `void` | Clears all decoding exceptions |
+
+---
+
+### SurfaceWind Class
+
+Represents surface wind information from a METAR report.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `MeanDirection` | `Value` | Mean wind direction (unit: `Degree`, 0-360) |
+| `VariableWind` | `bool` | `true` if wind direction is variable (VRB) |
+| `MeanSpeed` | `Value` | Mean wind speed (unit depends on report: `Knot`, `MeterPerSecond`, or `KilometerPerHour`) |
+| `SpeedVariations` | `Value` | Gust speed, if reported (same unit as `MeanSpeed`) |
+| `DirectionVariations` | `Value[]` | Array of 2 values [min, max] for variable direction range (e.g., 180V240) |
+
+---
+
+### Visibility Class
+
+Represents visibility information from a METAR report.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `PrevailingVisibility` | `Value` | Main visibility (unit: `Meter` or `StatuteMile`) |
+| `MinimumVisibility` | `Value` | Minimum directional visibility, if reported |
+| `MinimumVisibilityDirection` | `string` | Direction of minimum visibility (e.g., `"NW"`, `"SE"`) |
+| `NDV` | `bool` | No Directional Variation - `true` if visibility is the same in all directions |
+| `HasCavok` | `bool` | Whether CAVOK was set for this visibility report |
+
+---
+
+### RunwayVisualRange Class
+
+Represents runway visual range (RVR) information.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `Runway` | `string` | Runway designator (e.g., `"32"`, `"08C"`, `"26L"`) |
+| `VisualRange` | `Value` | Visual range value (unit: `Meter` or `Feet`) |
+| `PastTendency` | `string` | Trend indicator: `"U"` (up), `"D"` (down), `"N"` (no change), or empty |
+| `VisualRangeInterval` | `Value[]` | Min/max range values if an interval was reported |
+| `Variable` | `bool` | Whether a variable range was reported |
+
+---
+
+### CloudLayer Class
+
+Represents a single cloud layer.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `Amount` | `string` | Coverage amount: `"FEW"` (1-2 oktas), `"SCT"` (3-4), `"BKN"` (5-7), `"OVS"` (8) |
+| `BaseHeight` | `Value` | Cloud base height above ground level (unit: `Feet`) |
+| `Type` | `string` | Cloud type: `"CB"` (Cumulonimbus), `"TCU"` (Towering Cumulus), or empty |
+
+---
+
+### WeatherPhenomenon Class
+
+Represents a weather phenomenon (present or recent).
+
+**Namespace**: `Metar.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `IntensityProximity` | `string` | `"+"` (heavy), `"-"` (light), `"VC"` (vicinity), or empty (moderate) |
+| `Characteristics` | `List` | Descriptor codes: `"MI"`, `"BC"`, `"PR"`, `"DR"`, `"BL"`, `"SH"`, `"TS"`, `"FZ"` |
+| `Types` | `List` | Precipitation/obscuration types: `"RA"`, `"SN"`, `"DZ"`, `"FG"`, `"BR"`, etc. |
+
+#### Common Weather Codes
+
+| Code | Description | Category |
+|------|-------------|----------|
+| `RA` | Rain | Precipitation |
+| `SN` | Snow | Precipitation |
+| `DZ` | Drizzle | Precipitation |
+| `GR` | Hail | Precipitation |
+| `GS` | Small hail / Snow pellets | Precipitation |
+| `PL` | Ice pellets | Precipitation |
+| `SG` | Snow grains | Precipitation |
+| `IC` | Ice crystals | Precipitation |
+| `UP` | Unknown precipitation | Precipitation |
+| `FG` | Fog (visibility < 1000m) | Obscuration |
+| `BR` | Mist (visibility 1000-5000m) | Obscuration |
+| `HZ` | Haze | Obscuration |
+| `FU` | Smoke | Obscuration |
+| `SA` | Sand | Obscuration |
+| `DU` | Dust | Obscuration |
+| `VA` | Volcanic ash | Obscuration |
+| `TS` | Thunderstorm | Descriptor |
+| `SH` | Showers | Descriptor |
+| `FZ` | Freezing | Descriptor |
+| `BL` | Blowing | Descriptor |
+| `DR` | Drifting | Descriptor |
+| `MI` | Shallow | Descriptor |
+| `BC` | Patches | Descriptor |
+| `PR` | Partial | Descriptor |
+| `SQ` | Squall | Other |
+| `FC` | Funnel cloud / Tornado | Other |
+| `SS` | Sandstorm | Other |
+| `DS` | Duststorm | Other |
+
+---
+
+### Value Class
+
+Represents a numeric value with its associated unit. Supports unit conversions.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+#### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `ActualValue` | `double` | The numeric value in the original unit |
+| `ActualUnit` | `Value.Unit` | The unit of measurement |
+
+#### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `GetConvertedValue(Value.Unit unitTo)` | `float` | Converts the value to the specified unit. Throws `ArgumentException` if conversion is not supported |
+| `ToString()` | `string` | Returns `"{ActualValue} {ActualUnit}"` |
+
+#### Static Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `ToInt(string value)` | `int?` | Converts METAR-encoded string to integer. Handles `P` (+), `M` (-), `/` (null) |
+
+#### Conversion Table
+
+| From | To | Supported |
+|------|----|-----------|
+| `MeterPerSecond` | `KilometerPerHour`, `Knot` | Yes |
+| `KilometerPerHour` | `MeterPerSecond`, `Knot` | Yes |
+| `Knot` | `MeterPerSecond`, `KilometerPerHour` | Yes |
+| `Meter` | `Feet`, `StatuteMile` | Yes |
+| `Feet` | `Meter`, `StatuteMile` | Yes |
+| `StatuteMile` | `Meter`, `Feet` | Yes |
+| `HectoPascal` | `MercuryInch` | Yes |
+| `MercuryInch` | `HectoPascal` | Yes |
+
+---
+
+### MetarChunkDecoderException Class
+
+Exception thrown when a METAR chunk cannot be decoded.
+
+**Namespace**: `Metar.Decoder`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `Message` | `string` | Description of the parsing error |
+| `RemainingMetar` | `string` | The remaining unparsed METAR string at the point of failure |
+| `ChunkDecoder` | `string` | Name of the chunk decoder that encountered the error |
+| `NewRemainingMetar` | `string` | The adjusted remaining string after error recovery |
+
+---
+
+## Taf.Decoder Namespace
+
+### TafDecoder Class
+
+Main class for decoding TAF weather forecast strings.
+
+**Namespace**: `Taf.Decoder`
+
+#### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `Parse(string rawTaf)` | `DecodedTaf` | Decodes a TAF string using the global strict parsing setting |
+| `ParseStrict(string rawTaf)` | `DecodedTaf` | Decodes a TAF string in strict mode |
+| `ParseNotStrict(string rawTaf)` | `DecodedTaf` | Decodes a TAF string in non-strict mode |
+| `ParseWithMode(string rawTaf, bool isStrict = false)` | `DecodedTaf` | **Static**. Decodes a TAF string with the specified parsing mode |
+| `SetStrictParsing(bool isStrict)` | `void` | Sets the global parsing mode for this decoder instance |
+
+---
+
+### DecodedTaf Class
+
+Represents a fully decoded TAF weather forecast.
+
+**Namespace**: `Taf.Decoder.Entity`
+
+#### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `RawTaf` | `string` | The original raw TAF string (trimmed) |
+| `Type` | `TafType` | Report type (`TAF`, `TAFAMD`, `TAFCOR`, `RTD`, `NULL`) |
+| `Icao` | `string` | ICAO 4-letter airport identifier |
+| `Day` | `int?` | Day of origin (1-31) |
+| `Time` | `string` | Time of origin as formatted string |
+| `OriginDateTime` | `DateTime?` | Full date/time of origin |
+| `ForecastPeriod` | `ForecastPeriod` | Valid forecast period |
+| `Status` | `string` | Report status |
+| `SurfaceWind` | `SurfaceWind` | Surface wind data |
+| `Visibility` | `Visibility` | Visibility data |
+| `Cavok` | `bool` | Whether CAVOK was reported |
+| `WeatherPhenomenons` | `List` | Weather phenomena |
+| `Clouds` | `List` | Cloud layers |
+| `MinimumTemperature` | `Temperature` | Forecast minimum temperature |
+| `MaximumTemperature` | `Temperature` | Forecast maximum temperature |
+| `Evolutions` | `List` | Forecast changes (BECMG, TEMPO, PROB) |
+| `DecodingExceptions` | `ReadOnlyCollection` | Parsing errors |
+
+#### Methods
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `IsValid` | `bool` | Returns `true` if no decoding exceptions occurred |
+| `AddDecodingException(TafChunkDecoderException ex)` | `void` | Adds a decoding exception |
+| `ResetDecodingExceptions()` | `void` | Clears all decoding exceptions |
+
+---
+
+### ForecastPeriod Class
+
+Represents the valid period of a TAF forecast.
+
+**Namespace**: `Taf.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `FromDay` | `int?` | Start day of the forecast period |
+| `FromHour` | `int?` | Start hour of the forecast period (UTC) |
+| `ToDay` | `int?` | End day of the forecast period |
+| `ToHour` | `int?` | End hour of the forecast period (UTC) |
+
+---
+
+### Temperature Class
+
+Represents a forecast temperature with its associated time.
+
+**Namespace**: `Taf.Decoder.Entity`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `TemperatureValue` | `Value` | Temperature value (unit: `DegreeCelsius`) |
+| `Day` | `int?` | Day when the temperature is forecast |
+| `Hour` | `int?` | Hour (UTC) when the temperature is forecast |
+
+---
+
+### Evolution Class
+
+Represents a forecast change (evolution) within a TAF.
+
+**Namespace**: `Taf.Decoder.Entity`
+
+Inherits from `AbstractEntity`, which provides weather-related properties.
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `Type` | `string` | Evolution type: `"BECMG"`, `"TEMPO"` |
+| `FromDay` | `int?` | Start day of the evolution period |
+| `FromHour` | `int?` | Start hour of the evolution period |
+| `ToDay` | `int?` | End day of the evolution period |
+| `ToHour` | `int?` | End hour of the evolution period |
+| `Probability` | `int?` | Probability percentage (30 or 40) if PROB was specified |
+| `SurfaceWind` | `SurfaceWind` | Wind changes (if any) |
+| `Visibility` | `Visibility` | Visibility changes (if any) |
+| `Cavok` | `bool` | Whether CAVOK applies to this evolution |
+| `WeatherPhenomenons` | `List` | Weather changes |
+| `Clouds` | `List` | Cloud changes |
+
+---
+
+## Enumerations
+
+### MetarType
+
+| Value | Description |
+|-------|-------------|
+| `NULL` | Not determined |
+| `METAR` | Standard METAR report |
+| `METAR_COR` | Corrected METAR report |
+| `SPECI` | Special METAR report (issued for significant changes) |
+| `SPECI_COR` | Corrected special METAR report |
+
+### MetarStatus
+
+| Value | Description |
+|-------|-------------|
+| `NULL` | Not determined |
+| `AUTO` | Automated observation (no human intervention) |
+| `NIL` | Missing report (no data available) |
+
+### TafType
+
+| Value | Description |
+|-------|-------------|
+| `NULL` | Not determined |
+| `TAF` | Standard TAF forecast |
+| `TAFAMD` | Amended TAF forecast |
+| `TAFCOR` | Corrected TAF forecast |
+| `RTD` | Report Delayed |
+
+### Value.Unit
+
+| Value | Description | Abbreviation |
+|-------|-------------|-------------|
+| `None` | No unit | |
+| `DegreeCelsius` | Temperature in Celsius | deg C |
+| `Degree` | Direction in degrees | deg |
+| `Knot` | Speed in knots | kt |
+| `MeterPerSecond` | Speed in m/s | m/s |
+| `KilometerPerHour` | Speed in km/h | km/h |
+| `Meter` | Distance in meters | m |
+| `Feet` | Distance in feet | ft |
+| `StatuteMile` | Distance in statute miles | SM |
+| `HectoPascal` | Pressure in hectopascals | hPa |
+| `MercuryInch` | Pressure in inches of mercury | inHg |
+| `UnknownUnit` | Unknown/unrecognized unit | N/A |
+
+---
+
+## Repository & Issues
+
+- **Repository**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **NuGet (Metar)**: [https://www.nuget.org/packages/Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder)
+- **NuGet (TAF)**: [https://www.nuget.org/packages/Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **License**: MIT
diff --git a/docs/en-US/usage-guide.md b/docs/en-US/usage-guide.md
new file mode 100644
index 0000000..3d321ad
--- /dev/null
+++ b/docs/en-US/usage-guide.md
@@ -0,0 +1,557 @@
+# Metar.Decoder & Taf.Decoder - Usage Guide (en-US)
+
+.NET library for decoding METAR and TAF weather report strings. Compatible with **.NET Standard 2.0**, **.NET 8.0**, **.NET 10.0**, and **.NET Framework 4.8**.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [METAR Decoder](#metar-decoder)
+ - [Basic Usage](#basic-metar-usage)
+ - [Full Example](#full-metar-example)
+ - [Decoded Properties](#decoded-metar-properties)
+- [TAF Decoder](#taf-decoder)
+ - [Basic Usage](#basic-taf-usage)
+ - [Full Example](#full-taf-example)
+ - [RTD Support](#rtd-support)
+ - [Evolutions](#evolutions)
+- [Value Objects & Unit Conversion](#value-objects--unit-conversion)
+- [Parsing Modes](#parsing-modes)
+- [Error Handling](#error-handling)
+
+---
+
+## Installation
+
+### .NET CLI
+
+```bash
+dotnet add package Metar.Decoder
+dotnet add package Taf.Decoder
+```
+
+### NuGet Package Manager
+
+```bash
+Install-Package Metar.Decoder
+Install-Package Taf.Decoder
+```
+
+### PackageReference
+
+```xml
+
+
+```
+
+---
+
+## METAR Decoder
+
+METAR (Meteorological Aerodrome Report) is a standardized format by the International Civil Aviation Organization (ICAO) for reporting meteorological conditions at aerodromes. The `MetarDecoder` class parses raw METAR strings into structured `DecodedMetar` objects.
+
+### Basic METAR Usage
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+
+// Simplest usage - static method with non-strict mode (default)
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z 24004KT 9999 FEW040 17/10 Q1009");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.ICAO}");
+ Console.WriteLine($"Temperature: {decoded.AirTemperature.ActualValue} {decoded.AirTemperature.ActualUnit}");
+}
+```
+
+### Full METAR Example
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+
+var d = MetarDecoder.ParseWithMode(
+ "METAR LFPO 231027Z AUTO 24004G09MPS 2500 1000NW R32/0400 R08C/0004D " +
+ "+FZRA VCSN //FEW015 17/10 Q1009 REFZRA WS R03");
+
+// --- Context Information ---
+Console.WriteLine($"Valid: {d.IsValid}"); // true
+Console.WriteLine($"Raw METAR: {d.RawMetar}");
+Console.WriteLine($"Type: {d.Type}"); // MetarType.METAR
+Console.WriteLine($"ICAO: {d.ICAO}"); // "LFPO"
+Console.WriteLine($"Day: {d.Day}"); // 23
+Console.WriteLine($"Time: {d.Time}"); // "10:27 UTC"
+Console.WriteLine($"Status: {d.Status}"); // "AUTO"
+
+// --- Surface Wind ---
+var sw = d.SurfaceWind;
+Console.WriteLine($"Mean Direction: {sw.MeanDirection.ActualValue} {sw.MeanDirection.ActualUnit}");
+// 240 Degree
+Console.WriteLine($"Mean Speed: {sw.MeanSpeed.ActualValue} {sw.MeanSpeed.ActualUnit}");
+// 4 MeterPerSecond
+Console.WriteLine($"Speed Variations (gusts): {sw.SpeedVariations.ActualValue} {sw.SpeedVariations.ActualUnit}");
+// 9 MeterPerSecond
+Console.WriteLine($"Variable Wind: {sw.VariableWind}");
+// false (true when direction is VRB)
+
+// --- Visibility ---
+var v = d.Visibility;
+Console.WriteLine($"Prevailing: {v.PrevailingVisibility.ActualValue} {v.PrevailingVisibility.ActualUnit}");
+// 2500 Meter
+Console.WriteLine($"Minimum: {v.MinimumVisibility.ActualValue} {v.MinimumVisibility.ActualUnit}");
+// 1000 Meter
+Console.WriteLine($"Min Direction: {v.MinimumVisibilityDirection}");
+// "NW"
+Console.WriteLine($"NDV (No Directional Variation): {v.NDV}");
+// false
+Console.WriteLine($"CAVOK: {d.Cavok}");
+// false
+
+// --- Runway Visual Range (RVR) ---
+foreach (var rvr in d.RunwaysVisualRange)
+{
+ Console.WriteLine($"Runway {rvr.Runway}: {rvr.VisualRange.ActualValue} {rvr.VisualRange.ActualUnit}");
+ Console.WriteLine($" Trend: {rvr.PastTendency}");
+ // PastTendency can be: U (Up), D (Down), N (No change), or empty
+}
+
+// --- Present Weather ---
+foreach (var pw in d.PresentWeather)
+{
+ Console.WriteLine($"Weather: {pw.IntensityProximity}" +
+ $"{string.Join("", pw.Characteristics)}" +
+ $"{string.Join("", pw.Types)}");
+ // "+FZRA" (heavy freezing rain)
+ // "VCSN" (vicinity snow)
+}
+
+// --- Cloud Layers ---
+foreach (var cld in d.Clouds)
+{
+ Console.WriteLine($"Clouds: {cld.Amount} at {cld.BaseHeight?.ActualValue} {cld.BaseHeight?.ActualUnit}");
+ Console.WriteLine($" Type: {cld.Type}");
+ // Amount: FEW, SCT, BKN, OVS
+ // Type: CB (cumulonimbus), TCU (towering cumulus), or empty
+}
+
+// --- Temperature ---
+Console.WriteLine($"Air Temperature: {d.AirTemperature?.ActualValue} {d.AirTemperature?.ActualUnit}");
+// 17 DegreeCelsius
+Console.WriteLine($"Dew Point: {d.DewPointTemperature?.ActualValue} {d.DewPointTemperature?.ActualUnit}");
+// 10 DegreeCelsius
+
+// --- Pressure ---
+Console.WriteLine($"Pressure: {d.Pressure?.ActualValue} {d.Pressure?.ActualUnit}");
+// 1009 HectoPascal (QNH)
+
+// --- Recent Weather ---
+if (d.RecentWeather != null)
+{
+ Console.WriteLine($"Recent: {d.RecentWeather.Characteristics}{string.Join("", d.RecentWeather.Types)}");
+ // "FZRA" (recent freezing rain)
+}
+
+// --- Windshear ---
+Console.WriteLine($"Windshear All Runways: {d.WindshearAllRunways}");
+if (d.WindshearRunways?.Count > 0)
+{
+ Console.WriteLine($"Windshear Runways: {string.Join(", ", d.WindshearRunways)}");
+ // "03"
+}
+
+// --- Trend Forecast ---
+if (!string.IsNullOrEmpty(d.TrendType))
+{
+ Console.WriteLine($"Trend Type: {d.TrendType}"); // NOSIG, BECMG, TEMPO
+ Console.WriteLine($"Trend Forecast: {d.TrendForecast}");
+}
+
+// --- Remarks ---
+if (!string.IsNullOrEmpty(d.Remark))
+{
+ Console.WriteLine($"Remarks: {d.Remark}");
+}
+
+// --- Sea-Level Pressure (from remarks) ---
+if (d.SeaLevelPressure != null)
+{
+ Console.WriteLine($"SLP: {d.SeaLevelPressure.ActualValue} {d.SeaLevelPressure.ActualUnit}");
+}
+```
+
+### Decoded METAR Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `RawMetar` | `string` | The original raw METAR string |
+| `IsValid` | `bool` | Whether the METAR was decoded without errors |
+| `Type` | `MetarType` | Report type: `METAR`, `METAR_COR`, `SPECI`, `SPECI_COR` |
+| `ICAO` | `string` | ICAO airport code (e.g., "LFPO") |
+| `Day` | `int?` | Day of the month of observation |
+| `Time` | `string` | Time of observation (e.g., "10:27 UTC") |
+| `ObservationDateTime` | `DateTime?` | Parsed observation date and time |
+| `Status` | `string` | Report status: `AUTO`, `NIL`, or empty |
+| `SurfaceWind` | `SurfaceWind` | Wind information (direction, speed, gusts, variable) |
+| `Visibility` | `Visibility` | Visibility data (prevailing, minimum, direction) |
+| `Cavok` | `bool` | Whether CAVOK (Ceiling And Visibility OK) was reported |
+| `RunwaysVisualRange` | `List` | RVR for each runway |
+| `PresentWeather` | `List` | Current weather phenomena |
+| `Clouds` | `List` | Cloud layers with amount, height, and type |
+| `AirTemperature` | `Value` | Air temperature in degrees Celsius |
+| `DewPointTemperature` | `Value` | Dew point temperature in degrees Celsius |
+| `Pressure` | `Value` | Atmospheric pressure (QNH/QFE) |
+| `RecentWeather` | `WeatherPhenomenon` | Recent weather phenomena |
+| `WindshearAllRunways` | `bool?` | Whether windshear affects all runways |
+| `WindshearRunways` | `List` | Specific runways with windshear |
+| `TrendType` | `string` | Trend forecast type: `NOSIG`, `BECMG`, `TEMPO` |
+| `TrendForecast` | `string` | Raw content of the trend forecast |
+| `Remark` | `string` | Raw content of the remarks section (after RMK) |
+| `SeaLevelPressure` | `Value` | Sea-level pressure extracted from remarks (SLPnnn) |
+| `DecodingExceptions` | `ReadOnlyCollection` | All parsing errors encountered |
+
+---
+
+## TAF Decoder
+
+TAF (Terminal Aerodrome Forecast) is a weather forecast format for aerodromes standardized by ICAO. The `TafDecoder` class parses raw TAF strings into structured `DecodedTaf` objects.
+
+### Basic TAF Usage
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+
+var decoded = TafDecoder.ParseWithMode("TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.Icao}");
+ Console.WriteLine($"Period: {decoded.ForecastPeriod.FromDay}/{decoded.ForecastPeriod.FromHour}Z " +
+ $"to {decoded.ForecastPeriod.ToDay}/{decoded.ForecastPeriod.ToHour}Z");
+}
+```
+
+### Full TAF Example
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+
+var d = TafDecoder.ParseWithMode(
+ "TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025 TX12/0816Z TN04/0807Z");
+
+// --- Context Information ---
+Console.WriteLine($"Valid: {d.IsValid}");
+Console.WriteLine($"Raw TAF: {d.RawTaf}");
+Console.WriteLine($"Type: {d.Type}"); // TAF, TAFAMD, TAFCOR, RTD
+Console.WriteLine($"ICAO: {d.Icao}"); // "LEMD"
+Console.WriteLine($"Day: {d.Day}"); // 8
+Console.WriteLine($"Time: {d.Time}"); // "05:00 UTC"
+
+// --- Forecast Period ---
+var fp = d.ForecastPeriod;
+Console.WriteLine($"From: Day {fp.FromDay} Hour {fp.FromHour}");
+Console.WriteLine($"To: Day {fp.ToDay} Hour {fp.ToHour}");
+
+// --- Surface Wind ---
+var sw = d.SurfaceWind;
+Console.WriteLine($"Direction: {sw.MeanDirection?.ActualValue} {sw.MeanDirection?.ActualUnit}");
+Console.WriteLine($"Speed: {sw.MeanSpeed?.ActualValue} {sw.MeanSpeed?.ActualUnit}");
+if (sw.SpeedVariations != null)
+ Console.WriteLine($"Gusts: {sw.SpeedVariations.ActualValue} {sw.SpeedVariations.ActualUnit}");
+
+// --- Visibility ---
+var vis = d.Visibility;
+Console.WriteLine($"Visibility: {vis.ActualVisibility?.ActualValue} {vis.ActualVisibility?.ActualUnit}");
+Console.WriteLine($"CAVOK: {d.Cavok}");
+
+// --- Clouds ---
+foreach (var cld in d.Clouds)
+{
+ Console.WriteLine($"Clouds: {cld.Amount} at {cld.BaseHeight?.ActualValue} {cld.BaseHeight?.ActualUnit}");
+}
+
+// --- Temperatures ---
+if (d.MaximumTemperature != null)
+{
+ var tx = d.MaximumTemperature;
+ Console.WriteLine($"Max Temp: {tx.TemperatureValue.ActualValue}{tx.TemperatureValue.ActualUnit} " +
+ $"on day {tx.Day} at {tx.Hour}Z");
+}
+if (d.MinimumTemperature != null)
+{
+ var tn = d.MinimumTemperature;
+ Console.WriteLine($"Min Temp: {tn.TemperatureValue.ActualValue}{tn.TemperatureValue.ActualUnit} " +
+ $"on day {tn.Day} at {tn.Hour}Z");
+}
+
+// --- Weather Phenomena ---
+foreach (var wp in d.WeatherPhenomenons)
+{
+ Console.WriteLine($"Weather: {wp.IntensityProximity}" +
+ $"{string.Join("", wp.Characteristics)}" +
+ $"{string.Join("", wp.Types)}");
+}
+
+// --- Evolutions ---
+foreach (var evo in d.Evolutions)
+{
+ Console.WriteLine($"Evolution: {evo.Type}");
+ Console.WriteLine($" Period: {evo.FromDay}{evo.FromHour}Z to {evo.ToDay}{evo.ToHour}Z");
+ Console.WriteLine($" Probability: {evo.Probability}");
+ // Access evolution-specific weather data: evo.SurfaceWind, evo.Visibility, evo.Clouds, etc.
+}
+```
+
+### RTD Support
+
+The decoder supports TAF reports marked as "RTD" (Report Delayed):
+
+```csharp
+string rtdTaf = "RTD EKEB 190416Z 1905/1912 13006KT 0200 FZFG BKN001 " +
+ "TEMPO 1905/1907 2000 BR BKN003 BECMG 1907/1909 9000 NSW FEW002";
+var decoded = TafDecoder.ParseWithMode(rtdTaf);
+
+Console.WriteLine($"Type: {decoded.Type}"); // TafType.RTD
+Console.WriteLine($"ICAO: {decoded.Icao}"); // "EKEB"
+Console.WriteLine($"Valid: {decoded.IsValid}"); // true
+```
+
+### Evolutions
+
+TAF reports can contain forecast changes over time:
+
+| Type | Keyword | Description |
+|------|---------|-------------|
+| BECMG | `BECMG` | Becoming - conditions will gradually change |
+| TEMPO | `TEMPO` | Temporary - conditions will temporarily change |
+| PROB | `PROB30/40` | Probability of occurrence (30% or 40%) |
+| PROB+TEMPO | `PROB30 TEMPO` | Probability of temporary changes |
+
+```csharp
+var d = TafDecoder.ParseWithMode(
+ "TAF EGLL 080500Z 0806/0906 24015G25KT 9999 BKN040 " +
+ "TEMPO 0806/0812 30018G30KT 3000 +SHRA BKN012CB " +
+ "BECMG 0812/0814 25010KT " +
+ "PROB40 0818/0824 2000 BR");
+
+foreach (var evo in d.Evolutions)
+{
+ Console.WriteLine($"--- {evo.Type} ---");
+ Console.WriteLine($"Period: {evo.FromDay}{evo.FromHour}Z-{evo.ToDay}{evo.ToHour}Z");
+
+ if (evo.SurfaceWind != null)
+ Console.WriteLine($"Wind: {evo.SurfaceWind.MeanDirection?.ActualValue} at " +
+ $"{evo.SurfaceWind.MeanSpeed?.ActualValue}{evo.SurfaceWind.MeanSpeed?.ActualUnit}");
+
+ if (evo.Visibility != null)
+ Console.WriteLine($"Visibility: {evo.Visibility.ActualVisibility?.ActualValue}m");
+
+ foreach (var wp in evo.WeatherPhenomenons)
+ Console.WriteLine($"Weather: {wp.IntensityProximity}" +
+ $"{string.Join("", wp.Characteristics)}{string.Join("", wp.Types)}");
+
+ foreach (var cld in evo.Clouds)
+ Console.WriteLine($"Clouds: {cld.Amount} at {cld.BaseHeight?.ActualValue}ft");
+}
+```
+
+### Decoded TAF Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `RawTaf` | `string` | The original raw TAF string |
+| `IsValid` | `bool` | Whether the TAF was decoded without errors |
+| `Type` | `TafType` | Report type: `TAF`, `TAFAMD`, `TAFCOR`, `RTD` |
+| `Icao` | `string` | ICAO airport code |
+| `Day` | `int?` | Day of origin |
+| `Time` | `string` | Time of origin |
+| `OriginDateTime` | `DateTime?` | Parsed origin date and time |
+| `ForecastPeriod` | `ForecastPeriod` | Valid period (FromDay/FromHour to ToDay/ToHour) |
+| `SurfaceWind` | `SurfaceWind` | Wind information |
+| `Visibility` | `Visibility` | Visibility data |
+| `Cavok` | `bool` | Whether CAVOK was reported |
+| `WeatherPhenomenons` | `List` | Weather phenomena |
+| `Clouds` | `List` | Cloud layers |
+| `MinimumTemperature` | `Temperature` | Forecast minimum temperature (TNnn/ddhhZ) |
+| `MaximumTemperature` | `Temperature` | Forecast maximum temperature (TXnn/ddhhZ) |
+| `Evolutions` | `List` | Forecast changes (BECMG, TEMPO, PROB) |
+| `DecodingExceptions` | `ReadOnlyCollection` | All parsing errors |
+
+---
+
+## Value Objects & Unit Conversion
+
+All numeric meteorological values (speed, distance, pressure, temperature) are encapsulated in `Value` objects that carry both the value and its unit.
+
+### Accessing Values
+
+```csharp
+Value temp = decoded.AirTemperature;
+if (temp != null)
+{
+ double value = temp.ActualValue; // e.g., 17.0
+ Value.Unit unit = temp.ActualUnit; // e.g., Value.Unit.DegreeCelsius
+ Console.WriteLine($"{value} {unit}");
+}
+```
+
+### Unit Conversion
+
+Convert values to different units using `GetConvertedValue()`:
+
+```csharp
+// Speed conversions
+Value windSpeed = decoded.SurfaceWind.MeanSpeed; // e.g., 4 MeterPerSecond
+float knots = windSpeed.GetConvertedValue(Value.Unit.Knot); // ~7.776
+float kph = windSpeed.GetConvertedValue(Value.Unit.KilometerPerHour); // ~14.4
+
+// Distance conversions
+Value vis = decoded.Visibility.PrevailingVisibility; // e.g., 2500 Meter
+float feet = vis.GetConvertedValue(Value.Unit.Feet); // ~8202.1
+float miles = vis.GetConvertedValue(Value.Unit.StatuteMile); // ~1.553
+
+// Pressure conversions
+Value press = decoded.Pressure; // e.g., 1009 HectoPascal
+float inHg = press.GetConvertedValue(Value.Unit.MercuryInch); // ~29.797
+```
+
+### Available Units
+
+| Category | Units | Description |
+|----------|-------|-------------|
+| **Speed** | `Value.Unit.MeterPerSecond` | Meters per second (m/s) |
+| | `Value.Unit.KilometerPerHour` | Kilometers per hour (km/h) |
+| | `Value.Unit.Knot` | Knots (kt) |
+| **Distance** | `Value.Unit.Meter` | Meters (m) |
+| | `Value.Unit.Feet` | Feet (ft) |
+| | `Value.Unit.StatuteMile` | Statute miles (SM) |
+| **Pressure** | `Value.Unit.HectoPascal` | Hectopascals (hPa) |
+| | `Value.Unit.MercuryInch` | Inches of mercury (inHg) |
+| **Temperature** | `Value.Unit.DegreeCelsius` | Degrees Celsius |
+| **Direction** | `Value.Unit.Degree` | Degrees (0-360) |
+
+### Null Safety
+
+Always check for null before accessing `Value` objects, as not all fields are mandatory:
+
+```csharp
+// Safe pattern
+var dewPoint = decoded.DewPointTemperature;
+if (dewPoint != null)
+{
+ Console.WriteLine($"Dew Point: {dewPoint.ActualValue} {dewPoint.ActualUnit}");
+}
+else
+{
+ Console.WriteLine("Dew point not reported");
+}
+
+// Default value pattern
+var pressure = decoded.Pressure ?? new Value(1013.25, Value.Unit.HectoPascal);
+Console.WriteLine($"Pressure: {pressure.ActualValue} {pressure.ActualUnit}");
+```
+
+---
+
+## Parsing Modes
+
+Both decoders support two parsing modes:
+
+### Non-Strict Mode (Default)
+
+Continues parsing even when errors are found. Errors are logged in `DecodingExceptions`:
+
+```csharp
+// Using static method (default: non-strict)
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z BADCHUNK 17/10 Q1009");
+
+// Or using instance method
+var decoder = new MetarDecoder();
+decoder.SetStrictParsing(false);
+var result = decoder.Parse("METAR LFPO 231027Z BADCHUNK 17/10 Q1009");
+
+// Check for errors
+foreach (var ex in decoded.DecodingExceptions)
+{
+ Console.WriteLine($"Error in chunk: {ex.Message}");
+}
+
+// Valid data is still available
+Console.WriteLine($"Temperature: {decoded.AirTemperature?.ActualValue}"); // 17
+```
+
+### Strict Mode
+
+Stops parsing at the first error encountered:
+
+```csharp
+// Using static method
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z BADCHUNK 17/10 Q1009", isStrict: true);
+
+// Or using instance method
+var decoder = new MetarDecoder();
+decoder.SetStrictParsing(true);
+var result = decoder.Parse("METAR LFPO 231027Z BADCHUNK 17/10 Q1009");
+
+// Only first error will be reported
+Console.WriteLine($"Valid: {decoded.IsValid}"); // false
+```
+
+### Override Modes per Call
+
+```csharp
+var decoder = new MetarDecoder();
+decoder.SetStrictParsing(true); // global strict
+
+decoder.ParseNotStrict("..."); // override: non-strict for this call
+decoder.ParseStrict("..."); // override: strict for this call
+decoder.Parse("..."); // uses global setting (strict)
+```
+
+---
+
+## Error Handling
+
+### Accessing Parsing Errors
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode(rawMetar);
+
+if (!decoded.IsValid)
+{
+ foreach (var exception in decoded.DecodingExceptions)
+ {
+ Console.WriteLine($"Chunk: {exception.ChunkDecoder}");
+ Console.WriteLine($"Message: {exception.Message}");
+ Console.WriteLine($"Remaining: {exception.RemainingMetar}");
+ }
+}
+```
+
+### Non-Strict Recovery
+
+In non-strict mode, the decoder attempts to recover from errors by retrying on the next chunk. For example, if `AAA 12003KPH ...` is provided to the `SurfaceWind` chunk decoder:
+
+1. It fails on `AAA`
+2. Retries on `12003KPH` and succeeds
+3. The first error is logged, but `SurfaceWind` is populated
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z AAA 12003KT 9999 17/10 Q1009");
+
+// Errors occurred but data was recovered
+Console.WriteLine($"Has Errors: {decoded.DecodingExceptions.Count > 0}"); // true
+Console.WriteLine($"Wind Speed: {decoded.SurfaceWind?.MeanSpeed?.ActualValue}"); // 12
+```
+
+---
+
+## Repository & Issues
+
+- **Repository**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **NuGet (Metar)**: [https://www.nuget.org/packages/Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder)
+- **NuGet (TAF)**: [https://www.nuget.org/packages/Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **License**: MIT
diff --git a/docs/pt-BR/guia-de-uso.md b/docs/pt-BR/guia-de-uso.md
new file mode 100644
index 0000000..0ac5418
--- /dev/null
+++ b/docs/pt-BR/guia-de-uso.md
@@ -0,0 +1,486 @@
+# Metar.Decoder & Taf.Decoder - Guia de Uso (pt-BR)
+
+Biblioteca .NET para decodificacao de strings de relatorios meteorologicos METAR e TAF. Compativel com **.NET Standard 2.0**, **.NET 8.0**, **.NET 10.0** e **.NET Framework 4.8**.
+
+## Indice
+
+- [Instalacao](#instalacao)
+- [Decodificador METAR](#decodificador-metar)
+ - [Uso Basico](#uso-basico-metar)
+ - [Exemplo Completo](#exemplo-completo-metar)
+ - [Propriedades Decodificadas](#propriedades-decodificadas-metar)
+- [Decodificador TAF](#decodificador-taf)
+ - [Uso Basico](#uso-basico-taf)
+ - [Exemplo Completo](#exemplo-completo-taf)
+ - [Suporte RTD](#suporte-rtd)
+ - [Evolucoes](#evolucoes)
+- [Objetos Value e Conversao de Unidades](#objetos-value-e-conversao-de-unidades)
+- [Modos de Analise](#modos-de-analise)
+- [Tratamento de Erros](#tratamento-de-erros)
+
+---
+
+## Instalacao
+
+### .NET CLI
+
+```bash
+dotnet add package Metar.Decoder
+dotnet add package Taf.Decoder
+```
+
+### NuGet Package Manager
+
+```bash
+Install-Package Metar.Decoder
+Install-Package Taf.Decoder
+```
+
+### PackageReference
+
+```xml
+
+
+```
+
+---
+
+## Decodificador METAR
+
+METAR (Meteorological Aerodrome Report) e um formato padronizado pela Organizacao da Aviacao Civil Internacional (ICAO) para relatar condicoes meteorologicas em aerodromos. A classe `MetarDecoder` analisa strings METAR brutas em objetos `DecodedMetar` estruturados.
+
+### Uso Basico METAR
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+
+// Uso mais simples - metodo estatico com modo nao estrito (padrao)
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z 24004KT 9999 FEW040 17/10 Q1009");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.ICAO}");
+ Console.WriteLine($"Temperatura: {decoded.AirTemperature.ActualValue} {decoded.AirTemperature.ActualUnit}");
+}
+```
+
+### Exemplo Completo METAR
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+
+var d = MetarDecoder.ParseWithMode(
+ "METAR LFPO 231027Z AUTO 24004G09MPS 2500 1000NW R32/0400 R08C/0004D " +
+ "+FZRA VCSN //FEW015 17/10 Q1009 REFZRA WS R03");
+
+// --- Informacoes de Contexto ---
+Console.WriteLine($"Valido: {d.IsValid}"); // true
+Console.WriteLine($"METAR Bruto: {d.RawMetar}");
+Console.WriteLine($"Tipo: {d.Type}"); // MetarType.METAR
+Console.WriteLine($"ICAO: {d.ICAO}"); // "LFPO"
+Console.WriteLine($"Dia: {d.Day}"); // 23
+Console.WriteLine($"Hora: {d.Time}"); // "10:27 UTC"
+Console.WriteLine($"Status: {d.Status}"); // "AUTO"
+
+// --- Vento de Superficie ---
+var sw = d.SurfaceWind;
+Console.WriteLine($"Direcao Media: {sw.MeanDirection.ActualValue} {sw.MeanDirection.ActualUnit}");
+// 240 Degree
+Console.WriteLine($"Velocidade Media: {sw.MeanSpeed.ActualValue} {sw.MeanSpeed.ActualUnit}");
+// 4 MeterPerSecond
+Console.WriteLine($"Rajadas: {sw.SpeedVariations.ActualValue} {sw.SpeedVariations.ActualUnit}");
+// 9 MeterPerSecond
+Console.WriteLine($"Vento Variavel: {sw.VariableWind}");
+// false (true quando a direcao e VRB)
+
+// --- Visibilidade ---
+var v = d.Visibility;
+Console.WriteLine($"Prevalecente: {v.PrevailingVisibility.ActualValue} {v.PrevailingVisibility.ActualUnit}");
+// 2500 Meter
+Console.WriteLine($"Minima: {v.MinimumVisibility.ActualValue} {v.MinimumVisibility.ActualUnit}");
+// 1000 Meter
+Console.WriteLine($"Direcao Minima: {v.MinimumVisibilityDirection}");
+// "NW"
+Console.WriteLine($"CAVOK: {d.Cavok}");
+// false
+
+// --- Alcance Visual da Pista (RVR) ---
+foreach (var rvr in d.RunwaysVisualRange)
+{
+ Console.WriteLine($"Pista {rvr.Runway}: {rvr.VisualRange.ActualValue} {rvr.VisualRange.ActualUnit}");
+ Console.WriteLine($" Tendencia: {rvr.PastTendency}");
+ // PastTendency pode ser: U (subindo), D (descendo), N (sem mudanca), ou vazio
+}
+
+// --- Tempo Presente ---
+foreach (var pw in d.PresentWeather)
+{
+ Console.WriteLine($"Tempo: {pw.IntensityProximity}" +
+ $"{string.Join("", pw.Characteristics)}" +
+ $"{string.Join("", pw.Types)}");
+ // "+FZRA" (chuva congelante forte)
+ // "VCSN" (neve nas proximidades)
+}
+
+// --- Camadas de Nuvens ---
+foreach (var cld in d.Clouds)
+{
+ Console.WriteLine($"Nuvens: {cld.Amount} a {cld.BaseHeight?.ActualValue} {cld.BaseHeight?.ActualUnit}");
+ Console.WriteLine($" Tipo: {cld.Type}");
+ // Amount: FEW, SCT, BKN, OVS
+ // Type: CB (cumulonimbus), TCU (cumulus imponente), ou vazio
+}
+
+// --- Temperatura ---
+Console.WriteLine($"Temperatura do Ar: {d.AirTemperature?.ActualValue} {d.AirTemperature?.ActualUnit}");
+// 17 DegreeCelsius
+Console.WriteLine($"Ponto de Orvalho: {d.DewPointTemperature?.ActualValue} {d.DewPointTemperature?.ActualUnit}");
+// 10 DegreeCelsius
+
+// --- Pressao ---
+Console.WriteLine($"Pressao: {d.Pressure?.ActualValue} {d.Pressure?.ActualUnit}");
+// 1009 HectoPascal (QNH)
+
+// --- Tempo Recente ---
+if (d.RecentWeather != null)
+{
+ Console.WriteLine($"Recente: {d.RecentWeather.Characteristics}{string.Join("", d.RecentWeather.Types)}");
+ // "FZRA" (chuva congelante recente)
+}
+
+// --- Windshear ---
+Console.WriteLine($"Windshear Todas as Pistas: {d.WindshearAllRunways}");
+if (d.WindshearRunways?.Count > 0)
+{
+ Console.WriteLine($"Windshear Pistas: {string.Join(", ", d.WindshearRunways)}");
+ // "03"
+}
+
+// --- Tendencia ---
+if (!string.IsNullOrEmpty(d.TrendType))
+{
+ Console.WriteLine($"Tipo de Tendencia: {d.TrendType}"); // NOSIG, BECMG, TEMPO
+ Console.WriteLine($"Previsao de Tendencia: {d.TrendForecast}");
+}
+
+// --- Observacoes ---
+if (!string.IsNullOrEmpty(d.Remark))
+{
+ Console.WriteLine($"Observacoes: {d.Remark}");
+}
+```
+
+### Propriedades Decodificadas METAR
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `RawMetar` | `string` | String METAR bruta original |
+| `IsValid` | `bool` | Se o METAR foi decodificado sem erros |
+| `Type` | `MetarType` | Tipo de relatorio: `METAR`, `METAR_COR`, `SPECI`, `SPECI_COR` |
+| `ICAO` | `string` | Codigo ICAO do aeroporto (ex.: "LFPO") |
+| `Day` | `int?` | Dia do mes da observacao |
+| `Time` | `string` | Hora da observacao (ex.: "10:27 UTC") |
+| `ObservationDateTime` | `DateTime?` | Data e hora completas da observacao |
+| `Status` | `string` | Status do relatorio: `AUTO`, `NIL`, ou vazio |
+| `SurfaceWind` | `SurfaceWind` | Informacoes de vento (direcao, velocidade, rajadas) |
+| `Visibility` | `Visibility` | Dados de visibilidade |
+| `Cavok` | `bool` | Se CAVOK (Teto e Visibilidade OK) foi reportado |
+| `RunwaysVisualRange` | `List` | RVR para cada pista |
+| `PresentWeather` | `List` | Fenomenos meteorologicos atuais |
+| `Clouds` | `List` | Camadas de nuvens |
+| `AirTemperature` | `Value` | Temperatura do ar em graus Celsius |
+| `DewPointTemperature` | `Value` | Temperatura do ponto de orvalho |
+| `Pressure` | `Value` | Pressao atmosferica (QNH/QFE) |
+| `RecentWeather` | `WeatherPhenomenon` | Fenomenos meteorologicos recentes |
+| `WindshearAllRunways` | `bool?` | Se o windshear afeta todas as pistas |
+| `WindshearRunways` | `List` | Pistas especificas com windshear |
+| `TrendType` | `string` | Tipo de tendencia: `NOSIG`, `BECMG`, `TEMPO` |
+| `TrendForecast` | `string` | Conteudo bruto da previsao de tendencia |
+| `Remark` | `string` | Conteudo bruto da secao de observacoes (apos RMK) |
+| `SeaLevelPressure` | `Value` | Pressao ao nivel do mar extraida das observacoes |
+| `DecodingExceptions` | `ReadOnlyCollection` | Erros de analise |
+
+---
+
+## Decodificador TAF
+
+TAF (Terminal Aerodrome Forecast) e um formato de previsao meteorologica para aerodromos padronizado pela ICAO. A classe `TafDecoder` analisa strings TAF brutas em objetos `DecodedTaf` estruturados.
+
+### Uso Basico TAF
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+
+var decoded = TafDecoder.ParseWithMode("TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.Icao}");
+ Console.WriteLine($"Periodo: {decoded.ForecastPeriod.FromDay}/{decoded.ForecastPeriod.FromHour}Z " +
+ $"ate {decoded.ForecastPeriod.ToDay}/{decoded.ForecastPeriod.ToHour}Z");
+}
+```
+
+### Exemplo Completo TAF
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+
+var d = TafDecoder.ParseWithMode(
+ "TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025 TX12/0816Z TN04/0807Z");
+
+// --- Informacoes de Contexto ---
+Console.WriteLine($"Valido: {d.IsValid}");
+Console.WriteLine($"TAF Bruto: {d.RawTaf}");
+Console.WriteLine($"Tipo: {d.Type}"); // TAF, TAFAMD, TAFCOR, RTD
+Console.WriteLine($"ICAO: {d.Icao}"); // "LEMD"
+
+// --- Periodo de Previsao ---
+var fp = d.ForecastPeriod;
+Console.WriteLine($"De: Dia {fp.FromDay} Hora {fp.FromHour}");
+Console.WriteLine($"Ate: Dia {fp.ToDay} Hora {fp.ToHour}");
+
+// --- Vento de Superficie ---
+var sw = d.SurfaceWind;
+Console.WriteLine($"Direcao: {sw.MeanDirection?.ActualValue} {sw.MeanDirection?.ActualUnit}");
+Console.WriteLine($"Velocidade: {sw.MeanSpeed?.ActualValue} {sw.MeanSpeed?.ActualUnit}");
+
+// --- Visibilidade ---
+Console.WriteLine($"Visibilidade: {d.Visibility.ActualVisibility?.ActualValue} {d.Visibility.ActualVisibility?.ActualUnit}");
+
+// --- Nuvens ---
+foreach (var cld in d.Clouds)
+{
+ Console.WriteLine($"Nuvens: {cld.Amount} a {cld.BaseHeight?.ActualValue} {cld.BaseHeight?.ActualUnit}");
+}
+
+// --- Temperaturas ---
+if (d.MaximumTemperature != null)
+{
+ var tx = d.MaximumTemperature;
+ Console.WriteLine($"Temp Maxima: {tx.TemperatureValue.ActualValue}{tx.TemperatureValue.ActualUnit} " +
+ $"no dia {tx.Day} as {tx.Hour}Z");
+}
+if (d.MinimumTemperature != null)
+{
+ var tn = d.MinimumTemperature;
+ Console.WriteLine($"Temp Minima: {tn.TemperatureValue.ActualValue}{tn.TemperatureValue.ActualUnit} " +
+ $"no dia {tn.Day} as {tn.Hour}Z");
+}
+
+// --- Evolucoes ---
+foreach (var evo in d.Evolutions)
+{
+ Console.WriteLine($"Evolucao: {evo.Type} de {evo.FromDay}{evo.FromHour}Z a {evo.ToDay}{evo.ToHour}Z");
+}
+```
+
+### Suporte RTD
+
+O decodificador suporta relatorios TAF marcados como "RTD" (Report Delayed):
+
+```csharp
+string rtdTaf = "RTD EKEB 190416Z 1905/1912 13006KT 0200 FZFG BKN001 " +
+ "TEMPO 1905/1907 2000 BR BKN003 BECMG 1907/1909 9000 NSW FEW002";
+var decoded = TafDecoder.ParseWithMode(rtdTaf);
+
+Console.WriteLine($"Tipo: {decoded.Type}"); // TafType.RTD
+Console.WriteLine($"ICAO: {decoded.Icao}"); // "EKEB"
+Console.WriteLine($"Valido: {decoded.IsValid}"); // true
+```
+
+### Evolucoes
+
+Relatorios TAF podem conter mudancas de previsao ao longo do tempo:
+
+| Tipo | Palavra-chave | Descricao |
+|------|---------------|-----------|
+| BECMG | `BECMG` | Tornando-se - condicoes mudarao gradualmente |
+| TEMPO | `TEMPO` | Temporario - condicoes mudarao temporariamente |
+| PROB | `PROB30/40` | Probabilidade de ocorrencia (30% ou 40%) |
+| PROB+TEMPO | `PROB30 TEMPO` | Probabilidade de mudancas temporarias |
+
+```csharp
+var d = TafDecoder.ParseWithMode(
+ "TAF EGLL 080500Z 0806/0906 24015G25KT 9999 BKN040 " +
+ "TEMPO 0806/0812 30018G30KT 3000 +SHRA BKN012CB " +
+ "BECMG 0812/0814 25010KT " +
+ "PROB40 0818/0824 2000 BR");
+
+foreach (var evo in d.Evolutions)
+{
+ Console.WriteLine($"--- {evo.Type} ---");
+ Console.WriteLine($"Periodo: {evo.FromDay}{evo.FromHour}Z-{evo.ToDay}{evo.ToHour}Z");
+
+ if (evo.SurfaceWind != null)
+ Console.WriteLine($"Vento: {evo.SurfaceWind.MeanDirection?.ActualValue} a " +
+ $"{evo.SurfaceWind.MeanSpeed?.ActualValue}{evo.SurfaceWind.MeanSpeed?.ActualUnit}");
+
+ if (evo.Visibility != null)
+ Console.WriteLine($"Visibilidade: {evo.Visibility.ActualVisibility?.ActualValue}m");
+}
+```
+
+---
+
+## Objetos Value e Conversao de Unidades
+
+Todos os valores meteorologicos numericos sao encapsulados em objetos `Value` que carregam tanto o valor quanto sua unidade.
+
+### Acessando Valores
+
+```csharp
+Value temp = decoded.AirTemperature;
+if (temp != null)
+{
+ double valor = temp.ActualValue; // ex.: 17.0
+ Value.Unit unidade = temp.ActualUnit; // ex.: Value.Unit.DegreeCelsius
+ Console.WriteLine($"{valor} {unidade}");
+}
+```
+
+### Conversao de Unidades
+
+Converta valores para diferentes unidades usando `GetConvertedValue()`:
+
+```csharp
+// Conversoes de velocidade
+Value velVento = decoded.SurfaceWind.MeanSpeed; // ex.: 4 MeterPerSecond
+float nos = velVento.GetConvertedValue(Value.Unit.Knot); // ~7.776
+float kmh = velVento.GetConvertedValue(Value.Unit.KilometerPerHour); // ~14.4
+
+// Conversoes de distancia
+Value vis = decoded.Visibility.PrevailingVisibility; // ex.: 2500 Meter
+float pes = vis.GetConvertedValue(Value.Unit.Feet); // ~8202.1
+float milhas = vis.GetConvertedValue(Value.Unit.StatuteMile); // ~1.553
+
+// Conversoes de pressao
+Value press = decoded.Pressure; // ex.: 1009 HectoPascal
+float inHg = press.GetConvertedValue(Value.Unit.MercuryInch); // ~29.797
+```
+
+### Unidades Disponiveis
+
+| Categoria | Unidade | Descricao |
+|-----------|---------|-----------|
+| **Velocidade** | `Value.Unit.MeterPerSecond` | Metros por segundo (m/s) |
+| | `Value.Unit.KilometerPerHour` | Quilometros por hora (km/h) |
+| | `Value.Unit.Knot` | Nos (kt) |
+| **Distancia** | `Value.Unit.Meter` | Metros (m) |
+| | `Value.Unit.Feet` | Pes (ft) |
+| | `Value.Unit.StatuteMile` | Milhas terrestres (SM) |
+| **Pressao** | `Value.Unit.HectoPascal` | Hectopascais (hPa) |
+| | `Value.Unit.MercuryInch` | Polegadas de mercurio (inHg) |
+| **Temperatura** | `Value.Unit.DegreeCelsius` | Graus Celsius |
+| **Direcao** | `Value.Unit.Degree` | Graus (0-360) |
+
+### Seguranca contra Nulos
+
+Sempre verifique nulo antes de acessar objetos `Value`, pois nem todos os campos sao obrigatorios:
+
+```csharp
+var pontoOrvalho = decoded.DewPointTemperature;
+if (pontoOrvalho != null)
+{
+ Console.WriteLine($"Ponto de Orvalho: {pontoOrvalho.ActualValue} {pontoOrvalho.ActualUnit}");
+}
+else
+{
+ Console.WriteLine("Ponto de orvalho nao reportado");
+}
+
+// Padrao com valor default
+var pressao = decoded.Pressure ?? new Value(1013.25, Value.Unit.HectoPascal);
+```
+
+---
+
+## Modos de Analise
+
+Ambos os decodificadores suportam dois modos de analise:
+
+### Modo Nao Estrito (Padrao)
+
+Continua a analise mesmo quando erros sao encontrados:
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z BADCHUNK 17/10 Q1009");
+
+// Verificar erros
+foreach (var ex in decoded.DecodingExceptions)
+{
+ Console.WriteLine($"Erro: {ex.Message}");
+}
+
+// Dados validos ainda estao disponiveis
+Console.WriteLine($"Temperatura: {decoded.AirTemperature?.ActualValue}"); // 17
+```
+
+### Modo Estrito
+
+Para a analise no primeiro erro encontrado:
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z BADCHUNK 17/10 Q1009", isStrict: true);
+Console.WriteLine($"Valido: {decoded.IsValid}"); // false
+```
+
+### Sobrescrevendo o Modo por Chamada
+
+```csharp
+var decoder = new MetarDecoder();
+decoder.SetStrictParsing(true); // estrito global
+
+decoder.ParseNotStrict("..."); // sobrescreve: nao estrito para esta chamada
+decoder.ParseStrict("..."); // sobrescreve: estrito para esta chamada
+decoder.Parse("..."); // usa configuracao global (estrito)
+```
+
+---
+
+## Tratamento de Erros
+
+### Acessando Erros de Analise
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode(rawMetar);
+
+if (!decoded.IsValid)
+{
+ foreach (var exception in decoded.DecodingExceptions)
+ {
+ Console.WriteLine($"Chunk: {exception.ChunkDecoder}");
+ Console.WriteLine($"Mensagem: {exception.Message}");
+ Console.WriteLine($"Restante: {exception.RemainingMetar}");
+ }
+}
+```
+
+### Recuperacao em Modo Nao Estrito
+
+No modo nao estrito, o decodificador tenta se recuperar de erros retentando no proximo chunk. Por exemplo, se `AAA 12003KPH ...` e fornecido ao decodificador `SurfaceWind`:
+
+1. Falha em `AAA`
+2. Retenta em `12003KPH` e tem sucesso
+3. O primeiro erro e registrado, mas `SurfaceWind` e preenchido
+
+```csharp
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z AAA 12003KT 9999 17/10 Q1009");
+
+Console.WriteLine($"Tem Erros: {decoded.DecodingExceptions.Count > 0}"); // true
+Console.WriteLine($"Velocidade do Vento: {decoded.SurfaceWind?.MeanSpeed?.ActualValue}"); // 12
+```
+
+---
+
+## Repositorio e Issues
+
+- **Repositorio**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **NuGet (Metar)**: [https://www.nuget.org/packages/Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder)
+- **NuGet (TAF)**: [https://www.nuget.org/packages/Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **Licenca**: MIT
diff --git a/docs/pt-BR/referencia-api.md b/docs/pt-BR/referencia-api.md
new file mode 100644
index 0000000..f5397af
--- /dev/null
+++ b/docs/pt-BR/referencia-api.md
@@ -0,0 +1,345 @@
+# Metar.Decoder & Taf.Decoder - Referencia da API (pt-BR)
+
+Referencia completa de todas as classes publicas, propriedades, metodos e enumeracoes.
+
+Para a versao em ingles, consulte: **[API Reference (en-US)](../en-US/api-reference.md)**
+
+## Indice
+
+- [Namespace Metar.Decoder](#namespace-metardecoder)
+ - [MetarDecoder](#classe-metardecoder)
+ - [DecodedMetar](#classe-decodedmetar)
+ - [SurfaceWind](#classe-surfacewind)
+ - [Visibility](#classe-visibility)
+ - [RunwayVisualRange](#classe-runwayvisualrange)
+ - [CloudLayer](#classe-cloudlayer)
+ - [WeatherPhenomenon](#classe-weatherphenomenon)
+ - [Value](#classe-value)
+- [Namespace Taf.Decoder](#namespace-tafdecoder)
+ - [TafDecoder](#classe-tafdecoder)
+ - [DecodedTaf](#classe-decodedtaf)
+ - [ForecastPeriod](#classe-forecastperiod)
+ - [Temperature](#classe-temperature)
+ - [Evolution](#classe-evolution)
+- [Enumeracoes](#enumeracoes)
+
+---
+
+## Namespace Metar.Decoder
+
+### Classe MetarDecoder
+
+Classe principal para decodificacao de strings METAR.
+
+**Namespace**: `Metar.Decoder`
+
+#### Construtores
+
+```csharp
+public MetarDecoder()
+```
+
+Cria uma nova instancia do decodificador METAR. Define um timeout de regex de 500ms para seguranca.
+
+#### Metodos
+
+| Metodo | Retorno | Descricao |
+|--------|---------|-----------|
+| `Parse(string rawMetar)` | `DecodedMetar` | Decodifica uma string METAR usando a configuracao global de modo estrito |
+| `ParseStrict(string rawMetar)` | `DecodedMetar` | Decodifica no modo estrito (para no primeiro erro) |
+| `ParseNotStrict(string rawMetar)` | `DecodedMetar` | Decodifica no modo nao estrito (continua em erros) |
+| `ParseWithMode(string rawMetar, bool isStrict = false)` | `DecodedMetar` | **Estatico**. Decodifica com o modo especificado |
+| `SetStrictParsing(bool isStrict)` | `void` | Define o modo de analise global |
+
+---
+
+### Classe DecodedMetar
+
+Representa um relatorio METAR completamente decodificado.
+
+**Namespace**: `Metar.Decoder.Entity`
+
+#### Propriedades
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `RawMetar` | `string` | String METAR bruta original (sem espacos extras) |
+| `Type` | `MetarType` | Tipo de relatorio: `METAR`, `METAR_COR`, `SPECI`, `SPECI_COR`, `NULL` |
+| `ICAO` | `string` | Identificador ICAO de 4 letras do aeroporto (ex.: `"LFPO"`, `"SBGR"`) |
+| `Day` | `int?` | Dia do mes da observacao (1-31) |
+| `Time` | `string` | Hora da observacao (ex.: `"10:27 UTC"`) |
+| `ObservationDateTime` | `DateTime?` | Data/hora completa da observacao |
+| `Status` | `string` | Status: `"AUTO"` (automatizado), `"NIL"` (ausente), ou vazio |
+| `SurfaceWind` | `SurfaceWind` | Dados de vento de superficie |
+| `Visibility` | `Visibility` | Dados de visibilidade |
+| `Cavok` | `bool` | `true` se CAVOK foi reportado |
+| `RunwaysVisualRange` | `List` | RVR para cada pista reportada |
+| `PresentWeather` | `List` | Condicoes meteorologicas atuais |
+| `Clouds` | `List` | Camadas de nuvens |
+| `AirTemperature` | `Value` | Temperatura do ar (unidade: `DegreeCelsius`) |
+| `DewPointTemperature` | `Value` | Temperatura do ponto de orvalho |
+| `Pressure` | `Value` | Pressao atmosferica (QNH) |
+| `RecentWeather` | `WeatherPhenomenon` | Tempo recente |
+| `WindshearAllRunways` | `bool?` | Se windshear em todas as pistas |
+| `WindshearRunways` | `List` | Pistas com windshear |
+| `TrendType` | `string` | Tipo de tendencia: `"NOSIG"`, `"BECMG"`, `"TEMPO"` |
+| `TrendForecast` | `string` | Conteudo bruto da previsao de tendencia |
+| `Remark` | `string` | Conteudo bruto das observacoes (apos RMK) |
+| `SeaLevelPressure` | `Value` | Pressao ao nivel do mar (SLPnnn) |
+| `DecodingExceptions` | `ReadOnlyCollection` | Erros de analise |
+
+#### Metodos
+
+| Metodo | Retorno | Descricao |
+|--------|---------|-----------|
+| `IsValid` | `bool` | Retorna `true` se nenhuma excecao de decodificacao ocorreu |
+| `AddDecodingException(...)` | `void` | Adiciona uma excecao de decodificacao |
+| `ResetDecodingExceptions()` | `void` | Limpa todas as excecoes |
+
+---
+
+### Classe SurfaceWind
+
+Informacoes de vento de superficie.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `MeanDirection` | `Value` | Direcao media do vento (unidade: `Degree`, 0-360) |
+| `VariableWind` | `bool` | `true` se a direcao do vento e variavel (VRB) |
+| `MeanSpeed` | `Value` | Velocidade media do vento |
+| `SpeedVariations` | `Value` | Velocidade de rajada, se reportada |
+| `DirectionVariations` | `Value[]` | Array de 2 valores [min, max] para faixa de direcao variavel |
+
+---
+
+### Classe Visibility
+
+Informacoes de visibilidade.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `PrevailingVisibility` | `Value` | Visibilidade principal (unidade: `Meter` ou `StatuteMile`) |
+| `MinimumVisibility` | `Value` | Visibilidade direcional minima |
+| `MinimumVisibilityDirection` | `string` | Direcao da visibilidade minima (ex.: `"NW"`, `"SE"`) |
+| `NDV` | `bool` | Sem Variacao Direcional |
+| `HasCavok` | `bool` | Se CAVOK foi definido |
+
+---
+
+### Classe RunwayVisualRange
+
+Alcance visual da pista (RVR).
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `Runway` | `string` | Designador da pista (ex.: `"32"`, `"08C"`, `"26L"`) |
+| `VisualRange` | `Value` | Valor do alcance visual |
+| `PastTendency` | `string` | Indicador de tendencia: `"U"`, `"D"`, `"N"`, ou vazio |
+| `VisualRangeInterval` | `Value[]` | Valores min/max se um intervalo foi reportado |
+| `Variable` | `bool` | Se um intervalo variavel foi reportado |
+
+---
+
+### Classe CloudLayer
+
+Camada de nuvens individual.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `Amount` | `string` | Cobertura: `"FEW"` (1-2 oitavos), `"SCT"` (3-4), `"BKN"` (5-7), `"OVS"` (8) |
+| `BaseHeight` | `Value` | Altura da base da nuvem acima do solo (unidade: `Feet`) |
+| `Type` | `string` | Tipo: `"CB"` (Cumulonimbus), `"TCU"` (Cumulus imponente), ou vazio |
+
+---
+
+### Classe WeatherPhenomenon
+
+Fenomeno meteorologico (presente ou recente).
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `IntensityProximity` | `string` | `"+"` (forte), `"-"` (leve), `"VC"` (vizinhanca), ou vazio (moderado) |
+| `Characteristics` | `List` | Codigos descritores: `"MI"`, `"BC"`, `"PR"`, `"DR"`, `"BL"`, `"SH"`, `"TS"`, `"FZ"` |
+| `Types` | `List` | Tipos de precipitacao/obscurecimento: `"RA"`, `"SN"`, `"DZ"`, `"FG"`, `"BR"`, etc. |
+
+#### Codigos Meteorologicos Comuns
+
+| Codigo | Descricao | Categoria |
+|--------|-----------|-----------|
+| `RA` | Chuva | Precipitacao |
+| `SN` | Neve | Precipitacao |
+| `DZ` | Chuvisco | Precipitacao |
+| `GR` | Granizo | Precipitacao |
+| `GS` | Granizo pequeno / Grao de neve | Precipitacao |
+| `PL` | Pelotas de gelo | Precipitacao |
+| `FG` | Nevoeiro (visibilidade < 1000m) | Obscurecimento |
+| `BR` | Nevoa (visibilidade 1000-5000m) | Obscurecimento |
+| `HZ` | Nevoa seca | Obscurecimento |
+| `FU` | Fumaca | Obscurecimento |
+| `SA` | Areia | Obscurecimento |
+| `DU` | Poeira | Obscurecimento |
+| `VA` | Cinza vulcanica | Obscurecimento |
+| `TS` | Trovoada | Descritor |
+| `SH` | Pancadas | Descritor |
+| `FZ` | Congelante | Descritor |
+| `BL` | Soprado | Descritor |
+| `SQ` | Rajada | Outro |
+| `FC` | Nuvem funil / Tornado | Outro |
+
+---
+
+### Classe Value
+
+Valor numerico com unidade associada. Suporta conversao de unidades.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `ActualValue` | `double` | Valor numerico na unidade original |
+| `ActualUnit` | `Value.Unit` | Unidade de medida |
+
+#### Metodos
+
+| Metodo | Retorno | Descricao |
+|--------|---------|-----------|
+| `GetConvertedValue(Value.Unit unitTo)` | `float` | Converte o valor para a unidade especificada |
+| `ToString()` | `string` | Retorna `"{ActualValue} {ActualUnit}"` |
+| `ToInt(string value)` | `int?` | **Estatico**. Converte string codificada METAR para inteiro |
+
+---
+
+## Namespace Taf.Decoder
+
+### Classe TafDecoder
+
+Classe principal para decodificacao de strings TAF.
+
+#### Metodos
+
+| Metodo | Retorno | Descricao |
+|--------|---------|-----------|
+| `Parse(string rawTaf)` | `DecodedTaf` | Decodifica usando configuracao global |
+| `ParseStrict(string rawTaf)` | `DecodedTaf` | Decodifica no modo estrito |
+| `ParseNotStrict(string rawTaf)` | `DecodedTaf` | Decodifica no modo nao estrito |
+| `ParseWithMode(string rawTaf, bool isStrict = false)` | `DecodedTaf` | **Estatico**. Decodifica com modo especificado |
+| `SetStrictParsing(bool isStrict)` | `void` | Define modo de analise global |
+
+---
+
+### Classe DecodedTaf
+
+Representa uma previsao TAF completamente decodificada.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `RawTaf` | `string` | String TAF bruta original |
+| `Type` | `TafType` | Tipo: `TAF`, `TAFAMD`, `TAFCOR`, `RTD`, `NULL` |
+| `Icao` | `string` | Identificador ICAO do aeroporto |
+| `Day` | `int?` | Dia de origem |
+| `Time` | `string` | Hora de origem |
+| `OriginDateTime` | `DateTime?` | Data/hora de origem |
+| `ForecastPeriod` | `ForecastPeriod` | Periodo de previsao valido |
+| `SurfaceWind` | `SurfaceWind` | Dados de vento |
+| `Visibility` | `Visibility` | Dados de visibilidade |
+| `Cavok` | `bool` | Se CAVOK foi reportado |
+| `WeatherPhenomenons` | `List` | Fenomenos meteorologicos |
+| `Clouds` | `List` | Camadas de nuvens |
+| `MinimumTemperature` | `Temperature` | Temperatura minima prevista (TNnn/ddhhZ) |
+| `MaximumTemperature` | `Temperature` | Temperatura maxima prevista (TXnn/ddhhZ) |
+| `Evolutions` | `List` | Mudancas de previsao (BECMG, TEMPO, PROB) |
+| `DecodingExceptions` | `ReadOnlyCollection` | Erros de analise |
+
+---
+
+### Classe ForecastPeriod
+
+Periodo de validade da previsao TAF.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `FromDay` | `int?` | Dia de inicio |
+| `FromHour` | `int?` | Hora de inicio (UTC) |
+| `ToDay` | `int?` | Dia de termino |
+| `ToHour` | `int?` | Hora de termino (UTC) |
+
+---
+
+### Classe Temperature
+
+Temperatura prevista com horario associado.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `TemperatureValue` | `Value` | Valor da temperatura (unidade: `DegreeCelsius`) |
+| `Day` | `int?` | Dia da temperatura prevista |
+| `Hour` | `int?` | Hora (UTC) da temperatura prevista |
+
+---
+
+### Classe Evolution
+
+Mudanca de previsao (evolucao) dentro de um TAF.
+
+| Propriedade | Tipo | Descricao |
+|-------------|------|-----------|
+| `Type` | `string` | Tipo: `"BECMG"`, `"TEMPO"` |
+| `FromDay` | `int?` | Dia de inicio da evolucao |
+| `FromHour` | `int?` | Hora de inicio da evolucao |
+| `ToDay` | `int?` | Dia de termino da evolucao |
+| `ToHour` | `int?` | Hora de termino da evolucao |
+| `Probability` | `int?` | Porcentagem de probabilidade (30 ou 40) |
+| `SurfaceWind` | `SurfaceWind` | Mudancas de vento |
+| `Visibility` | `Visibility` | Mudancas de visibilidade |
+| `Cavok` | `bool` | Se CAVOK se aplica |
+| `WeatherPhenomenons` | `List` | Mudancas de tempo |
+| `Clouds` | `List` | Mudancas de nuvens |
+
+---
+
+## Enumeracoes
+
+### MetarType
+
+| Valor | Descricao |
+|-------|-----------|
+| `NULL` | Nao determinado |
+| `METAR` | Relatorio METAR padrao |
+| `METAR_COR` | Relatorio METAR corrigido |
+| `SPECI` | Relatorio METAR especial |
+| `SPECI_COR` | Relatorio METAR especial corrigido |
+
+### TafType
+
+| Valor | Descricao |
+|-------|-----------|
+| `NULL` | Nao determinado |
+| `TAF` | Previsao TAF padrao |
+| `TAFAMD` | Previsao TAF amendada |
+| `TAFCOR` | Previsao TAF corrigida |
+| `RTD` | Relatorio Atrasado |
+
+### Value.Unit
+
+| Valor | Descricao | Abreviacao |
+|-------|-----------|------------|
+| `None` | Sem unidade | |
+| `DegreeCelsius` | Temperatura em Celsius | deg C |
+| `Degree` | Direcao em graus | deg |
+| `Knot` | Velocidade em nos | kt |
+| `MeterPerSecond` | Velocidade em m/s | m/s |
+| `KilometerPerHour` | Velocidade em km/h | km/h |
+| `Meter` | Distancia em metros | m |
+| `Feet` | Distancia em pes | ft |
+| `StatuteMile` | Distancia em milhas terrestres | SM |
+| `HectoPascal` | Pressao em hectopascais | hPa |
+| `MercuryInch` | Pressao em polegadas de mercurio | inHg |
+| `UnknownUnit` | Unidade desconhecida | N/A |
+
+---
+
+## Repositorio e Issues
+
+- **Repositorio**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **NuGet (Metar)**: [https://www.nuget.org/packages/Metar.Decoder](https://www.nuget.org/packages/Metar.Decoder)
+- **NuGet (TAF)**: [https://www.nuget.org/packages/Taf.Decoder](https://www.nuget.org/packages/Taf.Decoder)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **Licenca**: MIT
diff --git a/src/Metar.Decoder/Assets/nuget-readme.md b/src/Metar.Decoder/Assets/nuget-readme.md
new file mode 100644
index 0000000..11ac686
--- /dev/null
+++ b/src/Metar.Decoder/Assets/nuget-readme.md
@@ -0,0 +1,88 @@
+# Metar.Decoder
+
+A .NET library to decode METAR (Meteorological Aerodrome Report) strings into structured objects.
+
+Compatible with **.NET Standard 2.0**, **.NET 8.0**, **.NET 10.0**, and **.NET Framework 4.8**.
+
+---
+
+## Quick Start
+
+```csharp
+using Metar.Decoder;
+using Metar.Decoder.Entity;
+
+var decoded = MetarDecoder.ParseWithMode("METAR LFPO 231027Z 24004G09KT 2500 +FZRA FEW015 17/10 Q1009");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.ICAO}"); // "LFPO"
+ Console.WriteLine($"Wind: {decoded.SurfaceWind.MeanSpeed.ActualValue} {decoded.SurfaceWind.MeanSpeed.ActualUnit}");
+ Console.WriteLine($"Visibility: {decoded.Visibility.PrevailingVisibility.ActualValue}m");
+ Console.WriteLine($"Temperature: {decoded.AirTemperature.ActualValue}C");
+ Console.WriteLine($"Pressure: {decoded.Pressure.ActualValue} {decoded.Pressure.ActualUnit}");
+}
+```
+
+## Features
+
+- **Full METAR parsing**: Report type, ICAO, datetime, surface wind, visibility, RVR, present weather, clouds, temperature, dew point, pressure, recent weather, windshear, trend, remarks
+- **Strict and non-strict modes**: Continue parsing on errors or stop at first error
+- **Unit conversion**: Built-in conversion between speed, distance, and pressure units
+- **Null-safe**: All optional fields are nullable with safe access patterns
+- **Cross-platform**: Works on Windows, Linux, macOS
+
+## Decoded Properties
+
+| Property | Description |
+|----------|-------------|
+| `ICAO` | ICAO 4-letter airport code |
+| `SurfaceWind` | Wind direction, speed, gusts |
+| `Visibility` | Prevailing and minimum visibility |
+| `RunwaysVisualRange` | RVR per runway |
+| `PresentWeather` | Current weather phenomena |
+| `Clouds` | Cloud layers (amount, height, type) |
+| `AirTemperature` | Air temperature |
+| `DewPointTemperature` | Dew point temperature |
+| `Pressure` | QNH pressure |
+| `RecentWeather` | Recent weather |
+| `WindshearRunways` | Runways with windshear |
+| `TrendType` | Trend (NOSIG, BECMG, TEMPO) |
+| `Remark` | Remarks section (after RMK) |
+| `SeaLevelPressure` | SLP from remarks |
+
+## Unit Conversion
+
+```csharp
+// Convert wind speed to knots
+float knots = decoded.SurfaceWind.MeanSpeed.GetConvertedValue(Value.Unit.Knot);
+
+// Convert visibility to feet
+float feet = decoded.Visibility.PrevailingVisibility.GetConvertedValue(Value.Unit.Feet);
+
+// Convert pressure to inHg
+float inHg = decoded.Pressure.GetConvertedValue(Value.Unit.MercuryInch);
+```
+
+## Parsing Modes
+
+```csharp
+// Non-strict (default) - continues on errors
+var decoded = MetarDecoder.ParseWithMode(rawMetar);
+
+// Strict - stops at first error
+var decoded = MetarDecoder.ParseWithMode(rawMetar, isStrict: true);
+
+// Instance-based with global mode
+var decoder = new MetarDecoder();
+decoder.SetStrictParsing(true);
+var result = decoder.Parse(rawMetar);
+```
+
+## Documentation & Source
+
+- **Full Documentation**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **Usage Guide**: [https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/usage-guide.md](https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/usage-guide.md)
+- **API Reference**: [https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/api-reference.md](https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/api-reference.md)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **License**: MIT
diff --git a/src/Metar.Decoder/Entity/DecodedMetar.cs b/src/Metar.Decoder/Entity/DecodedMetar.cs
index ac0b2c7..4242657 100644
--- a/src/Metar.Decoder/Entity/DecodedMetar.cs
+++ b/src/Metar.Decoder/Entity/DecodedMetar.cs
@@ -103,6 +103,9 @@ public ReadOnlyCollection DecodingExceptions
///
public Visibility Visibility { get; set; }
+ ///
+ /// Ceiling And Visibility OK. When true, visibility is 10km or more, no cloud below 5000ft, and no significant weather.
+ ///
public bool Cavok { get; set; } = false;
///
diff --git a/src/Metar.Decoder/Entity/SurfaceWind.cs b/src/Metar.Decoder/Entity/SurfaceWind.cs
index 6d72f1e..cc868e0 100644
--- a/src/Metar.Decoder/Entity/SurfaceWind.cs
+++ b/src/Metar.Decoder/Entity/SurfaceWind.cs
@@ -1,7 +1,8 @@
namespace Metar.Decoder.Entity
{
///
- /// SurfaceWind
+ /// Represents surface wind information decoded from a METAR report,
+ /// including mean direction, speed, gusts, and variable direction range.
///
public sealed class SurfaceWind
{
@@ -11,7 +12,7 @@ public sealed class SurfaceWind
public Value MeanDirection { get; set; }
///
- /// Wind variability (if true, direction is null)
+ /// Indicates whether the wind direction is variable (VRB). When true, is null.
///
public bool VariableDirection { get; set; }
@@ -31,10 +32,10 @@ public sealed class SurfaceWind
public Value[] DirectionVariations { get; private set; } = null;
///
- /// SetDirectionVariations
+ /// Sets the variable wind direction boundaries (e.g., 180V240 means wind varies between 180 and 240 degrees).
///
- /// directionMax
- /// directionMin
+ /// Maximum wind direction in degrees.
+ /// Minimum wind direction in degrees.
public void SetDirectionVariations(Value directionMax, Value directionMin)
{
DirectionVariations = new Value[] { directionMax, directionMin };
diff --git a/src/Metar.Decoder/Entity/Value.cs b/src/Metar.Decoder/Entity/Value.cs
index 8b8bcb8..9a68414 100644
--- a/src/Metar.Decoder/Entity/Value.cs
+++ b/src/Metar.Decoder/Entity/Value.cs
@@ -7,23 +7,24 @@
namespace Metar.Decoder.Entity
{
///
- /// Value
+ /// Represents a numeric meteorological value with its associated unit of measurement.
+ /// Supports unit conversions for speed, distance, and pressure.
///
[DebuggerDisplay("{ActualValue} {ActualUnit}")]
public sealed class Value
{
///
- /// ActualValue
+ /// The numeric value in the original unit of measurement.
///
public double ActualValue { get; private set; }
///
- /// ActualUnit
+ /// The unit of measurement for this value.
///
public Unit ActualUnit { get; private set; }
///
- /// Unit
+ /// Enumeration of all supported units of measurement for meteorological values.
///
public enum Unit
{
diff --git a/src/Metar.Decoder/Entity/Visibility.cs b/src/Metar.Decoder/Entity/Visibility.cs
index ce9a4ed..272e8a7 100644
--- a/src/Metar.Decoder/Entity/Visibility.cs
+++ b/src/Metar.Decoder/Entity/Visibility.cs
@@ -1,7 +1,8 @@
namespace Metar.Decoder.Entity
{
///
- /// Visibility
+ /// Represents visibility information decoded from a METAR report,
+ /// including prevailing visibility, minimum directional visibility, and NDV indicator.
///
public sealed class Visibility
{
@@ -21,7 +22,7 @@ public sealed class Visibility
public string MinimumVisibilityDirection { get; set; }
///
- /// No Direction Visibility
+ /// No Directional Variation. When true, visibility is the same in all directions.
///
public bool NDV { get; set; } = false;
}
diff --git a/src/Metar.Decoder/Entity/WeatherPhenomenon.cs b/src/Metar.Decoder/Entity/WeatherPhenomenon.cs
index 7810b32..2c5233d 100644
--- a/src/Metar.Decoder/Entity/WeatherPhenomenon.cs
+++ b/src/Metar.Decoder/Entity/WeatherPhenomenon.cs
@@ -4,7 +4,9 @@
namespace Metar.Decoder.Entity
{
///
- /// WeatherPhenomenon
+ /// Represents a weather phenomenon decoded from a METAR or TAF report,
+ /// including intensity/proximity, descriptor characteristics (e.g., FZ, TS, SH),
+ /// and precipitation/obscuration types (e.g., RA, SN, FG, BR).
///
public sealed class WeatherPhenomenon
{
@@ -32,9 +34,9 @@ public ReadOnlyCollection Types
}
///
- /// AddType
+ /// Adds a weather type code (e.g., RA, SN, FG) to this phenomenon.
///
- /// type
+ /// The METAR/TAF weather type code to add.
public void AddType(string type)
{
_types.Add(type);
diff --git a/src/Metar.Decoder/Metar.Decoder.csproj b/src/Metar.Decoder/Metar.Decoder.csproj
index 4238839..5dad1f7 100644
--- a/src/Metar.Decoder/Metar.Decoder.csproj
+++ b/src/Metar.Decoder/Metar.Decoder.csproj
@@ -34,7 +34,7 @@
Metar.Decoder
Metar.Decoder;Metar;Decoder;netstandard2;NET8;NET6;FW48
A .NET library to decode METAR strings, this library package is netstandard 2.0. Working with Net Core and NET.
- README.md
+ nuget-readme.md
@@ -61,10 +61,9 @@
-
+
True
\
- Always
diff --git a/src/Taf.Decoder/Assets/nuget-readme.md b/src/Taf.Decoder/Assets/nuget-readme.md
new file mode 100644
index 0000000..0c7d455
--- /dev/null
+++ b/src/Taf.Decoder/Assets/nuget-readme.md
@@ -0,0 +1,99 @@
+# Taf.Decoder
+
+A .NET library to decode TAF (Terminal Aerodrome Forecast) strings into structured objects.
+
+Compatible with **.NET Standard 2.0**, **.NET 8.0**, **.NET 10.0**, and **.NET Framework 4.8**.
+
+---
+
+## Quick Start
+
+```csharp
+using Taf.Decoder;
+using Taf.Decoder.Entity;
+
+var decoded = TafDecoder.ParseWithMode(
+ "TAF LEMD 080500Z 0806/0912 23010KT 9999 SCT025 TX12/0816Z TN04/0807Z");
+
+if (decoded.IsValid)
+{
+ Console.WriteLine($"ICAO: {decoded.Icao}"); // "LEMD"
+ Console.WriteLine($"Wind: {decoded.SurfaceWind.MeanSpeed.ActualValue} {decoded.SurfaceWind.MeanSpeed.ActualUnit}");
+ Console.WriteLine($"Visibility: {decoded.Visibility.ActualVisibility.ActualValue}m");
+ Console.WriteLine($"Max Temp: {decoded.MaximumTemperature?.TemperatureValue.ActualValue}C");
+ Console.WriteLine($"Min Temp: {decoded.MinimumTemperature?.TemperatureValue.ActualValue}C");
+}
+```
+
+## Features
+
+- **Full TAF parsing**: Report type, ICAO, datetime, forecast period, surface wind, visibility, weather, clouds, temperatures, evolutions
+- **RTD Support**: Decodes "Report Delayed" TAF messages
+- **Evolution handling**: Parses BECMG, TEMPO, and PROB forecast changes
+- **Strict and non-strict modes**: Continue parsing on errors or stop at first error
+- **Unit conversion**: Built-in conversion between speed, distance, and pressure units
+- **Cross-platform**: Works on Windows, Linux, macOS
+
+## Decoded Properties
+
+| Property | Description |
+|----------|-------------|
+| `Icao` | ICAO 4-letter airport code |
+| `Type` | Report type: TAF, TAFAMD, TAFCOR, RTD |
+| `ForecastPeriod` | Valid period (FromDay/FromHour to ToDay/ToHour) |
+| `SurfaceWind` | Wind direction, speed, gusts |
+| `Visibility` | Prevailing visibility |
+| `Cavok` | CAVOK indicator |
+| `WeatherPhenomenons` | Weather phenomena |
+| `Clouds` | Cloud layers (amount, height, type) |
+| `MaximumTemperature` | Forecast maximum temperature with time |
+| `MinimumTemperature` | Forecast minimum temperature with time |
+| `Evolutions` | Forecast changes (BECMG, TEMPO, PROB) |
+
+## Supported Report Types
+
+| Type | Description |
+|------|-------------|
+| `TAF` | Standard TAF forecast |
+| `TAFAMD` | Amended TAF forecast |
+| `TAFCOR` | Corrected TAF forecast |
+| `RTD` | Report Delayed |
+
+## Evolutions (Forecast Changes)
+
+```csharp
+var decoded = TafDecoder.ParseWithMode(
+ "TAF EGLL 080500Z 0806/0906 24015G25KT 9999 BKN040 " +
+ "TEMPO 0806/0812 30018G30KT 3000 +SHRA BKN012CB " +
+ "BECMG 0812/0814 25010KT");
+
+foreach (var evo in decoded.Evolutions)
+{
+ Console.WriteLine($"{evo.Type}: {evo.FromDay}{evo.FromHour}Z-{evo.ToDay}{evo.ToHour}Z");
+ if (evo.SurfaceWind != null)
+ Console.WriteLine($" Wind: {evo.SurfaceWind.MeanSpeed?.ActualValue} {evo.SurfaceWind.MeanSpeed?.ActualUnit}");
+}
+```
+
+## Parsing Modes
+
+```csharp
+// Non-strict (default) - continues on errors
+var decoded = TafDecoder.ParseWithMode(rawTaf);
+
+// Strict - stops at first error
+var decoded = TafDecoder.ParseWithMode(rawTaf, isStrict: true);
+
+// Instance-based with global mode
+var decoder = new TafDecoder();
+decoder.SetStrictParsing(true);
+var result = decoder.Parse(rawTaf);
+```
+
+## Documentation & Source
+
+- **Full Documentation**: [https://github.com/afonsoft/metar-decoder](https://github.com/afonsoft/metar-decoder)
+- **Usage Guide**: [https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/usage-guide.md](https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/usage-guide.md)
+- **API Reference**: [https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/api-reference.md](https://github.com/afonsoft/metar-decoder/blob/main/docs/en-US/api-reference.md)
+- **Issues**: [https://github.com/afonsoft/metar-decoder/issues](https://github.com/afonsoft/metar-decoder/issues)
+- **License**: MIT
diff --git a/src/Taf.Decoder/Entity/DecodedTaf.cs b/src/Taf.Decoder/Entity/DecodedTaf.cs
index 24f21c8..a14fa66 100644
--- a/src/Taf.Decoder/Entity/DecodedTaf.cs
+++ b/src/Taf.Decoder/Entity/DecodedTaf.cs
@@ -95,6 +95,9 @@ public ReadOnlyCollection DecodingExceptions
///
public Visibility Visibility { get; set; }
+ ///
+ /// Ceiling And Visibility OK. When true, visibility is 10km or more, no cloud below 5000ft, and no significant weather.
+ ///
public bool Cavok { get; set; } = false;
///
diff --git a/src/Taf.Decoder/Entity/Temperature.cs b/src/Taf.Decoder/Entity/Temperature.cs
index 41454b0..086a3a5 100644
--- a/src/Taf.Decoder/Entity/Temperature.cs
+++ b/src/Taf.Decoder/Entity/Temperature.cs
@@ -18,7 +18,7 @@ public class Temperature : AbstractEntity
public int Day { get; set; }
///
- /// Hur of occurrence
+ /// Hour of occurrence (UTC)
///
public int Hour { get; set; }
}
diff --git a/src/Taf.Decoder/Taf.Decoder.csproj b/src/Taf.Decoder/Taf.Decoder.csproj
index afa3d91..7127cc3 100644
--- a/src/Taf.Decoder/Taf.Decoder.csproj
+++ b/src/Taf.Decoder/Taf.Decoder.csproj
@@ -34,7 +34,7 @@
Taf.Decoder
Taf.Decoder;Taf;Decoder;netstandard2;NET6;NET8;FW48
A .NET library to decode Taf strings, this library package is netstandard 2.0. Working with Net Core and NET.
- README.md
+ nuget-readme.md
@@ -61,10 +61,9 @@
-
+
True
\
- Always