static void Main(string[] args)
        {
            string templateFileName = @"html template.htm";
            string pdfPath = @"test html template to pdf.pdf";
            FileStream templateAsStream = new FileStream(templateFileName, FileMode.Open, FileAccess.Read);

            ///////////
            //telerik
            ///////////

            

            try
            {               
                // Register the font 
                byte[] fontDataR = File.ReadAllBytes("Raleway-VariableFont_wght.ttf");
                System.Windows.Media.FontFamily fontFamilyR = new System.Windows.Media.FontFamily("Releway");
                byte[] fontDataRL = File.ReadAllBytes("Raleway-Light.ttf");
                System.Windows.Media.FontFamily fontFamilyRL = new System.Windows.Media.FontFamily("Releway Light");

                //Telerik.Windows.Documents.Fixed.Model.Fonts.
                FontsRepository.RegisterFont(fontFamilyR, System.Windows.FontStyles.Normal, System.Windows.FontWeights.Normal, fontDataR);
                FontsRepository.RegisterFont(fontFamilyRL, System.Windows.FontStyles.Normal, System.Windows.FontWeights.Normal, fontDataRL);

                byte[] fontDataRb = File.ReadAllBytes("Raleway-Bold.ttf");
                System.Windows.Media.FontFamily fontFamilyRb = new System.Windows.Media.FontFamily("Releway");
                //Telerik.Windows.Documents.Fixed.Model.Fonts.
                FontsRepository.RegisterFont(fontFamilyR, System.Windows.FontStyles.Normal, System.Windows.FontWeights.Bold, fontDataRb);


                //import AFTER setting fonts
                //Telerik.Windows.Documents.Flow.FormatProviders.Html.
                HtmlFormatProvider htmlProvider = new HtmlFormatProvider();
                HtmlImportSettings importSettings = new HtmlImportSettings();
                HtmlExportSettings exportSettings = new HtmlExportSettings();
                var document = htmlProvider.Import(templateAsStream);                

                PdfFormatProvider pdfProvider = new PdfFormatProvider();

                //Telerik.Windows.Documents.Extensibility.FontsProviderBase fontsProvider = new FontsProvider();
                //Telerik.Windows.Documents.Extensibility.FixedExtensibilityManager.FontsProvider = fontsProvider;

                PdfExportSettings pdfExportSettings = new PdfExportSettings();
                pdfExportSettings.ShouldEmbedFonts = true;

                pdfProvider.ExportSettings = pdfExportSettings;


                FileStream stream = File.Create("fixed pdf.pdf");
                var radFixedDocument = (new Telerik.Windows.Documents.Flow.FormatProviders.Pdf.PdfFormatProvider()).ExportToFixedDocument(document);
                var fixedFormatProvider = new Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider();
                fixedFormatProvider.Export(radFixedDocument, stream);
                stream.Close();

                //var resultBytes = pdfProvider.Export(document);
                //File.WriteAllBytes(pdfPath, resultBytes);

            }
            catch(Exception e)
            {
                throw e;
            }

using System;
using System.Collections.Generic;
using Telerik.Windows.Documents.Fixed.Model.Editing;
using Telerik.Windows.Documents.Fixed.Model.Fonts;

classTextJustify
{
    public static void InsertJustifiedBlock(FixedContentEditor PageEditor, string Text, int TextBoxWidth)
    {
        Block justifiedBlock = CreateJustifiedBlock(Text, TextBoxWidth, PageEditor.TextProperties.Font, PageEditor.TextProperties.FontSize);
        PageEditor.DrawBlock(justifiedBlock);
    }
    public static Block CreateJustifiedBlock(string Text, int TextBoxWidth, FontBase Font, double FontSize)
    {
        Block justifiedBlock = new Block();
        double currentSpacing = 0;
        double spacingStep = 1;
        string currentLine;

        if (Text.Length > 0)
        {
            {
                var withBlock = justifiedBlock.TextProperties;
                // Default word spacing.  Must be initialized to 0 before use. This defaults to Nothing/Null// and will not function correctly if not initialized.
                withBlock.WordSpacing = 0;
                withBlock.Font = Font;
                withBlock.FontSize = FontSize;
            }

            // We need a seperate block to use as a measuring tool using the same text properties as the justified block.
            Block measuringBlock = new Block(justifiedBlock);

            // Make sure the WordSpacing property is initialized to zero. // Break the text string into lines, adding as many full words as we can to each line.// This does not support hyphenation.  
            List<string> lines = breakIntoLines(Text, TextBoxWidth, ref measuringBlock);

            for (int i = 0; i <= lines.Count - 1; i++)
            {
                currentLine = lines[i];

                // For all except the last line, space out the words to fill the allowed space.if (i < (lines.Count - 1))
                {
                    do
                    {
                        // Set the word spacing before inserting the text.
                        measuringBlock.TextProperties.WordSpacing = currentSpacing;

                        // We need to reinsert the text each time the spacing changes since the spacing is only applied on insert
                        measuringBlock.Clear();
                        measuringBlock.InsertText(currentLine);
                        measuringBlock.Measure();
                        if (measuringBlock.DesiredSize.Width > TextBoxWidth && spacingStep != 0.01)
                        {
                            // Step back by one then narrow in at finer increments
                            currentSpacing -= spacingStep;
                            spacingStep /= 10;
                            currentSpacing += spacingStep;
                            continue;
                        }

                        currentSpacing += spacingStep;
                    }
                    while (measuringBlock.DesiredSize.Width > TextBoxWidth && spacingStep == 0.01);

                    // Reduce by one step to bring it back into allowed width
                    currentSpacing -= spacingStep;
                }

                // Add the line of text with the appropriate spacing.using (justifiedBlock.SaveTextProperties())
                {
                    justifiedBlock.TextProperties.WordSpacing = currentSpacing;
                    justifiedBlock.InsertText(currentLine);
                    justifiedBlock.InsertLineBreak();
                }

                // Reset for next line
                currentSpacing = 0; spacingStep = 1;
            }
        }

        return justifiedBlock;
    }

    private static List<string> breakIntoLines(string Text, int maxLineWidth, ref Block measuringBlock)
    {
        List<string> sResults = new List<string>();
        string[] lines = Text.Split(newstring[] { "\n", "\r\n" }, StringSplitOptions.None);

        foreach (string line in lines)
        {
            string[] words = line.Split(newstring[] { " " }, StringSplitOptions.RemoveEmptyEntries);

            sResults.Add(""); // Initialize the line.  This may remain empty if the line is blank.for (int i = 0; i <= words.Length - 1; i++)
            {
                if (sResults[sResults.Count - 1].Length == 0)

                    sResults[sResults.Count - 1] = words[i];

                else
                {
                    string testLine = string.Concat(sResults[sResults.Count - 1], " ", words[i]);

                    measuringBlock.InsertText(testLine);
                    measuringBlock.Measure();

                    if (measuringBlock.DesiredSize.Width <= maxLineWidth)
                        // Replace with new, longer line
                        sResults[sResults.Count - 1] = testLine;
                    else// Start new line
                        sResults.Add(words[i]);

                    // Remove text from measuring block to reset for next word
                    measuringBlock.Clear();
                }
            }
        }

        return sResults;
    }

}

        public void CreatePdf(Workbook wb, string fileName)
        {
            var fixedProvider = new Telerik.Windows.Documents.Spreadsheet.FormatProviders.Pdf.PdfFormatProvider();
            RadFixedDocument fixedDocument = fixedProvider.ExportToFixedDocument(wb);
                        

            var pdfFormatProvider = new Telerik.Windows.Documents.Fixed.FormatProviders.Pdf.PdfFormatProvider();
            pdfFormatProvider.ExportSettings.ShouldEmbedFonts = true;

             using (Stream output = File.OpenWrite($"c:\\temp\\{fileName}.pdf"))
            {
                pdfFormatProvider.Export(fixedDocument, output);
            }
        }

                RadFlowDocument document;

                Telerik.Documents.ImageUtils.ImagePropertiesResolver defaultImagePropertiesResolver = new Telerik.Documents.ImageUtils.ImagePropertiesResolver();
                Telerik.Windows.Documents.Extensibility.FixedExtensibilityManager.ImagePropertiesResolver = defaultImagePropertiesResolver;

                using (FileStream input = new FileStream("file.bin", FileMode.Create, System.IO.FileAccess.ReadWrite))
                {
                    input.Write(doc.Content, 0, doc.Content.Count());

                    DocxFormatProvider provider = new DocxFormatProvider();
                    document = provider.Import(input);

                    //insert the data
                    RadFlowDocumentEditor editor = new RadFlowDocumentEditor(document);

                    foreach (var item in templateValues)
                    {
                        editor.ReplaceText(item.Key, item.Value);
                    }

                    //change the value in the footer
                    editor.ReplaceText("[Document Revised Date]", doc.lastModified.ToShortDateString());

                    PdfFormatProvider pdfProvider = new PdfFormatProvider();
                    var result = pdfProvider.Export(document);

                    return result;

RadFlowDocument document = new RadFlowDocument(); 
document.Sections.AddSection(); 
 
document.Sections.First().Headers.Add(); // Creates the default Header. 
document.Sections.First().Headers.Add(HeaderFooterType.First); 
document.Sections.First().Headers.Add(HeaderFooterType.Even); 

'object' does not contain a definition for'Headers'and no accessible extension method 'Headers' accepting a first argument of type
 'object'could be found (are you missing a using directive or an assembly reference?)