protected ReadWorkspace(DocumentConfig path)
 {
     if (path == null)
     {
         throw new ArgumentNullException(nameof(path));
     }
     _path = new ConfigHelper<string>(path);
 }

 public OrderBy(DocumentConfig key)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _key = key;
 }

 /// <summary>
 /// Limits the documents passed to the child modules to those that satisfy the 
 /// supplied predicate. All original input documents are output without 
 /// modification regardless of whether they satisfy the predicate.
 /// </summary>
 /// <param name="predicate">A delegate that should return a <c>bool</c>.</param>
 public ConcatBranch Where(DocumentConfig predicate)
 {
     Func<IDocument, IExecutionContext, bool> currentPredicate = _predicate;
     _predicate = currentPredicate == null
         ? (Func<IDocument, IExecutionContext, bool>)(predicate.Invoke<bool>)
         : ((x, c) => currentPredicate(x, c) && predicate.Invoke<bool>(x, c));
     return this;
 }

 /// <summary>
 /// Uses a function to determine a text template which is processed and added as metadata for each document. 
 /// This allows you to specify different metadata for each document depending on the input.
 /// </summary>
 /// <param name="key">The metadata key for the generated text.</param>
 /// <param name="template">A delegate that returns the template to use.</param>
 public GenerateMeta(string key, DocumentConfig template) : base(template)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _key = key;
 }

 /// <summary>
 /// Defines the delegate that will be invoked against each input document to get the case comparison value.
 /// </summary>
 /// <param name="value">A delegate that returns an object to compare cases against.</param>
 public Switch(DocumentConfig value)
 {
     if (value == null)
     {
         throw new ArgumentNullException(nameof(value));
     }
     _value = value;
 }

 // This will get documents based on each input document - the result will be the aggregate of all returned documents for each input document
 // The delegate should return a IEnumerable<IDocument>
 public Documents(DocumentConfig documents)
 {
     if (documents == null)
     {
         throw new ArgumentNullException(nameof(documents));
     }
     _documentDocuments = documents;
 }

 protected ReadWorkspace(DocumentConfig path)
 {
     if (path == null)
     {
         throw new ArgumentNullException(nameof(path));
     }
     _pathDelegate = path;
 }

 /// <summary>
 /// Sets the metadata key <c>WriteFileName</c> to an optimized version of the return value of the delegate.
 /// Also sets the metadata key <c>WritePath</c> to <c>Path.Combine(RelativeFileDir, WriteFileName)</c>.
 /// </summary>
 /// <param name="fileName">A delegate that should return a <c>string</c> with the filename to optimize.</param>
 public FileName(DocumentConfig fileName)
 {
     if (fileName == null)
     {
         throw new ArgumentNullException(nameof(fileName));
     }
     _fileName = fileName;
 }

 /// <summary>
 /// Creates a sitemap using the specified delegate which should return either a <c>string</c> that
 /// contains the location for each input document or a <c>SitemapItem</c> instance with the location
 /// and other information.
 /// </summary>
 /// <param name="sitemapItemOrLocation">A delegate that either returns a <c>SitemapItem</c> instance or a <c>string</c> 
 /// with the desired item location. If the delegate returns <c>null</c>, the input document is not added to the sitemap.</param>
 /// <param name="locationFormatter">A location formatter that will be applied to the location of each input after
 /// getting the value of the specified metadata key.</param>
 public Sitemap(DocumentConfig sitemapItemOrLocation, Func<string, string> locationFormatter = null)
 {
     if (sitemapItemOrLocation == null)
     {
         throw new ArgumentNullException(nameof(sitemapItemOrLocation));
     }
     _sitemapItemOrLocation = sitemapItemOrLocation;
     _locationFormatter = locationFormatter;
 }

 public OrderBy ThenBy(DocumentConfig key)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _thenByList.Add(new ThenByEntry(key));
     return this;
 }

 /// <summary>
 /// Uses a function to determine an object to be added as metadata for each document. 
 /// This allows you to specify different metadata for each document depending on the input.
 /// </summary>
 /// <param name="key">The metadata key to set.</param>
 /// <param name="metadata">A delegate that returns the object to add as metadata.</param>
 public Meta(string key, DocumentConfig metadata)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _key = key;
     _metadata = new ConfigHelper<object>(metadata);
 }

 public Meta(string key, DocumentConfig metadata)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _key = key;
     _metadata = metadata ?? ((x, y) => null);
 }

        /// <summary>
        /// Reads all files that match the specified globbing patterns and/or absolute paths. This allows you to 
        /// specify different patterns and/or paths depending on the input.
        /// </summary>
        /// <param name="patterns">A delegate that returns one or more globbing patterns and/or absolute paths.</param>
        public ReadFiles(DocumentConfig patterns)
        {
            if (patterns == null)
            {
                throw new ArgumentNullException(nameof(patterns));
            }

            _patternsDelegate = patterns;
        }

 public GroupBy(DocumentConfig key, params IModule[] modules)
 {
     if (key == null)
     {
         throw new ArgumentNullException(nameof(key));
     }
     _key = key;
     _modules = modules;
 }

        /// <summary>
        /// Reads all files that match the specified path. This allows you to specify different search paths depending on the input.
        /// </summary>
        /// <param name="path">A delegate that returns a <c>string</c> with the search path.</param>
        public ReadFiles(DocumentConfig path)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            _path = path;
        }

        /// <summary>
        /// Uses a delegate to describe where to write the content of each document. 
        /// The output of the function should be either a full path to the disk 
        /// location (including file name) or a path relative to the output folder.
        /// </summary>
        /// <param name="path">A delegate that returns a <c>string</c> with the desired path.</param>
        public WriteFiles(DocumentConfig path)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            _path = path;
            _warnOnWriteMetadata = true;
        }

        /// <summary>
        /// Uses a delegate to describe where to find the sidecar file for each input document.
        /// If a sidecar file is found, it's content is passed to the specified child modules for processing.
        /// </summary>
        /// <param name="sidecarPath">A delegate that returns a <see cref="FilePath"/> with the desired sidecar path.</param>
        /// <param name="modules">The modules to execute against the sidecar file.</param>
        public Sidecar(DocumentConfig sidecarPath, params IModule[] modules)
        {
            if (sidecarPath == null)
            {
                throw new ArgumentNullException(nameof(sidecarPath));
            }

            _sidecarPath = sidecarPath;
            _modules = modules;
        }

 /// <summary>
 /// Appends the string value of the returned object to to content of each document. 
 /// This allows you to specify different content to append for each document depending 
 /// on the input document.
 /// </summary>
 /// <param name="content">A delegate that returns the content to append.</param>
 public Append(DocumentConfig content)
     : base(content)
 {
 }

 protected ContentModule(DocumentConfig content)
 {
     _content = new ConfigHelper<object>(content);
 }

 public UnwrittenFiles(DocumentConfig path)
     : base(path)
 {
 }