Notmat XLIFF Library

using Notmat;

// Automatically detect version and load XLIFF file
var (version, document) = XliffLoader.LoadXliff("translations.xliff");

if (version == XliffVersion.Version12)
{
    var xliff12 = (Xliff12.XliffDocument)document;
    // Work with XLIFF 1.2 document
}
else if (version == XliffVersion.Version20)
{
    var xliff20 = (Xliff20.XliffDocument)document;
    // Work with XLIFF 2.0 document
}

// Load specific versions directly
var xliff12Doc = XliffLoader.LoadXliff12("translations.xliff");
var xliff20Doc = XliffLoader.LoadXliff20("translations.xliff");

using Notmat.Xliff12;

// Create a new XLIFF 1.2 document
var xliffDoc = new XliffDocument();
var file = new XliffFile
{
    Original = "Resources.resx",
    SourceLanguage = "en-US",
    TargetLanguage = "fr-FR",
    DataType = "resx"
};

// Add translation units
var unit = new TranslationUnit
{
    Id = "welcome_message",
    ResourceName = "WelcomeMessage",
    Source = "Welcome to our application!",
    Target = "Bienvenue dans notre application!",
    State = TranslationState.Translated
};

file.Body.TranslationUnits.Add(unit);
xliffDoc.Files.Add(file);

// Save the document
XliffSaver.SaveXliff12(xliffDoc, "output.xliff");

using Notmat.Converters;

// Convert .resx to XLIFF 1.2
var xliff12 = ResxToXliffConverter.ConvertToXliff12(
    "Resources.resx", 
    "en-US", 
    "fr-FR"
);
XliffSaver.SaveXliff12(xliff12, "Resources.fr-FR.xliff");

// Convert .resx to XLIFF 2.0
var xliff20 = ResxToXliffConverter.ConvertToXliff20(
    "Resources.resx", 
    "en-US", 
    "es-ES"
);
XliffSaver.SaveXliff20(xliff20, "Resources.es-ES.xliff");

using Notmat.Converters;

// Convert XLIFF to .resx (using target text as values)
XliffToResxConverter.ConvertFile(
    "translations.xliff", 
    "Resources.fr-FR.resx", 
    useTargetAsValue: true,
    includeUntranslated: false
);

// Convert XLIFF document to .resx
var (version, document) = XliffLoader.LoadXliff("translations.xliff");
XliffToResxConverter.ConvertFromXliff(
    document, 
    "output.resx", 
    useTargetAsValue: true
);

// Set translation state
unit.State = TranslationState.Translated;

// Check if translation is complete
if (unit.State == TranslationState.Final || unit.State == TranslationState.SignedOff)
{
    // Translation is complete
}

// Find units that need translation
var pendingUnits = file.Body.TranslationUnits
    .Where(u => u.State == TranslationState.New || u.State == TranslationState.NeedsTranslation)
    .ToList();

using Notmat;

// Load the source XLIFF file
var (version, sourceDocument) = XliffLoader.LoadXliff("source.en-US.xliff");

if (version == XliffVersion.Version12 && sourceDocument is Xliff12.XliffDocument xliff12)
{
    // Create a new document for the target language
    var targetDoc = new Xliff12.XliffDocument();
    
    foreach (var sourceFile in xliff12.Files)
    {
        var targetFile = new Xliff12.XliffFile
        {
            Original = sourceFile.Original,
            SourceLanguage = sourceFile.SourceLanguage,
            TargetLanguage = "de-DE", // New target language
            DataType = sourceFile.DataType,
            Header = sourceFile.Header
        };
        
        // Copy translation units and reset states
        foreach (var sourceUnit in sourceFile.Body.TranslationUnits)
        {
            var targetUnit = new Xliff12.TranslationUnit
            {
                Id = sourceUnit.Id,
                ResourceName = sourceUnit.ResourceName,
                Source = sourceUnit.Source,
                Target = null, // Clear target for new language
                State = TranslationState.New // Reset state
            };
            
            targetFile.Body.TranslationUnits.Add(targetUnit);
        }
        
        targetDoc.Files.Add(targetFile);
    }
    
    // Save the new language file
    XliffSaver.SaveXliff12(targetDoc, "target.de-DE.xliff");
}

using Notmat;

