/// <summary>
        /// Sign word-processing document with metadata signature
        /// </summary>
        public static void Run()
        {
            Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("[Example Basic Usage] # SignWordProcessingWithMetadata : Sign word-processing document with metadata signature\n");

            // The path to the documents directory.
            string filePath       = Constants.SAMPLE_WORDPROCESSING;
            string outputFilePath = Path.Combine(Constants.OutputPath, "SignWordProcessingWithMetadata", "SignedWithMetadata.docx");

            using (Signature signature = new Signature(filePath))
            {
                // create Metadata option with predefined Metadata text
                MetadataSignOptions options = new MetadataSignOptions();

                // Create few WordProcessing Metadata signatures
                WordProcessingMetadataSignature[] signatures = new WordProcessingMetadataSignature[]
                {
                    new WordProcessingMetadataSignature("Author", "Mr.Scherlock Holmes"), // String value
                    new WordProcessingMetadataSignature("CreatedOn", DateTime.Now),       // DateTime values
                    new WordProcessingMetadataSignature("DocumentId", 123456),            // Integer value
                    new WordProcessingMetadataSignature("SignatureId", 123.456D),         // Double value
                    new WordProcessingMetadataSignature("Amount", 123.456M),              // Decimal value
                    new WordProcessingMetadataSignature("Total", 123.456F)                // Float value
                };
                options.Signatures.AddRange(signatures);

                // sign document to file
                SignResult result = signature.Sign(outputFilePath, options);

                Console.WriteLine($"\nSource document signed successfully with {result.Succeeded.Count} signature(s).\nFile saved at {outputFilePath}.");
            }
        }
        /// <summary>
        /// Sign pdf document with metadata signature with customer object and encryption
        /// </summary>
        public static void Run()
        {
            Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("[Example Advanced Usage] # SignWithMetadataEncryptedObject : Sign pdf document with metadata signature with customer object and encryption\n");

            // The path to the documents directory.
            string filePath = Constants.SAMPLE_WORDPROCESSING;

            string outputFilePath = Path.Combine(Constants.OutputPath, "SignWithMetadataSecureCustom", "MetadataEncryptedObject.docx");

            using (Signature signature = new Signature(filePath))
            {
                // setup key and passphrase
                string key  = "1234567890";
                string salt = "1234567890";
                // create data encryption
                IDataEncryption encryption = new SymmetricEncryption(SymmetricAlgorithmType.Rijndael, key, salt);

                // setup options with text of signature
                MetadataSignOptions options = new MetadataSignOptions()
                {
                    // set encryption for all metadata signatures for this options
                    // if you need separate encryption use own MetadataSignature.DataEncryption property
                    DataEncryption = encryption
                };

                // create custom object
                DocumentSignatureData documentSignatureData = new DocumentSignatureData()
                {
                    ID         = Guid.NewGuid().ToString(),
                    Author     = Environment.UserName,
                    Signed     = DateTime.Now,
                    DataFactor = 11.22M
                };

                // setup signature metadata
                WordProcessingMetadataSignature mdSignature = new WordProcessingMetadataSignature("Signature", documentSignatureData);

                // setup signature metadata
                WordProcessingMetadataSignature mdAuthor = new WordProcessingMetadataSignature("Author", "Mr.Scherlock Holmes");

                // setup data of document id
                WordProcessingMetadataSignature mdDocId = new WordProcessingMetadataSignature("DocumentId", Guid.NewGuid().ToString());

                // add signatures to options
                options.Signatures.Add(mdSignature);
                options.Signatures.Add(mdAuthor);
                options.Signatures.Add(mdDocId);

                // sign document to file
                SignResult signResult = signature.Sign(outputFilePath, options);
                Console.WriteLine($"\nSource document signed successfully with {signResult.Succeeded.Count} signature(s).\nFile saved at {outputFilePath}.");
            }
        }
        /// <summary>
        /// Search document for metadata signature with applying specific options
        /// </summary>
        public static void Run()
        {
            Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("[Example Advanced Usage] # SearchForMetadataEncryptedObject : Search document for metadata signature with applying specific options\n");

            // The path to the documents directory.
            string filePath = Constants.SAMPLE_DOCX_METADATA_ENCRYPTED_OBJECT;

            using (Signature signature = new Signature(filePath))
            {
                // setup key and passphrase
                string key  = "1234567890";
                string salt = "1234567890";
                // create data encryption
                IDataEncryption encryption = new SymmetricEncryption(SymmetricAlgorithmType.Rijndael, key, salt);

                MetadataSearchOptions options = new MetadataSearchOptions()
                {
                    DataEncryption = encryption
                };

                // search for signatures in document
                List <WordProcessingMetadataSignature> signatures = signature.Search <WordProcessingMetadataSignature>(options);
                Console.WriteLine("\nSource document contains following signatures.");

                // get required metadata signatures
                WordProcessingMetadataSignature mdSignature = signatures.FirstOrDefault(p => p.Name == "Signature");
                if (mdSignature != null)
                {
                    DocumentSignatureData documentSignatureData = mdSignature.GetData <DocumentSignatureData>();
                    if (documentSignatureData != null)
                    {
                        Console.WriteLine("Signature has DocumentSignatureData object:\n ID = {0}, Author = {1}, Signed = {2}, DataFactor {3}",
                                          documentSignatureData.ID, documentSignatureData.Author, documentSignatureData.Signed.ToShortDateString(), documentSignatureData.DataFactor);
                    }
                }
                // get required metadata signatures
                WordProcessingMetadataSignature mdAuthor = signatures.FirstOrDefault(p => p.Name == "Author");
                if (mdAuthor != null)
                {
                    Console.WriteLine("Metadata signature found. Name : {0}. Value: {1}", mdAuthor.Name, mdAuthor.GetData <string>());
                }
                // get required metadata signatures
                WordProcessingMetadataSignature mdDocId = signatures.FirstOrDefault(p => p.Name == "DocumentId");
                if (mdDocId != null)
                {
                    Console.WriteLine("Metadata signature found. Name : {0}. Value: {1}", mdDocId.Name, mdDocId.GetData <string>());
                }
            }
        }
        /// <summary>
        /// Sign document with multiple signature types
        /// </summary>
        public static void Run()
        {
            Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------------");
            Console.WriteLine("[Example Basic Usage] # SignWithMultipleOptions : Sign document with multiple signature types \n");

            // The path to the documents directory.
            string filePath       = Constants.SAMPLE_WORDPROCESSING;
            string outputFilePath = Path.Combine(Constants.OutputPath, "SignWithMultiple", "SignWithMultiple.docx");

            using (Signature signature = new Signature(filePath))
            {
                // define several signature options of different types and settings
                TextSignOptions textOptions = new TextSignOptions("Text signature")
                {
                    VerticalAlignment   = VerticalAlignment.Top,
                    HorizontalAlignment = HorizontalAlignment.Left
                };
                BarcodeSignOptions barcodeOptions = new BarcodeSignOptions("123456")
                {
                    EncodeType = BarcodeTypes.Code128,
                    Left       = 0,
                    Top        = 150,
                    Height     = 50,
                    Width      = 200
                };
                QrCodeSignOptions qrcodeOptions = new QrCodeSignOptions("JohnSmith")
                {
                    EncodeType = QrCodeTypes.QR,
                    Left       = 0,
                    Top        = 220
                };
                DigitalSignOptions digitalOptions = new DigitalSignOptions(Constants.CertificatePfx)
                {
                    ImageFilePath = Constants.ImageHandwrite,
                    Left          = 20,
                    Top           = 400,
                    Height        = 100,
                    Width         = 100,
                    Password      = "******"
                };
                ImageSignOptions imageOptions = new ImageSignOptions(Constants.ImageStamp)
                {
                    Left   = 20,
                    Top    = 550,
                    Height = 100,
                    Width  = 100
                };
                MetadataSignOptions metaOptions = new MetadataSignOptions();
                WordProcessingMetadataSignature[] metaSignatures = new WordProcessingMetadataSignature[]
                {
                    new WordProcessingMetadataSignature("Author", "Mr.Scherlock Holmes"),
                    new WordProcessingMetadataSignature("CreatedOn", DateTime.Now)
                };
                metaOptions.Signatures.AddRange(metaSignatures);

                // define list of signature options
                List <SignOptions> listOptions = new List <SignOptions>();

                listOptions.Add(textOptions);
                listOptions.Add(barcodeOptions);
                listOptions.Add(qrcodeOptions);
                listOptions.Add(digitalOptions);
                listOptions.Add(imageOptions);
                listOptions.Add(metaOptions);

                // sign document to file
                SignResult result = signature.Sign(outputFilePath, listOptions);

                Console.WriteLine($"\nSource document signed successfully with {result.Succeeded.Count} signature(s).\nFile saved at {outputFilePath}.");
            }
        }