public static class XliffLanguageHelper
{
    /// <summary>
    /// Creates a new XLIFF file for a target language based on an existing source file
    /// </summary>
    /// <param name="sourceFilePath">Path to the source XLIFF file</param>
    /// <param name="targetLanguage">Target language code (e.g., "de-DE")</param>
    /// <param name="outputPath">Output path for the new XLIFF file</param>
    /// <param name="preserveTranslations">Whether to preserve existing translations</param>
    public static void CreateLanguageVariant(string sourceFilePath, string targetLanguage, 
        string outputPath, bool preserveTranslations = false)
    {
        var (version, sourceDocument) = XliffLoader.LoadXliff(sourceFilePath);
        
        switch (version)
        {
            case XliffVersion.Version12 when sourceDocument is Xliff12.XliffDocument xliff12:
                CreateLanguageVariant12(xliff12, targetLanguage, outputPath, preserveTranslations);
                break;
                
            case XliffVersion.Version20 when sourceDocument is Xliff20.XliffDocument xliff20:
                CreateLanguageVariant20(xliff20, targetLanguage, outputPath, preserveTranslations);
                break;
                
            default:
                throw new NotSupportedException($"Unsupported XLIFF version: {version}");
        }
    }
    
    private static void CreateLanguageVariant12(Xliff12.XliffDocument source, string targetLanguage, 
        string outputPath, bool preserveTranslations)
    {
        var targetDoc = new Xliff12.XliffDocument();
        
        foreach (var sourceFile in source.Files)
        {
            var targetFile = new Xliff12.XliffFile
            {
                Original = sourceFile.Original,
                SourceLanguage = sourceFile.SourceLanguage,
                TargetLanguage = targetLanguage,
                DataType = sourceFile.DataType,
                Header = CloneHeader(sourceFile.Header)
            };
            
            foreach (var sourceUnit in sourceFile.Body.TranslationUnits)
            {
                var targetUnit = new Xliff12.TranslationUnit
                {
                    Id = sourceUnit.Id,
                    ResourceName = sourceUnit.ResourceName,
                    Source = sourceUnit.Source,
                    Target = preserveTranslations ? sourceUnit.Target : null,
                    State = preserveTranslations && !string.IsNullOrEmpty(sourceUnit.Target) 
                        ? sourceUnit.State 
                        : TranslationState.New
                };
                
                targetFile.Body.TranslationUnits.Add(targetUnit);
            }
            
            targetDoc.Files.Add(targetFile);
        }
        
        XliffSaver.SaveXliff12(targetDoc, outputPath);
    }
    
    private static void CreateLanguageVariant20(Xliff20.XliffDocument source, string targetLanguage, 
        string outputPath, bool preserveTranslations)
    {
        var targetDoc = new Xliff20.XliffDocument
        {
            SourceLanguage = source.SourceLanguage,
            TargetLanguage = targetLanguage
        };
        
        foreach (var sourceFile in source.Files)
        {
            var targetFile = new Xliff20.XliffFile
            {
                Id = sourceFile.Id,
                Original = sourceFile.Original,
                Header = CloneHeader20(sourceFile.Header)
            };
            
            foreach (var sourceUnit in sourceFile.Units)
            {
                var targetUnit = new Xliff20.TranslationUnit
                {
                    Id = sourceUnit.Id,
                    Name = sourceUnit.Name
                };
                
                foreach (var sourceSegment in sourceUnit.Segments)
                {
                    var targetSegment = new Xliff20.Segment
                    {
                        Id = sourceSegment.Id,
                        Source = sourceSegment.Source,
                        Target = preserveTranslations ? sourceSegment.Target : null,
                        State = preserveTranslations && !string.IsNullOrEmpty(sourceSegment.Target)
                            ? sourceSegment.State
                            : TranslationState.New
                    };
                    
                    targetUnit.Segments.Add(targetSegment);
                }
                
                targetFile.Units.Add(targetUnit);
            }
            
            targetDoc.Files.Add(targetFile);
        }
        
        XliffSaver.SaveXliff20(targetDoc, outputPath);
    }
    
    private static Xliff12.XliffHeader? CloneHeader(Xliff12.XliffHeader? source)
    {
        if (source == null) return null;
        
        return new Xliff12.XliffHeader
        {
            Tool = source.Tool != null ? new Xliff12.XliffTool
            {
                ToolId = source.Tool.ToolId,
                ToolName = source.Tool.ToolName,
                ToolVersion = source.Tool.ToolVersion
            } : null,
            Notes = source.Notes.ToList()
        };
    }
    
    private static Xliff20.XliffHeader? CloneHeader20(Xliff20.XliffHeader? source)
    {
        if (source == null) return null;
        
        return new Xliff20.XliffHeader
        {
            Tool = source.Tool != null ? new Xliff20.XliffTool
            {
                Id = source.Tool.Id,
                Name = source.Tool.Name,
                Version = source.Tool.Version
            } : null,
            Notes = source.Notes.ToList()
        };
    }
}

// Usage example:
XliffLanguageHelper.CreateLanguageVariant("source.en-US.xliff", "de-DE", "target.de-DE.xliff");