#line 1 "B3437BF2-8AE3-4281-8726-B926BB9DF75D"
/// <summary>
///            Determines whether or not the specified argument exist.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <returns>Whether or not the specified argument exist.</returns>
/// <example>
///            This sample shows how to call the <see cref="M:Cake.Common.ArgumentAliases.HasArgument(Cake.Core.ICakeContext,System.String)" /> method.
///            <code>
///            var argumentName = "myArgument";
///            //Cake.exe .\hasargument.cake -myArgument="is specified"
///            if (HasArgument(argumentName))
///            {
///                Information("{0} is specified", argumentName);
///            }
///            //Cake.exe .\hasargument.cake
///            else
///            {
///                Warning("{0} not specified", argumentName);
///            }
///            </code>
///            </example>
public System.Boolean HasArgument(System.String name)
{
    return Cake.Common.ArgumentAliases.HasArgument(Context, name);
}

/// <summary>
///            Gets an argument and throws if the argument is missing.
///            </summary>
/// <typeparam name="T">The argument type.</typeparam>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <returns>The value of the argument.</returns>
/// <example>
///            <code>
///            //Cake.exe .\argument.cake -myArgument="is valid" -loopCount = 5
///            Information("Argument {0}", Argument&lt;string&gt;("myArgument"));
///            var loopCount = Argument&lt;int&gt;("loopCount");
///            for(var index = 0;index&lt;loopCount; index++)
///            {
///                Information("Index {0}", index);
///            }
///            </code>
///            </example>
/// <exception cref="T:Cake.Core.CakeException">Argument value is null.</exception>
/// <exception cref="T:System.ArgumentNullException">
///  <paramref name="context" /> is null.</exception>
public T Argument<T>(System.String name)
{
    return Cake.Common.ArgumentAliases.Argument<T>(Context, name);
}

/// <summary>
///            Gets an argument and returns the provided <paramref name="defaultValue" /> if the argument is missing.
///            </summary>
/// <typeparam name="T">The argument type.</typeparam>
/// <param name="context">The context.</param>
/// <param name="name">The argument name.</param>
/// <param name="defaultValue">The value to return if the argument is missing.</param>
/// <returns>The value of the argument if it exist; otherwise <paramref name="defaultValue" />.</returns>
/// <example>
///            <code>
///            //Cake.exe .\argument.cake -myArgument="is valid" -loopCount = 5
///            Information("Argument {0}", Argument&lt;string&gt;("myArgument", "is NOT valid"));
///            var loopCount = Argument&lt;int&gt;("loopCount", 10);
///            for(var index = 0;index&lt;loopCount; index++)
///            {
///                Information("Index {0}", index);
///            }
///            </code>
///            </example>
public T Argument<T>(System.String name, T defaultValue)
{
    return Cake.Common.ArgumentAliases.Argument<T>(Context, name, defaultValue);
}

/// <summary>
///            Retrieves the value of the environment variable or <c>null</c> if the environment variable does not exist.
///            </summary>
/// <example>
///            <code>
///            Information(EnvironmentVariable("HOME") ?? "Unknown location");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="variable">The environment variable.</param>
/// <returns>The environment variable or <c>null</c> if the environment variable does not exist.</returns>
public System.String EnvironmentVariable(System.String variable)
{
    return Cake.Common.EnvironmentAliases.EnvironmentVariable(Context, variable);
}

/// <summary>
///             Retrieves all environment variables
///             </summary>
/// <example>
///             <code>
///             var envVars = EnvironmentVariables();
///            
///             string path;
///             if (envVars.TryGetValue("PATH", out path))
///             {
///                 Information("Path: {0}", path);
///             }
///            
///             foreach(var envVar in envVars)
///             {
///                 Information(
///                     "Key: {0}\tValue: \"{1}\"",
///                     envVar.Key,
///                     envVar.Value
///                     );
///             }
///             </code>
///             </example>
/// <param name="context">The context.</param>
/// <returns>The environment variables</returns>
public System.Collections.Generic.IDictionary<System.String, System.String> EnvironmentVariables()
{
    return Cake.Common.EnvironmentAliases.EnvironmentVariables(Context);
}

/// <summary>
///            Checks for the existence of a value for a given environment variable.
///            </summary>
/// <example>
///            <code>
///            if (HasEnvironmentVariable("SOME_ENVIRONMENT_VARIABLE"))
///            {
///                Information("The environment variable was present.");
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="variable">The environment variable.</param>
/// <returns>
///              <c>true</c> if the environment variable exist; otherwise <c>false</c>.
///            </returns>
public System.Boolean HasEnvironmentVariable(System.String variable)
{
    return Cake.Common.EnvironmentAliases.HasEnvironmentVariable(Context, variable);
}

/// <summary>
///            Determines whether the build script is running on Windows.
///            </summary>
/// <example>
///            <code>
///            if (IsRunningOnWindows())
///            {
///                Information("Windows!");
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>
///              <c>true</c> if the build script is running on Windows; otherwise <c>false</c>.
///            </returns>
public System.Boolean IsRunningOnWindows()
{
    return Cake.Common.EnvironmentAliases.IsRunningOnWindows(Context);
}

/// <summary>
///            Determines whether the build script running on a Unix or Linux based system.
///            </summary>
/// <example>
///            <code>
///            if (IsRunningOnUnix())
///            {
///                Information("Not Windows!");
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>
///              <c>true</c> if the build script running on a Unix or Linux based system; otherwise <c>false</c>.
///            </returns>
public System.Boolean IsRunningOnUnix()
{
    return Cake.Common.EnvironmentAliases.IsRunningOnUnix(Context);
}

/// <summary>
///            Starts the process resource that is specified by the filename.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">The file name.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
///            <code>
///            var exitCodeWithoutArguments = StartProcess("ping");
///            // This should output 1 as argument is missing
///            Information("Exit code: {0}", exitCodeWithoutArguments);
///            </code>
///            </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName)
{
    return Cake.Common.ProcessAliases.StartProcess(Context, fileName);
}

/// <summary>
///            Starts the process resource that is specified by the filename and arguments
///            </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="processArguments">The arguments used in the process settings.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
///            <code>
///            var exitCodeWithArgument = StartProcess("ping", "localhost");
///            // This should output 0 as valid arguments supplied
///            Information("Exit code: {0}", exitCodeWithArgument);
///            </code>
///            </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, System.String processArguments)
{
    return Cake.Common.ProcessAliases.StartProcess(Context, fileName, processArguments);
}

/// <summary>
///            Starts the process resource that is specified by the filename and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="settings">The settings.</param>
/// <returns>The exit code that the started process specified when it terminated.</returns>
/// <example>
///            <code>
///            var exitCodeWithArgument = StartProcess("ping", new ProcessSettings{ Arguments = "localhost" });
///            // This should output 0 as valid arguments supplied
///            Information("Exit code: {0}", exitCodeWithArgument);
///            </code>
///            </example>
public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings)
{
    return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings);
}

public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings, out System.Collections.Generic.IEnumerable<System.String> redirectedStandardOutput)
{
    return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings, out redirectedStandardOutput);
}

public System.Int32 StartProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings, out System.Collections.Generic.IEnumerable<System.String> redirectedStandardOutput, out System.Collections.Generic.IEnumerable<System.String> redirectedErrorOutput)
{
    return Cake.Common.ProcessAliases.StartProcess(Context, fileName, settings, out redirectedStandardOutput, out redirectedErrorOutput);
}

/// <summary>
///            Starts the process resource that is specified by the filename and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="settings">The settings.</param>
/// <returns>The newly started process.</returns>
/// <example>
///            <code>
///            using(var process = StartAndReturnProcess("ping", new ProcessSettings{ Arguments = "localhost" }))
///            {
///                process.WaitForExit();
///                // This should output 0 as valid arguments supplied
///                Information("Exit code: {0}", process.GetExitCode());
///            }
///            </code>
///            </example>
/// <exception cref="T:System.ArgumentNullException">
///  <paramref name="context" />, <paramref name="fileName" />, or <paramref name="settings" />  is null.</exception>
public Cake.Core.IO.IProcess StartAndReturnProcess(Cake.Core.IO.FilePath fileName, Cake.Core.IO.ProcessSettings settings)
{
    return Cake.Common.ProcessAliases.StartAndReturnProcess(Context, fileName, settings);
}

/// <summary>
///            Starts the process resource that is specified by the filename.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="fileName">Name of the file.</param>
/// <returns>The newly started process.</returns>
/// <example>
///            <code>
///            using(var process = StartAndReturnProcess("ping"))
///            {
///                process.WaitForExit();
///                // This should output 0 as valid arguments supplied
///                Information("Exit code: {0}", process.GetExitCode());
///            }
///            </code>
///            </example>
/// <exception cref="T:System.ArgumentNullException">
///  <paramref name="context" />, <paramref name="fileName" /> is null.</exception>
public Cake.Core.IO.IProcess StartAndReturnProcess(Cake.Core.IO.FilePath fileName)
{
    return Cake.Common.ProcessAliases.StartAndReturnProcess(Context, fileName);
}

/// <summary>
///            Parses all release notes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>All release notes.</returns>
/// <example>
///            <code>
///            var releaseNotes = ParseAllReleaseNotes("./ReleaseNotes.md");
///            foreach(var releaseNote in releaseNotes)
///            {
///                Information("Version: {0}", releaseNote.Version);
///                foreach(var note in releaseNote.Notes)
///                {
///                    Information("\t{0}", note);
///                }
///            }
///            </code>
///            </example>
public System.Collections.Generic.IReadOnlyList<Cake.Common.ReleaseNotes> ParseAllReleaseNotes(Cake.Core.IO.FilePath filePath)
{
    return Cake.Common.ReleaseNotesAliases.ParseAllReleaseNotes(Context, filePath);
}

/// <summary>
///            Parses the latest release notes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>The latest release notes.</returns>
/// <example>
///            <code>
///            var releaseNote = ParseReleaseNotes("./ReleaseNotes.md");
///            Information("Version: {0}", releaseNote.Version);
///            foreach(var note in releaseNote.Notes)
///            {
///                Information("\t{0}", note);
///            }
///            </code>
///            </example>
public Cake.Common.ReleaseNotes ParseReleaseNotes(Cake.Core.IO.FilePath filePath)
{
    return Cake.Common.ReleaseNotesAliases.ParseReleaseNotes(Context, filePath);
}

/// <summary>
///            Gets the value of a target node.
///            </summary>
/// <returns>The value found at the given XPath query.</returns>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the node to get.</param>
/// <example>
///            <code>
///            string autoFacVersion = XmlPeek("./src/Cake/packages.config", "/packages/package[@id='Autofac']/@version");
///            </code>
///            </example>
public System.String XmlPeek(Cake.Core.IO.FilePath filePath, System.String xpath)
{
    return Cake.Common.Xml.XmlPeekAliases.XmlPeek(Context, filePath, xpath);
}

/// <summary>
///            Get the value of a target node.
///            </summary>
/// <returns>The value found at the given XPath query.</returns>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="settings">Additional settings to tweak Xml Peek behavior.</param>
/// <example>
///            <code>
///            <para>XML document:</para>
///            <![CDATA[
///            <?xml version="1.0" encoding="UTF-8"?>
///            <pastery xmlns = "https://cakebuild.net/pastery" >
///                <cake price="1.62" />
///            </pastery>
///            ]]>
///            </code>
///            <para>XmlPeek usage:</para>
///            <code>
///            string version = XmlPeek("./pastery.xml", "/pastery:pastery/pastery:cake/@price",
///                new XmlPeekSettings {
///                    Namespaces = new Dictionary&lt;string, string&gt; {{ "pastery", "https://cakebuild.net/pastery" }}
///                });
///            string unknown = XmlPeek("./pastery.xml", "/pastery:pastery/pastery:cake/@recipe",
///                new XmlPeekSettings {
///                    Namespaces = new Dictionary&lt;string, string&gt; {{ "pastery", "https://cakebuild.net/pastery" }},
///                    SuppressWarning = true
///                });
///            </code>
///            </example>
public System.String XmlPeek(Cake.Core.IO.FilePath filePath, System.String xpath, Cake.Common.Xml.XmlPeekSettings settings)
{
    return Cake.Common.Xml.XmlPeekAliases.XmlPeek(Context, filePath, xpath, settings);
}

/// <summary>
///            Set the value of, or remove, target nodes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <example>
///              <para>
///              Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
///              to <c>productionhost.somecompany.com</c>.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
///            });
///                ]]>
///              </code>
///            </example>
/// <example>
///              <para>
///              Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
///            </Commands>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
///                    Namespaces = new Dictionary<string, string> {
///                        { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
///                    }
///                });
///            });
///                ]]>
///              </code>
///            <example>
///              <para>
///              Remove an app setting from a config file.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                    <add key="testing" value="true" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/configuration/appSettings/add[@testing]", null);
///            });
///                ]]>
///              </code>
///            </example>
///            <para>
///            Credit to NAnt for the original example.
///            http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
///            </para>
///            </example>
public void XmlPoke(Cake.Core.IO.FilePath filePath, System.String xpath, System.String value)
{
    Cake.Common.Xml.XmlPokeAliases.XmlPoke(Context, filePath, xpath, value);
}

/// <summary>
///            Set the value of, or remove, target nodes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The target file.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <param name="settings">Additional settings to tweak Xml Poke behavior.</param>
/// <example>
///              <para>
///              Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
///              to <c>productionhost.somecompany.com</c>.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
///            });
///                ]]>
///              </code>
///            </example>
/// <example>
///              <para>
///              Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
///            </Commands>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
///                    Namespaces = new Dictionary<string, string> {
///                        { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
///                    }
///                });
///            });
///                ]]>
///              </code>
///            <example>
///              <para>
///              Remove an app setting from a config file.
///              </para>
///              <para>XML file:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                    <add key="testing" value="true" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var file = File("test.xml");
///                XmlPoke(file, "/configuration/appSettings/add[@testing]", null);
///            });
///                ]]>
///              </code>
///            </example>
///            <para>
///            Credit to NAnt for the original example.
///            http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
///            </para>
///            </example>
public void XmlPoke(Cake.Core.IO.FilePath filePath, System.String xpath, System.String value, Cake.Common.Xml.XmlPokeSettings settings)
{
    Cake.Common.Xml.XmlPokeAliases.XmlPoke(Context, filePath, xpath, value, settings);
}

/// <summary>
///            Set the value of, or remove, target nodes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="sourceXml">The source xml to transform.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <returns>Resulting XML.</returns>
/// <example>
///              <para>
///              Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
///              to <c>productionhost.somecompany.com</c>.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
///            });
///                ]]>
///              </code>
///            </example>
/// <example>
///              <para>
///              Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
///            </Commands>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
///                    Namespaces = new Dictionary<string, string> {
///                        { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
///                    }
///                });
///            });
///                ]]>
///              </code>
///            <example>
///              <para>
///              Remove an app setting from a config file.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                    <add key="testing" value="true" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@testing]", null);
///            });
///                ]]>
///              </code>
///            </example>
///            <para>
///            Credit to NAnt for the original example.
///            http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
///            </para>
///            </example>
public System.String XmlPokeString(System.String sourceXml, System.String xpath, System.String value)
{
    return Cake.Common.Xml.XmlPokeAliases.XmlPokeString(Context, sourceXml, xpath, value);
}

/// <summary>
///            Set the value of, or remove, target nodes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="sourceXml">The source xml to transform.</param>
/// <param name="xpath">The xpath of the nodes to set.</param>
/// <param name="value">The value to set too. Leave blank to remove the selected nodes.</param>
/// <param name="settings">Additional settings to tweak Xml Poke behavior.</param>
/// <returns>Resulting XML.</returns>
/// <example>
///              <para>
///              Change the <c>server</c> setting in the configuration from <c>testhost.somecompany.com</c>
///              to <c>productionhost.somecompany.com</c>.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@key = 'server']/@value", "productionhost.somecompany.com");
///            });
///                ]]>
///              </code>
///            </example>
/// <example>
///              <para>
///              Modify the <c>noNamespaceSchemaLocation</c> in an XML file.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <Commands xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Path Value">
///            </Commands>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/Commands/@xsi:noNamespaceSchemaLocation", "d:\\Commands.xsd", new XmlPokeSettings {
///                    Namespaces = new Dictionary<string, string> {
///                        { /* Prefix */ "xsi", /* URI */ "http://www.w3.org/2001/XMLSchema-instance" }
///                    }
///                });
///            });
///                ]]>
///              </code>
///            <example>
///              <para>
///              Remove an app setting from a config file.
///              </para>
///              <para>XML string:</para>
///              <code>
///                <![CDATA[
///            <?xml version="1.0" encoding="utf-8" ?>
///            <configuration>
///                <appSettings>
///                    <add key="server" value="testhost.somecompany.com" />
///                    <add key="testing" value="true" />
///                </appSettings>
///            </configuration>
///                ]]>
///              </code>
///              <para>Cake Task:</para>
///              <code>
///                <![CDATA[
///            Task("Transform")
///                .Does(() =>
///            {
///                var result = XmlPokeString(xmlString, "/configuration/appSettings/add[@testing]", null);
///            });
///                ]]>
///              </code>
///            </example>
///            <para>
///            Credit to NAnt for the original example.
///            http://nant.sourceforge.net/release/latest/help/tasks/xmlpoke.html
///            </para>
///            </example>
public System.String XmlPokeString(System.String sourceXml, System.String xpath, System.String value, Cake.Common.Xml.XmlPokeSettings settings)
{
    return Cake.Common.Xml.XmlPokeAliases.XmlPokeString(Context, sourceXml, xpath, value, settings);
}

/// <summary>
///             Performs XML XSL transformation
///             </summary>
/// <param name="context">The context.</param>
/// <param name="xsl">XML style sheet.</param>
/// <param name="xml">XML data.</param>
/// <returns>Transformed XML string.</returns>
/// <example>
///             <code>
///             <para>This example code will convert xml to a new xml strucure using XmlTransform alias.</para>
///             <![CDATA[
///             string xsl = @"<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
///               <xsl:output method=""xml"" omit-xml-declaration=""yes"" />
///               <xsl:template match=""/"">
///                 <xsl:for-each select=""pastery/cake"" >
///                     <price><xsl:value-of select=""@price""/></price>
///                   </xsl:for-each>
///               </xsl:template>
///             </xsl:stylesheet>";
///            
///             string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
///             <pastery>
///                 <cake price=""1.62"" />
///             </pastery>";
///            
///             var priceTag = XmlTransform(xsl, xml);
///             ]]>
///             </code>
///             <para>Result:</para>
///             <code>
///             <![CDATA[<price>1.62</price>]]>
///             </code>
///             </example>
public System.String XmlTransform(System.String xsl, System.String xml)
{
    return Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xsl, xml);
}

/// <summary>
///             Performs XML XSL transformation
///             </summary>
/// <param name="context">The context.</param>
/// <param name="xsl">XML style sheet.</param>
/// <param name="xml">XML data.</param>
/// <param name="settings">Optional settings for result file xml writer</param>
/// <returns>Transformed XML string.</returns>
/// <example>
///             <code>
///             <para>This example code will convert specific part of xml to plaintext using XmlTransform alias.</para>
///             <![CDATA[string xsl = @"<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
///               <xsl:output method=""text"" omit-xml-declaration=""yes"" indent=""no""/>
///               <xsl:strip-space elements=""*""/>
///               <xsl:template match=""pastery/cake""><xsl:value-of select=""@price""/></xsl:template>
///             </xsl:stylesheet>";
///            
///             string xml = @"<?xml version=""1.0"" encoding=""UTF-8""?>
///             <pastery>
///                 <cake price=""1.62"" />
///             </pastery>";
///            
///             var text = XmlTransform(xsl, xml, new XmlTransformationSettings {
///                 ConformanceLevel = System.Xml.ConformanceLevel.Fragment, Encoding = Encoding.ASCII });
///             ]]>
///             </code>
///             </example>
public System.String XmlTransform(System.String xsl, System.String xml, Cake.Common.Xml.XmlTransformationSettings settings)
{
    return Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xsl, xml, settings);
}

/// <summary>
///            Performs XML XSL transformation
///            </summary>
/// <param name="context">The context.</param>
/// <param name="xslPath">Path to xml style sheet.</param>
/// <param name="xmlPath">Path xml data.</param>
/// <param name="resultPath">Transformation result path, will overwrite if exists.</param>
/// <example>
///            <code>
///            <para>This example code will convert the Cake nuspec into html using the XmlTransform alias.</para>
///            <para>XML stylesheet:</para>
///            <![CDATA[
///            <?xml version="1.0" ?>
///            <xsl:stylesheet
///              version="1.0"
///              xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
///              xmlns:p="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"
///              exclude-result-prefixes="p"
///              >
///              <xsl:output method="xml" indent="yes" omit-xml-declaration="yes" />
///              <xsl:template match="/">
///                <html lang="en" class="static">
///                  <head>
///                    <title>
///                      <xsl:for-each select="package/p:metadata">
///                          <xsl:value-of select="p:id"/>
///                      </xsl:for-each>
///                    </title>
///                  </head>
///                  <body>
///                      <xsl:for-each select="package/p:metadata">
///                        <h1>
///                          <xsl:value-of select="p:id"/>
///                        </h1>
///                        <h2>Description</h2>
///                        <i><xsl:value-of select="p:description"/></i>
///                      </xsl:for-each>
///                    <h3>Files</h3>
///                    <ul>
///                      <xsl:for-each select="package/files/file" >
///                        <li><xsl:value-of select="@src"/></li>
///                      </xsl:for-each>
///                    </ul>
///                  </body>
///                </html>
///              </xsl:template>
///            </xsl:stylesheet>
///            ]]>
///            </code>
///            <para>XmlTransform usage:</para>
///            <code>
///            XmlTransform("./nuspec.xsl", "./nuspec/Cake.nuspec", "./Cake.htm");
///            </code>
///            </example>
public void XmlTransform(Cake.Core.IO.FilePath xslPath, Cake.Core.IO.FilePath xmlPath, Cake.Core.IO.FilePath resultPath)
{
    Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xslPath, xmlPath, resultPath);
}

/// <summary>
///            Performs XML XSL transformation
///            </summary>
/// <param name="context">The context.</param>
/// <param name="xslPath">Path to xml style sheet.</param>
/// <param name="xmlPath">Path xml data.</param>
/// <param name="resultPath">Transformation result path.</param>
/// <param name="settings">Optional settings for result file xml writer</param>
/// <example>
///            <code>
///            <para>This example code will convert the Cake nuspec into html using the XmlTransform alias,
///            specifying that result should be indented and using Unicode encoding.</para>
///            <para>XML stylesheet:</para>
///            <![CDATA[
///            <?xml version="1.0" ?>
///            <xsl:stylesheet
///              version="1.0"
///              xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
///              xmlns:p="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"
///              exclude-result-prefixes="p"
///              >
///              <xsl:output method="xml" indent="yes" omit-xml-declaration="yes" />
///              <xsl:template match="/">
///                <html lang="en" class="static">
///                  <head>
///                    <title>
///                      <xsl:for-each select="package/p:metadata">
///                          <xsl:value-of select="p:id"/>
///                      </xsl:for-each>
///                    </title>
///                  </head>
///                  <body>
///                      <xsl:for-each select="package/p:metadata">
///                        <h1>
///                          <xsl:value-of select="p:id"/>
///                        </h1>
///                        <h2>Description</h2>
///                        <i><xsl:value-of select="p:description"/></i>
///                      </xsl:for-each>
///                    <h3>Files</h3>
///                    <ul>
///                      <xsl:for-each select="package/files/file" >
///                        <li><xsl:value-of select="@src"/></li>
///                      </xsl:for-each>
///                    </ul>
///                  </body>
///                </html>
///              </xsl:template>
///            </xsl:stylesheet>
///            ]]>
///            </code>
///            <para>XmlTransform usage:</para>
///            <code>
///            XmlTransform("./nuspec.xsl", "./nuspec/Cake.nuspec", "./Cake.htm",
///                new XmlTransformationSettings { Indent = true, Encoding = Encoding.Unicode});
///            </code>
///            </example>
public void XmlTransform(Cake.Core.IO.FilePath xslPath, Cake.Core.IO.FilePath xmlPath, Cake.Core.IO.FilePath resultPath, Cake.Common.Xml.XmlTransformationSettings settings)
{
    Cake.Common.Xml.XmlTransformationAlias.XmlTransform(Context, xslPath, xmlPath, resultPath, settings);
}

/// <summary>
///            Calculates the hash for a given file using the default (SHA256) algorithm.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <returns>A <see cref="T:Cake.Common.Security.FileHash" /> instance representing the calculated hash.</returns>
/// <example>
///            <code>
///            Information(
///               "Cake executable file SHA256 hash: {0}",
///               CalculateFileHash("Cake.exe").ToHex());
///            </code>
///            </example>
public Cake.Common.Security.FileHash CalculateFileHash(Cake.Core.IO.FilePath filePath)
{
    return Cake.Common.Security.SecurityAliases.CalculateFileHash(Context, filePath);
}

/// <summary>
///            Calculates the hash for a given file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="hashAlgorithm">The hash algorithm to use.</param>
/// <returns>A <see cref="T:Cake.Common.Security.FileHash" /> instance representing the calculated hash.</returns>
/// <example>
///            <code>
///            Information(
///                "Cake executable file MD5 hash: {0}",
///                CalculateFileHash("Cake.exe", HashAlgorithm.MD5).ToHex());
///            </code>
///            </example>
public Cake.Common.Security.FileHash CalculateFileHash(Cake.Core.IO.FilePath filePath, Cake.Common.Security.HashAlgorithm hashAlgorithm)
{
    return Cake.Common.Security.SecurityAliases.CalculateFileHash(Context, filePath, hashAlgorithm);
}

/// <summary>
///            Builds the specified solution using MSBuild or XBuild.
///            </summary>
/// <example>
///            <code>
///            DotNetBuild("./project/project.sln");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
public void DotNetBuild(Cake.Core.IO.FilePath solution)
{
    Cake.Common.Tools.DotNetBuildAliases.DotNetBuild(Context, solution);
}

/// <summary>
///            Builds the specified solution using MSBuild or XBuild.
///            </summary>
/// <example>
///            <code>
///            DotNetBuild("./project/project.sln", settings =&gt;
///                settings.SetConfiguration("Debug")
///                    .SetVerbosity(Core.Diagnostics.Verbosity.Minimal)
///                    .WithTarget("Build")
///                    .WithProperty("TreatWarningsAsErrors","true"));
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <param name="configurator">The configurator.</param>
public void DotNetBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.DotNetBuildSettings> configurator)
{
    Cake.Common.Tools.DotNetBuildAliases.DotNetBuild(Context, solution, configurator);
}

/// <summary>
///            Gets the legacy Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="latest">Get the latest version.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
///            <code>
///                var legacyInstallationPath = VSWhereLegacy(true);
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPath VSWhereLegacy(System.Boolean latest)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLegacy(Context, latest);
}

/// <summary>
///            Gets the legacy Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
///            <code>
///                 var legacyInstallationPaths = VSWhereLegacy(new VSWhereLegacySettings());
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereLegacy(Cake.Common.Tools.VSWhere.Legacy.VSWhereLegacySettings settings)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLegacy(Context, settings);
}

/// <summary>
///            Gets the latest Visual Studio product installation path.
///            </summary>
/// <param name="context">The context.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
///            <code>
///                var latestInstallationPath = VSWhereLatest();
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPath VSWhereLatest()
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLatest(Context);
}

/// <summary>
///            Gets the latest Visual Studio product installation path.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation path.</returns>
/// <example>
///            <code>
///                 var latestInstallationPath = VSWhereLatest(new VSWhereLatestSettings { Requires = "'Microsoft.Component.MSBuild" });
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPath VSWhereLatest(Cake.Common.Tools.VSWhere.Latest.VSWhereLatestSettings settings)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereLatest(Context, settings);
}

/// <summary>
///            Gets all Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
///            <code>
///                var latestInstallationPaths = VSWhereAll();
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereAll()
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereAll(Context);
}

/// <summary>
///            Gets all Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
///            <code>
///                var latestInstallationPaths = VSWhereAll(new VSWhereAllSettings { Requires = "'Microsoft.Component.MSBuild" });
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereAll(Cake.Common.Tools.VSWhere.All.VSWhereAllSettings settings)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereAll(Context, settings);
}

/// <summary>
///            Gets Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="products">The products to find.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
///            <code>
///                var latestInstallationPaths = VSWhereProducts("Microsoft.VisualStudio.Product.BuildTools");
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereProducts(System.String products)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereProducts(Context, products);
}

/// <summary>
///            Gets Visual Studio product installation paths.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="products">The products to find.</param>
/// <param name="settings">The settings.</param>
/// <returns>The Visual Studio installation paths.</returns>
/// <example>
///            <code>
///                var latestInstallationPaths = VSWhereProducts("Microsoft.VisualStudio.Product.BuildTools", new VSWhereProductSettings { Requires = "'Microsoft.Component.MSBuild" });
///            </code>
///            </example>
public Cake.Core.IO.DirectoryPathCollection VSWhereProducts(System.String products, Cake.Common.Tools.VSWhere.Product.VSWhereProductSettings settings)
{
    return Cake.Common.Tools.VSWhere.VSWhereAliases.VSWhereProducts(Context, products, settings);
}

/// <summary>
///            Runs all VSTest unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            VSTest("./Tests/*.UnitTests.dll");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void VSTest(System.String pattern)
{
    Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, pattern);
}

/// <summary>
///            Runs all VSTest unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            VSTest("./Tests/*.UnitTests.dll", new VSTestSettings() { Logger = VSTestLogger.Trx });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void VSTest(System.String pattern, Cake.Common.Tools.VSTest.VSTestSettings settings)
{
    Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, pattern, settings);
}

/// <summary>
///            Runs all VSTest unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
///            VSTest(paths);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
public void VSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
    Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, assemblyPaths);
}

/// <summary>
///            Runs all VSTest unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
///            VSTest(paths, new VSTestSettings() { InIsolation = true });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
public void VSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.VSTest.VSTestSettings settings)
{
    Cake.Common.Tools.VSTest.VSTestAliases.VSTest(Context, assemblyPaths, settings);
}

/// <summary>
///            Transform a text template.
///            </summary>
/// <example>
///            <code>
///            // Transform a .tt template.
///            var transform = File("./src/Cake/Transform.tt");
///            TransformTemplate(transform);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The source file.</param>
public void TransformTemplate(Cake.Core.IO.FilePath sourceFile)
{
    Cake.Common.Tools.TextTransform.TextTransformAliases.TransformTemplate(Context, sourceFile);
}

/// <summary>
///            Transform a text template.
///            </summary>
/// <example>
///            <code>
///            // Transform a .tt template.
///            var transform = File("./src/Cake/Transform.tt");
///            TransformTemplate(transform, new TextTransformSettings { OutputFile="./src/Cake/Transform.cs" });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The source file.</param>
/// <param name="settings">The settings.</param>
public void TransformTemplate(Cake.Core.IO.FilePath sourceFile, Cake.Common.Tools.TextTransform.TextTransformSettings settings)
{
    Cake.Common.Tools.TextTransform.TextTransformAliases.TransformTemplate(Context, sourceFile, settings);
}

/// <summary>
///            Creates a report that shows the usage and binding status of the steps for the entire project.
///            You can use this report to find both unused code in the automation layer and scenario steps that have no definition yet.
///            See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#step-definition-report">SpecFlow Documentation</see> for more information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
public void SpecFlowStepDefinitionReport(Cake.Core.IO.FilePath projectFile)
{
    Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowStepDefinitionReport(Context, projectFile);
}

/// <summary>
///            Creates a report that shows the usage and binding status of the steps for the entire project.
///            You can use this report to find both unused code in the automation layer and scenario steps that have no definition yet.
///            See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#step-definition-report">SpecFlow Documentation</see> for more information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
/// <param name="settings">The settings.</param>
public void SpecFlowStepDefinitionReport(Cake.Core.IO.FilePath projectFile, Cake.Common.Tools.SpecFlow.StepDefinitionReport.SpecFlowStepDefinitionReportSettings settings)
{
    Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowStepDefinitionReport(Context, projectFile, settings);
}

/// <summary>
///            Creates a formatted HTML report of a test execution.
///            The report contains a summary about the executed tests and the result and also a detailed report for the individual scenario executions.
///            See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#test-execution-report">SpecFlow Documentation</see> for more information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run SpecFlow for. Supported actions are: MSTest, NUnit3 and XUnit2</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
public void SpecFlowTestExecutionReport(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath projectFile)
{
    Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowTestExecutionReport(Context, action, projectFile);
}

/// <summary>
///            Creates a formatted HTML report of a test execution.
///            The report contains a summary about the executed tests and the result and also a detailed report for the individual scenario executions.
///            See <see href="https://github.com/techtalk/SpecFlow/wiki/Reporting#test-execution-report">SpecFlow Documentation</see> for more information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run SpecFlow for. Supported actions are: MSTest, NUNit, NUNit3, XUnit and XUnit2</param>
/// <param name="projectFile">The path of the project file containing the feature files.</param>
/// <param name="settings">The settings.</param>
public void SpecFlowTestExecutionReport(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath projectFile, Cake.Common.Tools.SpecFlow.TestExecutionReport.SpecFlowTestExecutionReportSettings settings)
{
    Cake.Common.Tools.SpecFlow.SpecFlowAliases.SpecFlowTestExecutionReport(Context, action, projectFile, settings);
}

/// <summary>
///            Converts the reports in the specified directory into human readable form.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <example>
///            <para>Provide only an input folder, which will causes ReportUnit to search entire directory for report files.</para>
///            <para>Cake task:</para>
///            <code>
///            ReportUnit("c:/temp");
///            </code>
///            </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder)
{
    Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder);
}

/// <summary>
///            Converts the reports in the specified directory into human readable form.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
///            <para>Provide an input folder and custom ToolPath, which will causes ReportUnit to search entire directory for report files.</para>
///            <para>Cake task:</para>
///            <code>
///            ReportUnit("c:/temp", new ReportUnitSettings(){
///                ToolPath = "c:/tools/reportunit.exe"
///            });
///            </code>
///            </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
    Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder, settings);
}

/// <summary>
///            Converts the reports in the specified directory into human readable form and outputs to specified folder.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="inputFolder">The input folder.</param>
/// <param name="outputFolder">The output folder.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
///            <para>Provide both input and output folder, which will causes ReportUnit to search entire directory for report files, and output the results to specified location.</para>
///            <para>Cake task:</para>
///            <code>
///            ReportUnit("c:/temp/input", "c:/temp/output");
///            </code>
///            </example>
public void ReportUnit(Cake.Core.IO.DirectoryPath inputFolder, Cake.Core.IO.DirectoryPath outputFolder, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
    Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFolder, outputFolder, settings);
}

/// <summary>
///            Converts the single specified report into human readable form and outputs to specified file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="inputFile">The input file.</param>
/// <param name="outputFile">The output file.</param>
/// <example>
///            <para>Provide both input and output file, which will causes ReportUnit to transform only the specific file, and output to the specified location.</para>
///            <para>Cake task:</para>
///            <code>
///            ReportUnit("c:/temp/input", "c:/temp/output");
///            </code>
///            </example>
public void ReportUnit(Cake.Core.IO.FilePath inputFile, Cake.Core.IO.FilePath outputFile)
{
    Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFile, outputFile);
}

/// <summary>
///            Converts the single specified report into human readable form and outputs to specified file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="inputFile">The input file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="settings">The ReportUnit settings.</param>
/// <example>
///            <para>Provide both input and output file, which will causes ReportUnit to transform only the specific file, and output to the specified location.  Also use a custom path for the reportunit.exe.</para>
///            <para>Cake task:</para>
///            <code>
///            ReportUnit("c:/temp/input", "c:/temp/output", new ReportUnitSettings(){
///                ToolPath = "c:/tools/reportunit.exe"
///            });
///            </code>
///            </example>
public void ReportUnit(Cake.Core.IO.FilePath inputFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.ReportUnit.ReportUnitSettings settings)
{
    Cake.Common.Tools.ReportUnit.ReportUnitAliases.ReportUnit(Context, inputFile, outputFile, settings);
}

/// <summary>
///            Converts the coverage report specified by the glob pattern into human readable form.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
///            <code>
///            ReportGenerator("c:/temp/coverage/*.xml", "c:/temp/output");
///            </code>
///            </example>
public void ReportGenerator(System.String pattern, Cake.Core.IO.DirectoryPath targetDir)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, pattern, targetDir);
}

/// <summary>
///            Converts the coverage report specified by the glob pattern into human readable form using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ReportGenerator("c:/temp/coverage/*.xml", "c:/temp/output", new ReportGeneratorSettings(){
///                ToolPath = "c:/tools/reportgenerator.exe"
///            });
///            </code>
///            </example>
public void ReportGenerator(System.String pattern, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, pattern, targetDir, settings);
}

/// <summary>
///            Converts the specified coverage report into human readable form.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="report">The coverage report.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
///            <code>
///            ReportGenerator("c:/temp/coverage/report.xml", "c:/temp/output");
///            </code>
///            </example>
public void ReportGenerator(Cake.Core.IO.FilePath report, Cake.Core.IO.DirectoryPath targetDir)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, report, targetDir);
}

/// <summary>
///            Converts the specified coverage report into human readable form using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="report">The coverage report.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ReportGenerator("c:/temp/coverage.xml", "c:/temp/output", new ReportGeneratorSettings(){
///                ToolPath = "c:/tools/reportgenerator.exe"
///            });
///            </code>
///            </example>
public void ReportGenerator(Cake.Core.IO.FilePath report, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, report, targetDir, settings);
}

/// <summary>
///            Converts the specified coverage reports into human readable form.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="reports">The coverage reports.</param>
/// <param name="targetDir">The output directory.</param>
/// <example>
///            <code>
///            ReportGenerator(new[] { "c:/temp/coverage1.xml", "c:/temp/coverage2.xml" }, "c:/temp/output");
///            </code>
///            </example>
public void ReportGenerator(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> reports, Cake.Core.IO.DirectoryPath targetDir)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, reports, targetDir);
}

/// <summary>
///            Converts the specified coverage reports into human readable form using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="reports">The coverage reports.</param>
/// <param name="targetDir">The output directory.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ReportGenerator(new[] { "c:/temp/coverage1.xml", "c:/temp/coverage2.xml" }, "c:/temp/output", new ReportGeneratorSettings(){
///                ToolPath = "c:/tools/reportgenerator.exe"
///            });
///            </code>
///            </example>
public void ReportGenerator(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> reports, Cake.Core.IO.DirectoryPath targetDir, Cake.Common.Tools.ReportGenerator.ReportGeneratorSettings settings)
{
    Cake.Common.Tools.ReportGenerator.ReportGeneratorAliases.ReportGenerator(Context, reports, targetDir, settings);
}

/// <summary>
///            Runs <see href="https://github.com/OpenCover/opencover">OpenCover</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run OpenCover for.</param>
/// <param name="outputFile">The OpenCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            OpenCover(tool =&gt; {
///              tool.XUnit2("./**/App.Tests.dll",
///                new XUnit2Settings {
///                  ShadowCopy = false
///                });
///              },
///              new FilePath("./result.xml"),
///              new OpenCoverSettings()
///                .WithFilter("+[App]*")
///                .WithFilter("-[App.Tests]*"));
///            </code>
///            </example>
public void OpenCover(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.OpenCover.OpenCoverSettings settings)
{
    Cake.Common.Tools.OpenCover.OpenCoverAliases.OpenCover(Context, action, outputFile, settings);
}

/// <summary>
///            Compiles the given NSIS script using the default settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.nsi</c> script file to compile.</param>
/// <example>
///            <code>
///            MakeNSIS("./src/Cake.nsi");
///            </code>
///            </example>
public void MakeNSIS(Cake.Core.IO.FilePath scriptFile)
{
    Cake.Common.Tools.NSIS.NSISAliases.MakeNSIS(Context, scriptFile);
}

/// <summary>
///            Compiles the given NSIS script using the given <paramref name="settings" />.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.nsi</c> script file to compile.</param>
/// <param name="settings">The <see cref="T:Cake.Common.Tools.NSIS.MakeNSISSettings" /> to use.</param>
/// <example>
///            <code>
///            MakeNSIS("./src/Cake.nsi", new MakeNSISSettings {
///                NoConfig = true
///                });
///            </code>
///            </example>
public void MakeNSIS(Cake.Core.IO.FilePath scriptFile, Cake.Common.Tools.NSIS.MakeNSISSettings settings)
{
    Cake.Common.Tools.NSIS.NSISAliases.MakeNSIS(Context, scriptFile, settings);
}

/// <summary>
///            Analyses the specified solution with Resharper's InspectCode.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <example>
///            <code>
///            InspectCode("./src/MySolution.sln");
///            </code>
///            </example>
public void InspectCode(Cake.Core.IO.FilePath solution)
{
    Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCode(Context, solution);
}

/// <summary>
///             Analyses the specified solution with Resharper's InspectCode,
///             using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var buildOutputDirectory = Directory("./.build");
///             var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///            
///             var msBuildProperties = new Dictionary&lt;string, string&gt;();
///             msBuildProperties.Add("configuration", configuration);
///             msBuildProperties.Add("platform", "AnyCPU");
///            
///             InspectCode("./MySolution.sln", new InspectCodeSettings {
///                 SolutionWideAnalysis = true,
///                 Profile = "./MySolution.sln.DotSettings",
///                 MsBuildProperties = msBuildProperties,
///                 OutputFile = resharperReportsDirectory + File("inspectcode-output.xml"),
///                 ThrowExceptionOnFindingViolations = true
///             });
///             </code>
///             </example>
public void InspectCode(Cake.Core.IO.FilePath solution, Cake.Common.Tools.InspectCode.InspectCodeSettings settings)
{
    Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCode(Context, solution, settings);
}

/// <summary>
///            Runs ReSharper's InspectCode using the specified config file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="configFile">The config file.</param>
/// <example>
///            <code>
///            InspectCodeFromConfig("./src/inspectcode.config");
///            </code>
///            </example>
public void InspectCodeFromConfig(Cake.Core.IO.FilePath configFile)
{
    Cake.Common.Tools.InspectCode.InspectCodeAliases.InspectCodeFromConfig(Context, configFile);
}

/// <summary>
///            Compiles the given Inno Setup script using the default settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.iss</c> script file to compile.</param>
/// <example>
///            <code>
///            InnoSetup("./src/Cake.iss");
///            </code>
///            </example>
public void InnoSetup(Cake.Core.IO.FilePath scriptFile)
{
    Cake.Common.Tools.InnoSetup.InnoSetupAliases.InnoSetup(Context, scriptFile);
}

/// <summary>
///            Compiles the given Inno Setup script using the given <paramref name="settings" />.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="scriptFile">The path to the <c>.iss</c> script file to compile.</param>
/// <param name="settings">The <see cref="T:Cake.Common.Tools.InnoSetup.InnoSetupSettings" /> to use.</param>
/// <example>
///            <code>
///            InnoSetup("./src/Cake.iss", new InnoSetupSettings {
///                OutputDir = outputDirectory
///                });
///            </code>
///            </example>
public void InnoSetup(Cake.Core.IO.FilePath scriptFile, Cake.Common.Tools.InnoSetup.InnoSetupSettings settings)
{
    Cake.Common.Tools.InnoSetup.InnoSetupAliases.InnoSetup(Context, scriptFile, settings);
}

/// <summary>
///            Merges the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <example>
///            <code>
///            var assemblyPaths = GetFiles("./**/Cake.*.dll");
///            ILRepack("./MergedCake.exe", "./Cake.exe", assemblyPaths);
///            </code>
///            </example>
public void ILRepack(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
    Cake.Common.Tools.ILRepack.ILRepackAliases.ILRepack(Context, outputFile, primaryAssembly, assemblyPaths);
}

/// <summary>
///            Merges the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var assemblyPaths = GetFiles("./**/Cake.*.dll");
///            ILRepack(
///                "./MergedCake.exe",
///                "./Cake.exe",
///                assemblyPaths,
///                new ILRepackSettings { Internalize = true });
///            </code>
///            </example>
public void ILRepack(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.ILRepack.ILRepackSettings settings)
{
    Cake.Common.Tools.ILRepack.ILRepackAliases.ILRepack(Context, outputFile, primaryAssembly, assemblyPaths, settings);
}

/// <summary>
///            Retrieves the GitVersion output.
///            </summary>
/// <param name="context">The context.</param>
/// <returns>The git version info.</returns>
/// <example>
///            <para>Update the assembly info files for the project.</para>
///            <para>Cake task:</para>
///            <code>
///            <![CDATA[
///            Task("UpdateAssemblyInfo")
///                .Does(() =>
///            {
///                GitVersion(new GitVersionSettings {
///                    UpdateAssemblyInfo = true
///                });
///            });
///            ]]>
///            </code>
///            <para>Get the git version info for the project using a dynamic repository.</para>
///            <para>Cake task:</para>
///            <code>
///            <![CDATA[
///            Task("GetVersionInfo")
///                .Does(() =>
///            {
///                var result = GitVersion(new GitVersionSettings {
///                    UserName = "MyUser",
///                    Password = "MyPassword,
///                    Url = "http://git.myhost.com/myproject.git"
///                    Branch = "develop"
///                    Commit = EnviromentVariable("MY_COMMIT")
///                });
///                // Use result for building nuget packages, setting build server version, etc...
///            });
///            ]]>
///            </code>
///            </example>
public Cake.Common.Tools.GitVersion.GitVersion GitVersion()
{
    return Cake.Common.Tools.GitVersion.GitVersionAliases.GitVersion(Context);
}

/// <summary>
///            Retrieves the GitVersion output.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The GitVersion settings.</param>
/// <returns>The git version info.</returns>
/// <example>
///            <para>Update the assembly info files for the project.</para>
///            <para>Cake task:</para>
///            <code>
///            <![CDATA[
///            Task("UpdateAssemblyInfo")
///                .Does(() =>
///            {
///                GitVersion(new GitVersionSettings {
///                    UpdateAssemblyInfo = true
///                });
///            });
///            ]]>
///            </code>
///            <para>Get the git version info for the project using a dynamic repository.</para>
///            <para>Cake task:</para>
///            <code>
///            <![CDATA[
///            Task("GetVersionInfo")
///                .Does(() =>
///            {
///                var result = GitVersion(new GitVersionSettings {
///                    UserName = "MyUser",
///                    Password = "MyPassword,
///                    Url = "http://git.myhost.com/myproject.git"
///                    Branch = "develop"
///                    Commit = EnviromentVariable("MY_COMMIT")
///                });
///                // Use result for building nuget packages, setting build server version, etc...
///            });
///            ]]>
///            </code>
///            </example>
public Cake.Common.Tools.GitVersion.GitVersion GitVersion(Cake.Common.Tools.GitVersion.GitVersionSettings settings)
{
    return Cake.Common.Tools.GitVersion.GitVersionAliases.GitVersion(Context, settings);
}

/// <summary>
///            Generates a set of release notes based on the commit history of the repository and specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseNotes("c:/temp/releasenotes.md", new GitReleaseNotesSettings {
///                WorkingDirectory         = "c:/temp",
///                Verbose                  = true,
///                IssueTracker             = IssueTracker.GitHub,
///                AllTags                  = true,
///                RepoUserName             = "bob",
///                RepoPassword             = "password",
///                RepoUrl                  = "http://myrepo.co.uk",
///                RepoBranch               = "master",
///                IssueTrackerUrl          = "http://myissuetracker.co.uk",
///                IssueTrackerUserName     = "bob",
///                IssueTrackerPassword     = "password",
///                IssueTrackerProjectId    = "1234",
///                Categories               = "Category1",
///                Version                  = "1.2.3.4",
///                AllLabels                = true
///            });
///            </code>
///            </example>
public void GitReleaseNotes(Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.GitReleaseNotes.GitReleaseNotesSettings settings)
{
    Cake.Common.Tools.GitReleaseNotes.GitReleaseNotesAliases.GitReleaseNotes(Context, outputFile, settings);
}

/// <summary>
///            Creates a Package Release.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <example>
///            <code>
///            GitReleaseManagerCreate("user", "password", "owner", "repo");
///            </code>
///            </example>
/// <example>
///            <code>
///            GitReleaseManagerCreate("user", "password", "owner", "repo");
///            </code>
///            </example>
public void GitReleaseManagerCreate(System.String userName, System.String password, System.String owner, System.String repository)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerCreate(Context, userName, password, owner, repository);
}

/// <summary>
///            Creates a Package Release using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseManagerCreate("user", "password", "owner", "repo", new GitReleaseManagerCreateSettings {
///                Milestone         = "0.1.0",
///                Prerelease        = false,
///                Assets            = "c:/temp/asset1.txt,c:/temp/asset2.txt",
///                TargetCommitish   = "master",
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
/// <example>
///            <code>
///            GitReleaseManagerCreate("user", "password", "owner", "repo", new GitReleaseManagerCreateSettings {
///                Name              = "0.1.0",
///                InputFilePath     = "c:/repo/releasenotes.md",
///                Prerelease        = false,
///                Assets            = "c:/temp/asset1.txt,c:/temp/asset2.txt",
///                TargetCommitish   = "master",
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
public void GitReleaseManagerCreate(System.String userName, System.String password, System.String owner, System.String repository, Cake.Common.Tools.GitReleaseManager.Create.GitReleaseManagerCreateSettings settings)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerCreate(Context, userName, password, owner, repository, settings);
}

/// <summary>
///            Add Assets to an existing release.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="assets">The assets.</param>
/// <example>
///            <code>
///            GitReleaseManagerAddAssets("user", "password", "owner", "repo", "0.1.0", "c:/temp/asset1.txt,c:/temp/asset2.txt");
///            </code>
///            </example>
public void GitReleaseManagerAddAssets(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, System.String assets)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerAddAssets(Context, userName, password, owner, repository, tagName, assets);
}

/// <summary>
///            Add Assets to an existing release using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="assets">The assets.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseManagerAddAssets("user", "password", "owner", "repo", "0.1.0", "c:/temp/asset1.txt,c:/temp/asset2.txt" new GitReleaseManagerAddAssetsSettings {
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
public void GitReleaseManagerAddAssets(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, System.String assets, Cake.Common.Tools.GitReleaseManager.AddAssets.GitReleaseManagerAddAssetsSettings settings)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerAddAssets(Context, userName, password, owner, repository, tagName, assets, settings);
}

/// <summary>
///            Closes the milestone associated with a release.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="milestone">The milestone.</param>
/// <example>
///            <code>
///            GitReleaseManagerClose("user", "password", "owner", "repo", "0.1.0");
///            </code>
///            </example>
public void GitReleaseManagerClose(System.String userName, System.String password, System.String owner, System.String repository, System.String milestone)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerClose(Context, userName, password, owner, repository, milestone);
}

/// <summary>
///            Closes the milestone associated with a release using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="milestone">The milestone.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseManagerClose("user", "password", "owner", "repo", "0.1.0", new GitReleaseManagerCloseMilestoneSettings {
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
public void GitReleaseManagerClose(System.String userName, System.String password, System.String owner, System.String repository, System.String milestone, Cake.Common.Tools.GitReleaseManager.Close.GitReleaseManagerCloseMilestoneSettings settings)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerClose(Context, userName, password, owner, repository, milestone, settings);
}

/// <summary>
///            Publishes the release.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <example>
///            <code>
///            GitReleaseManagerPublish("user", "password", "owner", "repo", "0.1.0");
///            </code>
///            </example>
public void GitReleaseManagerPublish(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerPublish(Context, userName, password, owner, repository, tagName);
}

/// <summary>
///            Publishes the release using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="tagName">The tag name.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseManagerPublish("user", "password", "owner", "repo", "0.1.0", new GitReleaseManagerPublishSettings {
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
public void GitReleaseManagerPublish(System.String userName, System.String password, System.String owner, System.String repository, System.String tagName, Cake.Common.Tools.GitReleaseManager.Publish.GitReleaseManagerPublishSettings settings)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerPublish(Context, userName, password, owner, repository, tagName, settings);
}

/// <summary>
///            Exports the release notes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="fileOutputPath">The output file path.</param>
/// <example>
///            <code>
///            GitReleaseManagerExport("user", "password", "owner", "repo", "c:/temp/releasenotes.md")
///            });
///            </code>
///            </example>
public void GitReleaseManagerExport(System.String userName, System.String password, System.String owner, System.String repository, Cake.Core.IO.FilePath fileOutputPath)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerExport(Context, userName, password, owner, repository, fileOutputPath);
}

/// <summary>
///            Exports the release notes using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="userName">The user name.</param>
/// <param name="password">The password.</param>
/// <param name="owner">The owner.</param>
/// <param name="repository">The repository.</param>
/// <param name="fileOutputPath">The output file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitReleaseManagerExport("user", "password", "owner", "repo", "c:/temp/releasenotes.md", new GitReleaseManagerExportSettings {
///                TagName           = "0.1.0",
///                TargetDirectory   = "c:/repo",
///                LogFilePath       = "c:/temp/grm.log"
///            });
///            </code>
///            </example>
public void GitReleaseManagerExport(System.String userName, System.String password, System.String owner, System.String repository, Cake.Core.IO.FilePath fileOutputPath, Cake.Common.Tools.GitReleaseManager.Export.GitReleaseManagerExportSettings settings)
{
    Cake.Common.Tools.GitReleaseManager.GitReleaseManagerAliases.GitReleaseManagerExport(Context, userName, password, owner, repository, fileOutputPath, settings);
}

/// <summary>
///            Update pdb files to link all sources.
///            This will allow anyone to step through the source code while debugging without a symbol source server.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="repositoryRootPath">The Solution File to analyze.</param>
/// <example>
///            <code>
///            GitLink("C:/temp/solution");
///            </code>
///            </example>
public void GitLink(Cake.Core.IO.DirectoryPath repositoryRootPath)
{
    Cake.Common.Tools.GitLink.GitLinkAliases.GitLink(Context, repositoryRootPath);
}

/// <summary>
///            Update pdb files to link all sources, using specified settings.
///            This will allow anyone to step through the source code while debugging without a symbol source server.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="repositoryRootPath">The path to the Root of the Repository to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            GitLink("C:/temp/solution", new GitLinkSettings {
///                RepositoryUrl = "http://mydomain.com",
///                Branch        = "master",
///                ShaHash       = "abcdef",
///            });
///            </code>
///            </example>
public void GitLink(Cake.Core.IO.DirectoryPath repositoryRootPath, Cake.Common.Tools.GitLink.GitLinkSettings settings)
{
    Cake.Common.Tools.GitLink.GitLinkAliases.GitLink(Context, repositoryRootPath, settings);
}

/// <summary>
///            Runs all Fixie tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            Fixie("./src/UnitTests/*.dll");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void Fixie(System.String pattern)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, pattern);
}

/// <summary>
///            Runs all Fixie tests in the assemblies matching the specified pattern,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            Fixie("./src/UnitTests/*.dll", new FixieSettings {
///                NUnitXml = TestResult.xml
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.String pattern, Cake.Common.Tools.Fixie.FixieSettings settings)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, pattern, settings);
}

/// <summary>
///            Runs all Fixie tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var assemblies = new [] {
///                "UnitTests1.dll",
///                "UnitTests2.dll"
///            };
///            Fixie(assemblies);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void Fixie(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies);
}

/// <summary>
///            Runs all Fixie tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var assemblies = GetFiles("./src/UnitTests/*.dll");
///            Fixie(assemblies);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void Fixie(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies);
}

/// <summary>
///            Runs all Fixie tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            var assemblies = new [] {
///                "UnitTests1.dll",
///                "UnitTests2.dll"
///            };
///            Fixie(assemblies, new FixieSettings {
///                NUnitXml = TestResult.xml
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.Fixie.FixieSettings settings)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies, settings);
}

/// <summary>
///            Runs all Fixie tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            var assemblies = GetFiles("./src/UnitTests/*.dll");
///            Fixie(assemblies, new FixieSettings {
///                NUnitXml = TestResult.xml
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void Fixie(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.Fixie.FixieSettings settings)
{
    Cake.Common.Tools.Fixie.FixieAliases.Fixie(Context, assemblies, settings);
}

/// <summary>
///            Analyses the specified file with ReSharper's DupFinder.
///            The file can either be a solution/project or a source file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="file">The file to analyze.</param>
/// <example>
///            <code>
///            DupFinder("./src/MySolution.sln");
///            </code>
///            </example>
public void DupFinder(Cake.Core.IO.FilePath file)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, file);
}

/// <summary>
///             Analyses the specified file with ReSharper's DupFinder using the specified settings.
///             The file can either be a solution/project or a source file.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="file">The file to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var buildOutputDirectory = Directory("./.build");
///             var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///             var rootDirectoryPath = MakeAbsolute(Context.Environment.WorkingDirectory);
///            
///             DupFinder("./src/MySolution.sln", new DupFinderSettings {
///                 ShowStats = true,
///                 ShowText = true,
///                 ExcludePattern = new String[]
///                 {
///                     rootDirectoryPath + "/**/*Designer.cs",
///                 },
///                 OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
///                 ThrowExceptionOnFindingDuplicates = true
///             });
///             </code>
///             </example>
public void DupFinder(Cake.Core.IO.FilePath file, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, file, settings);
}

/// <summary>
///            Analyses the specified projects with ReSharper's DupFinder.
///            The files can either be solutions and projects or a source files.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="files">The files to analyze.</param>
/// <example>
///            <code>
///            var projects = GetFiles("./src/**/*.csproj");
///            DupFinder(projects);
///            </code>
///            </example>
public void DupFinder(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> files)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, files);
}

/// <summary>
///             Analyses the specified projects with ReSharper's DupFinder using the specified settings.
///             The files can either be solutions and projects or a source files.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="files">The files to analyze.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var buildOutputDirectory = Directory("./.build");
///             var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///             var rootDirectoryPath = MakeAbsolute(Context.Environment.WorkingDirectory);
///            
///             var projects = GetFiles("./src/**/*.csproj");
///             DupFinder(projects, new DupFinderSettings {
///                 ShowStats = true,
///                 ShowText = true,
///                 ExcludePattern = new String[]
///                 {
///                     rootDirectoryPath + "/**/*Designer.cs",
///                 },
///                 OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
///                 ThrowExceptionOnFindingDuplicates = true
///             });
///             </code>
///             </example>
public void DupFinder(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> files, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, files, settings);
}

/// <summary>
///            Analyses all files matching the specified pattern with ReSharper's DupFinder.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            DupFinder("*.cs");
///            </code>
///            </example>
public void DupFinder(System.String pattern)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, pattern);
}

/// <summary>
///             Analyses all files matching the specified pattern with ReSharper's DupFinder,
///             using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var buildOutputDirectory = Directory("./.build");
///             var resharperReportsDirectory = buildOutputDirectory + Directory("_ReSharperReports");
///            
///             DupFinder("*.cs", new DupFinderSettings {
///                 OutputFile = resharperReportsDirectory + File("dupfinder-output.xml"),
///             });
///             </code>
///             </example>
public void DupFinder(System.String pattern, Cake.Common.Tools.DupFinder.DupFinderSettings settings)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinder(Context, pattern, settings);
}

/// <summary>
///            Runs ReSharper's DupFinder using the provided config file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="configFile">The config file.</param>
/// <example>
///            <code>
///            DupFinderFromConfig("./src/dupfinder.config");
///            </code>
///            </example>
public void DupFinderFromConfig(Cake.Core.IO.FilePath configFile)
{
    Cake.Common.Tools.DupFinder.DupFinderAliases.DupFinderFromConfig(Context, configFile);
}

/// <summary>
///            Execute an assembly.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <example>
///            <code>
///                DotNetCoreExecute("./bin/Debug/app.dll");
///            </code>
///            </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath);
}

/// <summary>
///            Execute an assembly with arguments in the specific path.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
///            <code>
///                DotNetCoreExecute("./bin/Debug/app.dll", "--arg");
///            </code>
///            </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath, arguments);
}

/// <summary>
///             Execute an assembly with arguments in the specific path with settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyPath">The assembly path.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreExecuteSettings
///                 {
///                     FrameworkVersion = "1.0.3"
///                 };
///            
///                 DotNetCoreExecute("./bin/Debug/app.dll", "--arg", settings);
///             </code>
///             </example>
public void DotNetCoreExecute(Cake.Core.IO.FilePath assemblyPath, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Execute.DotNetCoreExecuteSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreExecute(Context, assemblyPath, arguments, settings);
}

/// <summary>
///            Restore all NuGet Packages.
///            </summary>
/// <param name="context">The context.</param>
/// <example>
///            <code>
///                DotNetCoreRestore();
///            </code>
///            </example>
public void DotNetCoreRestore()
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context);
}

/// <summary>
///            Restore all NuGet Packages in the specified path.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="root">List of projects and project folders to restore. Each value can be: a path to a project.json or global.json file, or a folder to recursively search for project.json files.</param>
/// <example>
///            <code>
///                DotNetCoreRestore("./src/*");
///            </code>
///            </example>
public void DotNetCoreRestore(System.String root)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, root);
}

/// <summary>
///             Restore all NuGet Packages with the settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreRestoreSettings
///                 {
///                     Sources = new[] {"https://www.example.com/nugetfeed", "https://www.example.com/nugetfeed2"},
///                     FallbackSources = new[] {"https://www.example.com/fallbacknugetfeed"},
///                     PackagesDirectory = "./packages",
///                     Verbosity = Information,
///                     DisableParallel = true,
///                     InferRuntimes = new[] {"runtime1", "runtime2"}
///                 };
///            
///                 DotNetCoreRestore(settings);
///             </code>
///             </example>
public void DotNetCoreRestore(Cake.Common.Tools.DotNetCore.Restore.DotNetCoreRestoreSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, settings);
}

/// <summary>
///             Restore all NuGet Packages in the specified path with settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="root">List of projects and project folders to restore. Each value can be: a path to a project.json or global.json file, or a folder to recursively search for project.json files.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreRestoreSettings
///                 {
///                     Sources = new[] {"https://www.example.com/nugetfeed", "https://www.example.com/nugetfeed2"},
///                     FallbackSources = new[] {"https://www.example.com/fallbacknugetfeed"},
///                     PackagesDirectory = "./packages",
///                     Verbosity = Information,
///                     DisableParallel = true,
///                     InferRuntimes = new[] {"runtime1", "runtime2"}
///                 };
///            
///                 DotNetCoreRestore("./src/*", settings);
///             </code>
///             </example>
public void DotNetCoreRestore(System.String root, Cake.Common.Tools.DotNetCore.Restore.DotNetCoreRestoreSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRestore(Context, root, settings);
}

/// <summary>
///            Build all projects.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
///            <code>
///                DotNetCoreBuild("./src/*");
///            </code>
///            </example>
public void DotNetCoreBuild(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreBuild(Context, project);
}

/// <summary>
///             Build all projects.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreBuildSettings
///                 {
///                     Framework = "netcoreapp1.0",
///                     Configuration = "Debug",
///                     OutputDirectory = "./artifacts/"
///                 };
///            
///                 DotNetCoreBuild("./src/*", settings);
///             </code>
///             </example>
public void DotNetCoreBuild(System.String project, Cake.Common.Tools.DotNetCore.Build.DotNetCoreBuildSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreBuild(Context, project, settings);
}

/// <summary>
///            Package all projects.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
///            <code>
///                DotNetCorePack("./src/*");
///            </code>
///            </example>
public void DotNetCorePack(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePack(Context, project);
}

/// <summary>
///             Package all projects.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCorePackSettings
///                 {
///                     Configuration = "Release",
///                     OutputDirectory = "./artifacts/"
///                 };
///            
///                 DotNetCorePack("./src/*", settings);
///             </code>
///             </example>
public void DotNetCorePack(System.String project, Cake.Common.Tools.DotNetCore.Pack.DotNetCorePackSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePack(Context, project, settings);
}

/// <summary>
///            Run all projects.
///            </summary>
/// <param name="context">The context.</param>
/// <example>
///            <code>
///                DotNetCoreRun();
///            </code>
///            </example>
public void DotNetCoreRun()
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context);
}

/// <summary>
///            Run project.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <example>
///            <code>
///                DotNetCoreRun("./src/Project");
///            </code>
///            </example>
public void DotNetCoreRun(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project);
}

/// <summary>
///            Run project with path and arguments.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
///            <code>
///                DotNetCoreRun("./src/Project", "--args");
///            </code>
///            </example>
public void DotNetCoreRun(System.String project, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project, arguments);
}

/// <summary>
///             Run project with settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreRunSettings
///                 {
///                     Framework = "netcoreapp1.0",
///                     Configuration = "Release"
///                 };
///            
///                 DotNetCoreRun("./src/Project", "--args", settings);
///             </code>
///             </example>
public void DotNetCoreRun(System.String project, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Run.DotNetCoreRunSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreRun(Context, project, arguments, settings);
}

/// <summary>
///            Publish all projects.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <example>
///            <code>
///                DotNetCorePublish("./src/*");
///            </code>
///            </example>
public void DotNetCorePublish(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePublish(Context, project);
}

/// <summary>
///             Publish all projects.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCorePublishSettings
///                 {
///                     Framework = "netcoreapp1.0",
///                     Configuration = "Release",
///                     OutputDirectory = "./artifacts/"
///                 };
///            
///                 DotNetCorePublish("./src/*", settings);
///             </code>
///             </example>
public void DotNetCorePublish(System.String project, Cake.Common.Tools.DotNetCore.Publish.DotNetCorePublishSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCorePublish(Context, project, settings);
}

/// <summary>
///            Test project.
///            </summary>
/// <param name="context">The context.</param>
/// <example>
///            <code>
///                DotNetCoreTest();
///            </code>
///            </example>
public void DotNetCoreTest()
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context);
}

/// <summary>
///            Test project with path.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <example>
///            <para>Specify the path to the .csproj file in the test project</para>
///            <code>
///                DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj");
///            </code>
///            <para>You could also specify a task that runs multiple test projects.</para>
///            <para>Cake task:</para>
///            <code>
///            Task("Test")
///                .Does(() =&gt;
///            {
///                var projectFiles = GetFiles("./test/**/*.csproj");
///                foreach(var file in projectFiles)
///                {
///                    DotNetCoreTest(file.FullPath);
///                }
///            });
///            </code>
///            <para>If your test project is using project.json, the project parameter should just be the directory path.</para>
///            <code>
///                DotNetCoreTest("./test/Project.Tests/");
///            </code>
///            </example>
public void DotNetCoreTest(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context, project);
}

/// <summary>
///             Test project with settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Configuration = "Release"
///                 };
///            
///                 DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj", settings);
///             </code>
///             <para>You could also specify a task that runs multiple test projects.</para>
///             <para>Cake task:</para>
///             <code>
///             Task("Test")
///                 .Does(() =&gt;
///             {
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Configuration = "Release"
///                 };
///            
///                 var projectFiles = GetFiles("./test/**/*.csproj");
///                 foreach(var file in projectFiles)
///                 {
///                     DotNetCoreTest(file.FullPath, settings);
///                 }
///             });
///             </code>
///             <para>If your test project is using project.json, the project parameter should just be the directory path.</para>
///             <code>
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Configuration = "Release"
///                 };
///            
///                 DotNetCoreTest("./test/Project.Tests/", settings);
///             </code>
///             </example>
public void DotNetCoreTest(System.String project, Cake.Common.Tools.DotNetCore.Test.DotNetCoreTestSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTest(Context, project, settings);
}

/// <summary>
///            Cleans a project's output.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="project">The project's path.</param>
/// <example>
///            <code>
///                DotNetCoreClean("./src/project");
///            </code>
///            </example>
public void DotNetCoreClean(System.String project)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreClean(Context, project);
}

/// <summary>
///             Cleans a project's output.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="project">The projects path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreCleanSettings
///                 {
///                     Framework = "netcoreapp1.0",
///                     Configuration = "Debug",
///                     OutputDirectory = "./artifacts/"
///                 };
///            
///                 DotNetCoreClean("./src/project", settings);
///             </code>
///             </example>
public void DotNetCoreClean(System.String project, Cake.Common.Tools.DotNetCore.Clean.DotNetCoreCleanSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreClean(Context, project, settings);
}

/// <summary>
///            Delete a NuGet Package from a server.
///            </summary>
/// <param name="context">The context.</param>
/// <example>
///            <code>
///                DotNetCoreNuGetDelete();
///            </code>
///            </example>
public void DotNetCoreNuGetDelete()
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context);
}

/// <summary>
///            Deletes a package from the NuGet.org.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <example>
///            <code>
///                DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc");
///            </code>
///            </example>
public void DotNetCoreNuGetDelete(System.String packageName)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName);
}

/// <summary>
///            Deletes a specific version of a package from the NuGet.org.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="packageVersion">Version of package to delete.</param>
/// <example>
///            <code>
///                DotNetCoreRestore("Microsoft.AspNetCore.Mvc", "1.0");
///            </code>
///            </example>
public void DotNetCoreNuGetDelete(System.String packageName, System.String packageVersion)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, packageVersion);
}

/// <summary>
///             Deletes a package from a server
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreNuGetDeleteSettings
///                 {
///                     Source = "https://www.example.com/nugetfeed",
///                     NonInteractive = true
///                 };
///            
///                 DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc", settings);
///             </code>
///             </example>
public void DotNetCoreNuGetDelete(System.String packageName, Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, settings);
}

/// <summary>
///             Deletes a package from a server using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreNuGetDeleteSettings
///                 {
///                     Source = "https://www.example.com/nugetfeed",
///                     NonInteractive = true
///                 };
///            
///                 DotNetCoreNuGetDelete(settings);
///             </code>
///             </example>
public void DotNetCoreNuGetDelete(Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, settings);
}

/// <summary>
///             Deletes a package from a server using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to delete.</param>
/// <param name="packageVersion">Version of package to delete.</param>
/// <param name="settings">The settings.</param>
/// <example>
///              <code>
///                 var settings = new DotNetCoreNuGetDeleteSettings
///                 {
///                     Source = "https://www.example.com/nugetfeed",
///                     NonInteractive = true
///                 };
///            
///                 DotNetCoreNuGetDelete("Microsoft.AspNetCore.Mvc", "1.0", settings);
///              </code>
///             </example>
public void DotNetCoreNuGetDelete(System.String packageName, System.String packageVersion, Cake.Common.Tools.DotNetCore.NuGet.Delete.DotNetCoreNuGetDeleteSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetDelete(Context, packageName, packageVersion, settings);
}

/// <summary>
///            Pushes one or more packages to a server.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to push.</param>
/// <example>
///            <code>
///                DotNetCoreNuGetPush("*.nupkg");
///            </code>
///            </example>
public void DotNetCoreNuGetPush(System.String packageName)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetPush(Context, packageName);
}

/// <summary>
///             Pushes one or more packages to a server using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageName">Name of package to push.</param>
/// <param name="settings">The settings.</param>
/// <example>
///              <code>
///                 var settings = new DotNetCoreNuGetPushSettings
///                 {
///                     Source = "https://www.example.com/nugetfeed",
///                     ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
///                 };
///            
///                 DotNetCoreNuGetPush("foo*.nupkg", settings);
///              </code>
///             </example>
public void DotNetCoreNuGetPush(System.String packageName, Cake.Common.Tools.DotNetCore.NuGet.Push.DotNetCoreNuGetPushSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreNuGetPush(Context, packageName, settings);
}

/// <summary>
///            Builds the specified targets in a project file found in the current working directory.
///            </summary>
/// <param name="context">The context.</param>
/// <example>
///             <code>
///                DotNetCoreMSBuild();
///             </code>
///            </example>
public void DotNetCoreMSBuild()
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context);
}

/// <summary>
///            Builds the specified targets in the project file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectOrDirectory">Project file or directory to search for project file.</param>
/// <example>
///             <code>
///                DotNetCoreMSBuild("foobar.proj");
///             </code>
///            </example>
/// <remarks>
///            If a directory is specified, MSBuild searches that directory for a project file.
///            </remarks>
public void DotNetCoreMSBuild(System.String projectOrDirectory)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, projectOrDirectory);
}

/// <summary>
///             Builds the specified targets in a project file found in the current working directory.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///              <code>
///                 var settings = new DotNetCoreMSBuildSettings
///                 {
///                     NoLogo = true,
///                     MaxCpuCount = -1
///                 };
///            
///                 DotNetCoreMSBuild(settings);
///              </code>
///             </example>
public void DotNetCoreMSBuild(Cake.Common.Tools.DotNetCore.MSBuild.DotNetCoreMSBuildSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, settings);
}

/// <summary>
///             Builds the specified targets in the project file.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="projectOrDirectory">Project file or directory to search for project file.</param>
/// <param name="settings">The settings.</param>
/// <example>
///              <code>
///                 var settings = new DotNetCoreMSBuildSettings
///                 {
///                     NoLogo = true,
///                     MaxCpuCount = -1
///                 };
///            
///                 DotNetCoreMSBuild("foobar.proj", settings);
///              </code>
///             </example>
/// <remarks>
///             If a project file is not specified, MSBuild searches the current working directory for a file that has a file
///             extension that ends in "proj" and uses that file. If a directory is specified, MSBuild searches that directory for a project file.
///             </remarks>
public void DotNetCoreMSBuild(System.String projectOrDirectory, Cake.Common.Tools.DotNetCore.MSBuild.DotNetCoreMSBuildSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreMSBuild(Context, projectOrDirectory, settings);
}

/// <summary>
///            Test one or more projects specified by a path or glob pattern using the VS Test host runner.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="testFile">A path to the test file or glob for one or more test files.</param>
/// <example>
///            <para>Specify the path to the .csproj file in the test project</para>
///            <code>
///                DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj");
///            </code>
///            <para>You could also specify a glob pattern to run multiple test projects.</para>
///            <code>
///                DotNetCoreTest("./**/*.Tests.csproj");
///            </code>
///            </example>
public void DotNetCoreVSTest(System.String testFile)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFile);
}

/// <summary>
///             Test one or more projects specified by a path or glob pattern with settings using the VS Test host runner.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="testFile">A path to the test file or glob for one or more test files.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <para>Specify the path to the .csproj file in the test project</para>
///             <code>
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Framework = "FrameworkCore10",
///                     Platform = "x64"
///                 };
///            
///                 DotNetCoreTest("./test/Project.Tests/Project.Tests.csproj", settings);
///             </code>
///             <para>You could also specify a glob pattern to run multiple test projects.</para>
///             <code>
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Framework = "FrameworkCore10",
///                     Platform = "x64",
///                     Parallel = true
///                 };
///            
///                 DotNetCoreTest("./**/*.Tests.csproj", settings);
///             </code>
///             </example>
public void DotNetCoreVSTest(System.String testFile, Cake.Common.Tools.DotNetCore.VSTest.DotNetCoreVSTestSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFile, settings);
}

/// <summary>
///             Test one or more specified projects with settings using the VS Test host runner.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="testFiles">The project paths to test.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Framework = "FrameworkCore10",
///                     Platform = "x64"
///                 };
///            
///                 DotNetCoreTest(new[] { (FilePath)"./Test/Cake.Common.Tests.csproj" }, settings);
///             </code>
///             <para>You could also specify a task that runs multiple test projects.</para>
///             <para>Cake task:</para>
///             <code>
///             Task("Test")
///                 .Does(() =&gt;
///             {
///                 var settings = new DotNetCoreTestSettings
///                 {
///                     Framework = "FrameworkCore10",
///                     Platform = "x64",
///                     Parallel = true
///                 };
///            
///                 var projectFiles = GetFiles("./test/**/*.csproj");
///            
///                 DotNetCoreTest(projectFiles, settings);
///             });
///             </code>
///             </example>
public void DotNetCoreVSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> testFiles, Cake.Common.Tools.DotNetCore.VSTest.DotNetCoreVSTestSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreVSTest(Context, testFiles, settings);
}

/// <summary>
///            /// Execute an .NET Core Extensibility Tool.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <example>
///            <code>
///                DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
///            </code>
///            </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command);
}

/// <summary>
///            Execute an .NET Core Extensibility Tool.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <param name="arguments">The arguments.</param>
/// <example>
///            <code>
///                DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
///            </code>
///            </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command, Cake.Core.IO.ProcessArgumentBuilder arguments)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command, arguments);
}

/// <summary>
///            Execute an .NET Core Extensibility Tool.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project path.</param>
/// <param name="command">The command to execute.</param>
/// <param name="arguments">The arguments.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///                DotNetCoreTool("./src/project", "xunit", "-xml report.xml");
///            </code>
///            </example>
public void DotNetCoreTool(Cake.Core.IO.FilePath projectPath, System.String command, Cake.Core.IO.ProcessArgumentBuilder arguments, Cake.Common.Tools.DotNetCore.Tool.DotNetCoreToolSettings settings)
{
    Cake.Common.Tools.DotNetCore.DotNetCoreAliases.DotNetCoreTool(Context, projectPath, command, arguments, settings);
}

/// <summary>
///            Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#analyse">DotCover Analyse</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run DotCover for.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            DotCoverAnalyse(tool =&gt; {
///              tool.XUnit2("./**/App.Tests.dll",
///                new XUnit2Settings {
///                  ShadowCopy = false
///                });
///              },
///              new FilePath("./result.xml"),
///              new DotCoverAnalyseSettings()
///                .WithFilter("+:App")
///                .WithFilter("-:App.Tests"));
///            </code>
///            </example>
public void DotCoverAnalyse(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Analyse.DotCoverAnalyseSettings settings)
{
    Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverAnalyse(Context, action, outputFile, settings);
}

/// <summary>
///            Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#cover">DotCover Cover</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action to run DotCover for.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            DotCoverCover(tool =&gt; {
///              tool.XUnit2("./**/App.Tests.dll",
///                new XUnit2Settings {
///                  ShadowCopy = false
///                });
///              },
///              new FilePath("./result.dcvr"),
///              new DotCoverCoverSettings()
///                .WithFilter("+:App")
///                .WithFilter("-:App.Tests"));
///            </code>
///            </example>
public void DotCoverCover(System.Action<Cake.Core.ICakeContext> action, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Cover.DotCoverCoverSettings settings)
{
    Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverCover(Context, action, outputFile, settings);
}

/// <summary>
///            Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#report">DotCover Report</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFile">The DotCover coverage snapshot file name.</param>
/// <param name="outputFile">The DotCover output file.</param>
/// <param name="settings">The settings</param>
/// <example>
///            <code>
///            DotCoverReport(new FilePath("./result.dcvr"),
///              new FilePath("./result.html"),
///              new DotCoverReportSettings {
///                ReportType = DotCoverReportType.HTML
///              });
///            </code>
///            </example>
public void DotCoverReport(Cake.Core.IO.FilePath sourceFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Report.DotCoverReportSettings settings)
{
    Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverReport(Context, sourceFile, outputFile, settings);
}

/// <summary>
///            Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#merge">DotCover Merge</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The list of DotCover coverage snapshot files.</param>
/// <param name="outputFile">The merged output file.</param>
/// <example>
///            <code>
///            DotCoverMerge(new[] {
///                new FilePath("./result1.dcvr"),
///                new FilePath("./result2.dcvr")
///              },
///              new FilePath("./merged.dcvr"));
///            </code>
///            </example>
public void DotCoverMerge(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Core.IO.FilePath outputFile)
{
    Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverMerge(Context, sourceFiles, outputFile);
}

/// <summary>
///            Runs <see href="https://www.jetbrains.com/dotcover/help/dotCover__Console_Runner_Commands.html#merge">DotCover Merge</see>
///            for the specified action and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The list of DotCover coverage snapshot files.</param>
/// <param name="outputFile">The merged output file.</param>
/// <param name="settings">The settings</param>
/// <example>
///            <code>
///            DotCoverMerge(new[] {
///                new FilePath("./result1.dcvr"),
///                new FilePath("./result2.dcvr")
///              },
///              new FilePath("./merged.dcvr"),
///              new DotCoverMergeSettings {
///                LogFile = new FilePath("./log.txt")
///              });
///            </code>
///            </example>
public void DotCoverMerge(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.DotCover.Merge.DotCoverMergeSettings settings)
{
    Cake.Common.Tools.DotCover.DotCoverAliases.DotCoverMerge(Context, sourceFiles, outputFile, settings);
}

/// <summary>
///             Creates a Chocolatey package using the specified Nuspec file.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="nuspecFilePath">The nuspec file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var chocolateyPackSettings   = new ChocolateyPackSettings {
///                                                 Id                      = "TestChocolatey",
///                                                 Title                   = "The tile of the package",
///                                                 Version                 = "0.0.0.1",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 Description             = "The description of the package",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 PackageSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 ProjectSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 DocsUrl                 = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 MailingListUrl          = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 BugTrackerUrl           = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 Copyright               = "Some company 2015",
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
///                                                 RequireLicenseAcceptance= false,
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Files                   = new [] {
///                                                                                      new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
///                                                                                   },
///                                                 Debug                   = false,
///                                                 Verbose                 = false,
///                                                 Force                   = false,
///                                                 Noop                    = false,
///                                                 LimitOutput             = false,
///                                                 ExecutionTimeout        = 13,
///                                                 CacheLocation           = @"C:\temp",
///                                                 AllowUnofficial          = false
///                                             };
///            
///                 ChocolateyPack("./nuspec/TestChocolatey.nuspec", chocolateyPackSettings);
///             </code>
///             </example>
public void ChocolateyPack(Cake.Core.IO.FilePath nuspecFilePath, Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, nuspecFilePath, settings);
}

/// <summary>
///             Creates Chocolatey packages using the specified Nuspec files.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The nuspec file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var chocolateyPackSettings   = new ChocolateyPackSettings {
///                                                 Id                      = "TestChocolatey",
///                                                 Title                   = "The tile of the package",
///                                                 Version                 = "0.0.0.1",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 Description             = "The description of the package",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 PackageSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 ProjectSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 DocsUrl                 = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 MailingListUrl          = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 BugTrackerUrl           = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 Copyright               = "Some company 2015",
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
///                                                 RequireLicenseAcceptance= false,
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Files                   = new [] {
///                                                                                      new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
///                                                                                   },
///                                                 Debug                   = false,
///                                                 Verbose                 = false,
///                                                 Force                   = false,
///                                                 Noop                    = false,
///                                                 LimitOutput             = false,
///                                                 ExecutionTimeout        = 13,
///                                                 CacheLocation           = @"C:\temp",
///                                                 AllowUnofficial          = false
///                                             };
///            
///                 var nuspecFiles = GetFiles("./**/*.nuspec");
///                 ChocolateyPack(nuspecFiles, chocolateyPackSettings);
///             </code>
///             </example>
public void ChocolateyPack(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, filePaths, settings);
}

/// <summary>
///             Creates a Chocolatey package using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var chocolateyPackSettings   = new ChocolateyPackSettings {
///                                                 Id                      = "TestChocolatey",
///                                                 Title                   = "The tile of the package",
///                                                 Version                 = "0.0.0.1",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 Description             = "The description of the package",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 PackageSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 ProjectSourceUrl        = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 DocsUrl                 = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 MailingListUrl          = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 BugTrackerUrl           = new Uri("https://github.com/SomeUser/TestChocolatey/"),
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 Copyright               = "Some company 2015",
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestChocolatey/blob/master/LICENSE.md"),
///                                                 RequireLicenseAcceptance= false,
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestChocolatey/master/icons/testchocolatey.png"),
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Files                   = new [] {
///                                                                                      new ChocolateyNuSpecContent {Source = "bin/TestChocolatey.dll", Target = "bin"},
///                                                                                   },
///                                                 Debug                   = false,
///                                                 Verbose                 = false,
///                                                 Force                   = false,
///                                                 Noop                    = false,
///                                                 LimitOutput             = false,
///                                                 ExecutionTimeout        = 13,
///                                                 CacheLocation           = @"C:\temp",
///                                                 AllowUnofficial          = false
///                                             };
///            
///                 ChocolateyPack(chocolateyPackSettings);
///             </code>
///             </example>
public void ChocolateyPack(Cake.Common.Tools.Chocolatey.Pack.ChocolateyPackSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPack(Context, settings);
}

/// <summary>
///            Installs a Chocolatey package.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <example>
///            <code>
///            ChocolateyInstall("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyInstall(System.String packageId)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstall(Context, packageId);
}

/// <summary>
///            Installs a Chocolatey package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyInstall("MyChocolateyPackage", new ChocolateyInstallSettings {
///                Source                = true,
///                Version               = "1.2.3",
///                Prerelease            = false,
///                Forcex86              = false,
///                InstallArguments      = "arg1",
///                OverrideArguments     = false,
///                NotSilent             = false,
///                PackageParameters     = "param1",
///                AllowDowngrade        = false,
///                SideBySide            = false,
///                IgnoreDependencies    = false,
///                ForceDependencies     = false,
///                SkipPowerShell        = false,
///                User                  = "user",
///                Password              = "password",
///                IgnoreChecksums       = false,
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///                });
///            </code>
///            </example>
public void ChocolateyInstall(System.String packageId, Cake.Common.Tools.Chocolatey.Install.ChocolateyInstallSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstall(Context, packageId, settings);
}

/// <summary>
///            Installs Chocolatey packages using the specified package configuration.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <example>
///            <code>
///            ChocolateyInstallFromConfig("./tools/packages.config");
///            </code>
///            </example>
public void ChocolateyInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstallFromConfig(Context, packageConfigPath);
}

/// <summary>
///            Installs Chocolatey packages using the specified package configuration and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyInstallFromConfig("./tools/packages.config", new ChocolateyInstallSettings {
///                Source                = true,
///                Version               = "1.2.3",
///                Prerelease            = false,
///                Forcex86              = false,
///                InstallArguments      = "arg1",
///                OverrideArguments     = false,
///                NotSilent             = false,
///                PackageParameters     = "param1",
///                AllowDowngrade        = false,
///                SideBySide            = false,
///                IgnoreDependencies    = false,
///                ForceDependencies     = false,
///                SkipPowerShell        = false,
///                User                  = "user",
///                Password              = "password",
///                IgnoreChecksums       = false,
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///                });
///            </code>
///            </example>
public void ChocolateyInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath, Cake.Common.Tools.Chocolatey.Install.ChocolateyInstallSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyInstallFromConfig(Context, packageConfigPath, settings);
}

/// <summary>
///            Uninstalls a Chocolatey package.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to uninstall.</param>
/// <example>
///            <code>
///            ChocolateyUninstall("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyUninstall(System.String packageId)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageId);
}

/// <summary>
///            Uninstalls a Chocolatey package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to uninstall.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyUninstall("MyChocolateyPackage", new ChocolateyUninstallSettings {
///                Source                  = true,
///                Version                 = "1.2.3",
///                UninstallArguments      = "arg1",
///                OverrideArguments       = false,
///                NotSilent               = false,
///                PackageParameters       = "param1",
///                SideBySide              = false,
///                IgnoreDependencies      = false,
///                ForceDependencies       = false,
///                SkipPowerShell          = false,
///                Debug                   = false,
///                Verbose                 = false,
///                FailOnStandardError     = false,
///                UseSystemPowershell     = false,
///                AllVersions             = false,
///                Force                   = false,
///                Noop                    = false,
///                LimitOutput             = false,
///                ExecutionTimeout        = 13,
///                CacheLocation           = @"C:\temp",
///                AllowUnofficial         = false,
///                GlobalArguments         = false,
///                GlobalPackageParameters = false,
///                IgnorePackageExitCodes  = false,
///                UsePackageExitCodes     = false,
///                UseAutoUninstaller      = false,
///                SkipAutoUninstaller     = false,
///                FailOnAutoUninstaller   = false,
///                IgnoreAutoUninstaller   = false
///                });
///            </code>
///            </example>
public void ChocolateyUninstall(System.String packageId, Cake.Common.Tools.Chocolatey.Uninstall.ChocolateyUninstallSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageId, settings);
}

/// <summary>
///            Uninstalls a Chocolatey package.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The ids of the packages to uninstall.</param>
/// <example>
///            <code>
///            ChocolateyUninstall("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyUninstall(System.Collections.Generic.IEnumerable<System.String> packageIds)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageIds);
}

/// <summary>
///            Uninstalls Chocolatey packages using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The ids of the packages to uninstall.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyUninstall("MyChocolateyPackage", new ChocolateyUninstallSettings {
///                Source                  = true,
///                Version                 = "1.2.3",
///                UninstallArguments      = "arg1",
///                OverrideArguments       = false,
///                NotSilent               = false,
///                PackageParameters       = "param1",
///                SideBySide              = false,
///                IgnoreDependencies      = false,
///                ForceDependencies       = false,
///                SkipPowerShell          = false,
///                Debug                   = false,
///                Verbose                 = false,
///                FailOnStandardError     = false,
///                UseSystemPowershell     = false,
///                AllVersions             = false,
///                Force                   = false,
///                Noop                    = false,
///                LimitOutput             = false,
///                ExecutionTimeout        = 13,
///                CacheLocation           = @"C:\temp",
///                AllowUnofficial         = false,
///                GlobalArguments         = false,
///                GlobalPackageParameters = false,
///                IgnorePackageExitCodes  = false,
///                UsePackageExitCodes     = false,
///                UseAutoUninstaller      = false,
///                SkipAutoUninstaller     = false,
///                FailOnAutoUninstaller   = false,
///                IgnoreAutoUninstaller   = false
///                });
///            </code>
///            </example>
public void ChocolateyUninstall(System.Collections.Generic.IEnumerable<System.String> packageIds, Cake.Common.Tools.Chocolatey.Uninstall.ChocolateyUninstallSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUninstall(Context, packageIds, settings);
}

/// <summary>
///            Pins a Chocolatey package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">The name.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyPin("MyChocolateyPackage", new ChocolateyPinSettings {
///                Version               = "1.2.3",
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyPin(System.String name, Cake.Common.Tools.Chocolatey.Pin.ChocolateyPinSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPin(Context, name, settings);
}

/// <summary>
///            Sets the Api Key for a Chocolatey Source using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API Key.</param>
/// <param name="source">The source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyApiKey("myApiKey", "http://www.mysource.com", new ChocolateyApiKeySettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyApiKey(System.String apiKey, System.String source, Cake.Common.Tools.Chocolatey.ApiKey.ChocolateyApiKeySettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyApiKey(Context, apiKey, source, settings);
}

/// <summary>
///            Sets the config parameter using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">The name.</param>
/// <param name="value">The value.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyConfig("cacheLocation", @"c:\temp", new ChocolateyConfigSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyConfig(System.String name, System.String value, Cake.Common.Tools.Chocolatey.Config.ChocolateyConfigSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyConfig(Context, name, value, settings);
}

/// <summary>
///            Enables a Chocolatey Feature using the specified name
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <example>
///            <code>
///            ChocolateyEnableFeature("checkSumFiles");
///            </code>
///            </example>
public void ChocolateyEnableFeature(System.String name)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableFeature(Context, name);
}

/// <summary>
///            Enables a Chocolatey Feature using the specified name and settings
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyEnableFeature("checkSumFiles", new ChocolateyFeatureSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyEnableFeature(System.String name, Cake.Common.Tools.Chocolatey.Features.ChocolateyFeatureSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableFeature(Context, name, settings);
}

/// <summary>
///            Disables a Chocolatey Feature using the specified name
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <example>
///            <code>
///            ChocolateyDisableFeature("checkSumFiles");
///            </code>
///            </example>
public void ChocolateyDisableFeature(System.String name)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableFeature(Context, name);
}

/// <summary>
///            Disables a Chocolatey Feature using the specified name and settings
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the feature.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyDisableFeature("checkSumFiles", new ChocolateyFeatureSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyDisableFeature(System.String name, Cake.Common.Tools.Chocolatey.Features.ChocolateyFeatureSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableFeature(Context, name, settings);
}

/// <summary>
///            Adds Chocolatey package source using the specified name &amp;source to global user config
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
///            <code>
///            ChocolateyAddSource("MySource", "http://www.mysource.com");
///            </code>
///            </example>
public void ChocolateyAddSource(System.String name, System.String source)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyAddSource(Context, name, source);
}

/// <summary>
///            Adds Chocolatey package source using the specified name, source &amp; settings to global user config
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyAddSource("MySource", "http://www.mysource.com", new ChocolateySourcesSettings {
///                UserName              = "user",
///                Password              = "password",
///                Priority              = 13,
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyAddSource(System.String name, System.String source, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyAddSource(Context, name, source, settings);
}

/// <summary>
///            Removes Chocolatey package source using the specified name &amp; source from global user config
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
///            <code>
///            ChocolateyRemoveSource("MySource");
///            </code>
///            </example>
public void ChocolateyRemoveSource(System.String name)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyRemoveSource(Context, name);
}

/// <summary>
///            Removes Chocolatey package source using the specified name, source &amp; settings from global user config
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyRemoveSource("MySource", new ChocolateySourcesSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyRemoveSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyRemoveSource(Context, name, settings);
}

/// <summary>
///            Enables a Chocolatey Source using the specified name
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
///            <code>
///            ChocolateyEnableSource("MySource");
///            </code>
///            </example>
public void ChocolateyEnableSource(System.String name)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableSource(Context, name);
}

/// <summary>
///            Enables a Chocolatey Source using the specified name and settings
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyEnableSource("MySource", new ChocolateySourcesSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyEnableSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyEnableSource(Context, name, settings);
}

/// <summary>
///            Disables a Chocolatey Source using the specified name
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <example>
///            <code>
///            ChocolateyDisableSource("MySource");
///            </code>
///            </example>
public void ChocolateyDisableSource(System.String name)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableSource(Context, name);
}

/// <summary>
///            Disables a Chocolatey Source using the specified name and settings
///            </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyDisableSource("MySource", new ChocolateySourcesSettings {
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyDisableSource(System.String name, Cake.Common.Tools.Chocolatey.Sources.ChocolateySourcesSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDisableSource(Context, name, settings);
}

/// <summary>
///             Pushes a Chocolatey package to a Chocolatey server and publishes it.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePath">The <c>.nupkg</c> file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             // Get the path to the package.
///             var package = "./chocolatey/MyChocolateyPackage.0.0.1.nupkg";
///            
///             // Push the package.
///             ChocolateyPush(package, new ChocolateyPushSettings {
///                 Source                = "http://example.com/chocolateyfeed",
///                 ApiKey                = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
///                 Timeout               = 300
///                 Debug                 = false,
///                 Verbose               = false,
///                 Force                 = false,
///                 Noop                  = false,
///                 LimitOutput           = false,
///                 ExecutionTimeout      = 13,
///                 CacheLocation         = @"C:\temp",
///                 AllowUnofficial        = false
///             });
///             </code>
///             </example>
public void ChocolateyPush(Cake.Core.IO.FilePath packageFilePath, Cake.Common.Tools.Chocolatey.Push.ChocolateyPushSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPush(Context, packageFilePath, settings);
}

/// <summary>
///             Pushes Chocolatey packages to a Chocolatey server and publishes them.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePaths">The <c>.nupkg</c> file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             // Get the paths to the packages.
///             var packages = GetFiles("./**/*.nupkg");
///            
///             // Push the package.
///             ChocolateyPush(packages, new ChocolateyPushSettings {
///                 Source                = "http://example.com/chocolateyfeed",
///                 ApiKey                = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
///                 Timeout               = 300
///                 Debug                 = false,
///                 Verbose               = false,
///                 Force                 = false,
///                 Noop                  = false,
///                 LimitOutput           = false,
///                 ExecutionTimeout      = 13,
///                 CacheLocation         = @"C:\temp",
///                 AllowUnofficial        = false
///             });
///             </code>
///             </example>
public void ChocolateyPush(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageFilePaths, Cake.Common.Tools.Chocolatey.Push.ChocolateyPushSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyPush(Context, packageFilePaths, settings);
}

/// <summary>
///            Upgrades Chocolatey package.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to upgrade.</param>
/// <example>
///            <code>
///            ChocolateyUpgrade("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyUpgrade(System.String packageId)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUpgrade(Context, packageId);
}

/// <summary>
///            Upgrades Chocolatey package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to upgrade.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyUpgrade("MyChocolateyPackage", new ChocolateyUpgradeSettings {
///                Source                = true,
///                Version               = "1.2.3",
///                Prerelease            = false,
///                Forcex86              = false,
///                InstallArguments      = "arg1",
///                OverrideArguments     = false,
///                NotSilent             = false,
///                PackageParameters     = "param1",
///                AllowDowngrade        = false,
///                SideBySide            = false,
///                IgnoreDependencies    = false,
///                SkipPowerShell        = false,
///                FailOnUnfound        = false,
///                FailOnNotInstalled        = false,
///                User                  = "user",
///                Password              = "password",
///                IgnoreChecksums       = false,
///                Debug                 = false,
///                Verbose               = false,
///                Force                 = false,
///                Noop                  = false,
///                LimitOutput           = false,
///                ExecutionTimeout      = 13,
///                CacheLocation         = @"C:\temp",
///                AllowUnofficial        = false
///            });
///            </code>
///            </example>
public void ChocolateyUpgrade(System.String packageId, Cake.Common.Tools.Chocolatey.Upgrade.ChocolateyUpgradeSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyUpgrade(Context, packageId, settings);
}

/// <summary>
///            Generate package specification files for a new package using the default settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to create.</param>
/// <example>
///            <code>
///            ChocolateyNew("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyNew(System.String packageId)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyNew(Context, packageId);
}

/// <summary>
///            Generate package specification files for a new package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to create.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            ChocolateyNew("MyChocolateyPackage", new ChocolateyNewSettings {
///                PackageVersion = "1.2.3",
///                MaintainerName = "John Doe",
///                MaintainerRepo = "johndoe"
///            });
///            </code>
///            </example>
/// <example>
///            <code>
///            var settings = new ChocolateyNewSettings {
///                MaintainerName = "John Doe"
///            }
///            settings.AdditionalPropertyValues("Tags", "CustomPackage");
///            ChocolateyNew("MyChocolateyPackage", settings);
///            </code>
///            </example>
public void ChocolateyNew(System.String packageId, Cake.Common.Tools.Chocolatey.New.ChocolateyNewSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyNew(Context, packageId, settings);
}

/// <summary>
///            Downloads a Chocolatey package to the current working directory.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to download.</param>
/// <example>
///            <code>
///            ChocolateyDownload("MyChocolateyPackage");
///            </code>
///            </example>
public void ChocolateyDownload(System.String packageId)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDownload(Context, packageId);
}

/// <summary>
///            Downloads a Chocolatey package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <para>Download a package to a specific folder:</para>
///            <code>
///            ChocolateyDownload(
///                "MyChocolateyPackage",
///                new ChocolateyDownloadSettings {
///                    OutputDirectory = @"C:\download\"
///                });
///            </code>
///            <para>Download and internalize a package:</para>
///            <code>
///            ChocolateyDownload(
///                "MyChocolateyPackage",
///                new ChocolateyDownloadSettings {
///                    Internalize = true
///                });
///            </code>
///            </example>
public void ChocolateyDownload(System.String packageId, Cake.Common.Tools.Chocolatey.Download.ChocolateyDownloadSettings settings)
{
    Cake.Common.Tools.Chocolatey.ChocolateyAliases.ChocolateyDownload(Context, packageId, settings);
}

/// <summary>
///            Runs all xUnit.net v2 tests in the assemblies matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            XUnit2("./src/**/bin/Release/*.Tests.dll");
///            </code>
///            </example>
public void XUnit2(System.String pattern)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, pattern);
}

/// <summary>
///            Runs all xUnit.net v2 tests in the assemblies matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            XUnit2("./src/**/bin/Release/*.Tests.dll",
///                 new XUnit2Settings {
///                    Parallelism = ParallelismOption.All,
///                    HtmlReport = true,
///                    NoAppDomain = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit2(System.String pattern, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, pattern, settings);
}

/// <summary>
///            Runs all xUnit.net v2 tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            XUnit2(new []{
///                "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
///                "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
///                "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
///                "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
///                });
///            </code>
///            </example>
public void XUnit2(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies);
}

/// <summary>
///            Runs all xUnit.net tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            XUnit2(testAssemblies);
///            </code>
///            </example>
public void XUnit2(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies);
}

/// <summary>
///            Runs all xUnit.net v2 tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            XUnit2(new []{
///                "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
///                "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
///                "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
///                "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
///                 },
///                 new XUnit2Settings {
///                    Parallelism = ParallelismOption.All,
///                    HtmlReport = true,
///                    NoAppDomain = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit2(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies, settings);
}

/// <summary>
///            Runs all xUnit.net v2 tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            XUnit2(testAssemblies,
///                 new XUnit2Settings {
///                    Parallelism = ParallelismOption.All,
///                    HtmlReport = true,
///                    NoAppDomain = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit2(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.XUnit.XUnit2Settings settings)
{
    Cake.Common.Tools.XUnit.XUnit2Aliases.XUnit2(Context, assemblies, settings);
}

/// <summary>
///            Runs all xUnit.net tests in the assemblies matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            XUnit("./src/**/bin/Release/*.Tests.dll");
///            </code>
///            </example>
public void XUnit(System.String pattern)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, pattern);
}

/// <summary>
///            Runs all xUnit.net tests in the assemblies matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            XUnit("./src/**/bin/Release/*.Tests.dll",
///                 new XUnitSettings {
///                    HtmlReport = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit(System.String pattern, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, pattern, settings);
}

/// <summary>
///            Runs all xUnit.net tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            XUnit(new []{
///                "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
///                "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
///                "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
///                "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
///                });
///            </code>
///            </example>
public void XUnit(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies);
}

/// <summary>
///            Runs all xUnit.net tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            XUnit(testAssemblies);
///            </code>
///            </example>
public void XUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies);
}

/// <summary>
///            Runs all xUnit.net tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            XUnit(new []{
///                "./src/Cake.Common.Tests/bin/Release/Cake.Common.Tests.dll",
///                "./src/Cake.Core.Tests/bin/Release/Cake.Core.Tests.dll",
///                "./src/Cake.NuGet.Tests/bin/Release/Cake.NuGet.Tests.dll",
///                "./src/Cake.Tests/bin/Release/Cake.Tests.dll"
///                 },
///                 new XUnitSettings {
///                    HtmlReport = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies, settings);
}

/// <summary>
///            Runs all xUnit.net tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            XUnit(testAssemblies,
///                 new XUnitSettings {
///                    HtmlReport = true,
///                    OutputDirectory = "./build"
///                });
///            </code>
///            </example>
public void XUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.XUnit.XUnitSettings settings)
{
    Cake.Common.Tools.XUnit.XUnitAliases.XUnit(Context, assemblies, settings);
}

/// <summary>
///            Builds the specified solution using XBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <example>
///            <code>
///            XBuild("./src/Cake.sln");
///            </code>
///            </example>
public void XBuild(Cake.Core.IO.FilePath solution)
{
    Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution);
}

/// <summary>
///            Builds the specified solution using XBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="configurator">The settings configurator.</param>
/// <example>
///            <code>
///            XBuild("./src/Cake.sln", configurator =&gt;
///                configurator.SetConfiguration("Debug")
///                    .SetVerbosity(Verbosity.Minimal)
///                    .UseToolVersion(XBuildToolVersion.NET40));
///            </code>
///            </example>
public void XBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.XBuild.XBuildSettings> configurator)
{
    Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution, configurator);
}

/// <summary>
///            Builds the specified solution using XBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            XBuild("./src/Cake.sln", new XBuildSettings {
///                Verbosity = Verbosity.Minimal,
///                ToolVersion = XBuildToolVersion.NET40,
///                Configuration = "Release"
///                });
///            </code>
///            </example>
public void XBuild(Cake.Core.IO.FilePath solution, Cake.Common.Tools.XBuild.XBuildSettings settings)
{
    Cake.Common.Tools.XBuild.XBuildAliases.XBuild(Context, solution, settings);
}

/// <summary>
///            Compiles all <c>.wxs</c> sources matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            CandleSettings settings = new CandleSettings {
///                Architecture = Architecture.X64,
///                Verbose = true
///                };
///            WiXCandle("./src/*.wxs", settings);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The globbing pattern.</param>
/// <param name="settings">The settings.</param>
public void WiXCandle(System.String pattern, Cake.Common.Tools.WiX.CandleSettings settings = null)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXCandle(Context, pattern, settings);
}

/// <summary>
///            Compiles all <c>.wxs</c> sources in the provided source files.
///            </summary>
/// <example>
///            <code>
///            var files = GetFiles("./src/*.wxs");
///            CandleSettings settings = new CandleSettings {
///                Architecture = Architecture.X64,
///                Verbose = true
///                };
///            WiXCandle(files, settings);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="sourceFiles">The source files.</param>
/// <param name="settings">The settings.</param>
public void WiXCandle(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> sourceFiles, Cake.Common.Tools.WiX.CandleSettings settings = null)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXCandle(Context, sourceFiles, settings);
}

/// <summary>
///            Links all <c>.wixobj</c> files matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            LightSettings settings = new LightSettings {
///                RawArguments = "-O1 -pedantic -v"
///                };
///            WiXLight("./src/*.wixobj", settings);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The globbing pattern.</param>
/// <param name="settings">The settings.</param>
public void WiXLight(System.String pattern, Cake.Common.Tools.WiX.LightSettings settings = null)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXLight(Context, pattern, settings);
}

/// <summary>
///            Links all <c>.wixobj</c> files in the provided object files.
///            </summary>
/// <example>
///            <code>
///            var files = GetFiles("./src/*.wxs");
///            LightSettings settings = new LightSettings {
///                RawArguments = "-O1 -pedantic -v"
///                };
///            WiXLight(files, settings);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="objectFiles">The object files.</param>
/// <param name="settings">The settings.</param>
public void WiXLight(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> objectFiles, Cake.Common.Tools.WiX.LightSettings settings = null)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXLight(Context, objectFiles, settings);
}

/// <summary>
///            Harvests files in the provided object files.
///            </summary>
/// <example>
///            <code>
///            DirectoryPath harvestDirectory = Directory("./src");
///            var filePath = new FilePath("Wix.Directory.wxs");
///            WiXHeat(harvestDirectory, filePath, WiXHarvestType.Dir);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The object files.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, directoryPath, outputFile, harvestType);
}

/// <summary>
///            Harvests files in the provided directory path.
///            </summary>
/// <example>
///            <code>
///            DirectoryPath harvestDirectory = Directory("./src");
///            var filePath = File("Wix.Directory.wxs");
///            Information(MakeAbsolute(harvestDirectory).FullPath);
///            WiXHeat(harvestDirectory, filePath, WiXHarvestType.Dir, new HeatSettings { NoLogo = true });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, directoryPath, outputFile, harvestType, settings);
}

/// <summary>
///            Harvests from the desired files.
///            </summary>
/// <example>
///            <code>
///            var harvestFile = File("./tools/Cake/Cake.Core.dll");
///            var filePath = File("Wix.File.wxs");
///            WiXHeat(harvestFile, filePath, WiXHarvestType.File);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="objectFile">The object file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(Cake.Core.IO.FilePath objectFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, objectFile, outputFile, harvestType);
}

/// <summary>
///            Harvests from the desired files.
///            </summary>
/// <example>
///            <code>
///            var harvestFiles = File("./tools/Cake/*.dll");
///            var filePath = File("Wix.File.wxs");
///            WiXHeat(harvestFiles, filePath, WiXHarvestType.File, new HeatSettings { NoLogo = true });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="objectFile">The object file.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(Cake.Core.IO.FilePath objectFile, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, objectFile, outputFile, harvestType, settings);
}

/// <summary>
///            Harvests files for a website or performance.
///            </summary>
/// <example>
///            <code>
///            var filePath = File("Wix.Website.wxs");
///            WiXHeat("Default Web Site", filePath, WiXHarvestType.Website);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="harvestTarget">The harvest target.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
public void WiXHeat(System.String harvestTarget, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, harvestTarget, outputFile, harvestType);
}

/// <summary>
///            Harvests files for a website or performance.
///            </summary>
/// <example>
///            <code>
///            var filePath = File("Wix.Website.wxs");
///            WiXHeat("Default Web Site", filePath, WiXHarvestType.Website, new HeatSettings { NoLogo = true });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="harvestTarget">The harvest target.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="harvestType">The WiX harvest type.</param>
/// <param name="settings">The settings.</param>
public void WiXHeat(System.String harvestTarget, Cake.Core.IO.FilePath outputFile, Cake.Common.Tools.WiX.Heat.WiXHarvestType harvestType, Cake.Common.Tools.WiX.Heat.HeatSettings settings)
{
    Cake.Common.Tools.WiX.WiXAliases.WiXHeat(Context, harvestTarget, outputFile, harvestType, settings);
}

/// <summary>
///            Signs the specified assembly.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assembly">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            Task("Sign")
///                .IsDependentOn("Clean")
///                .IsDependentOn("Restore")
///                .IsDependentOn("Build")
///                .Does(() =&gt;
///            {
///                var file = "Core.dll";
///                Sign(file, new SignToolSignSettings {
///                        TimeStampUri = new Uri("http://timestamp.digicert.com"),
///                        CertPath = "digitalcertificate.pfx",
///                        Password = "TopSecret"
///                });
///            });
///            </code>
///            </example>
public void Sign(System.String assembly, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
    Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assembly, settings);
}

/// <summary>
///            Signs the specified assembly.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assembly">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            Task("Sign")
///                .IsDependentOn("Clean")
///                .IsDependentOn("Restore")
///                .IsDependentOn("Build")
///                .Does(() =&gt;
///            {
///                var file = new FilePath("Core.dll");
///                Sign(file, new SignToolSignSettings {
///                        TimeStampUri = new Uri("http://timestamp.digicert.com"),
///                        CertPath = "digitalcertificate.pfx",
///                        Password = "TopSecret"
///                });
///            });
///            </code>
///            </example>
public void Sign(Cake.Core.IO.FilePath assembly, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
    Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assembly, settings);
}

/// <summary>
///            Signs the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            Task("Sign")
///                .IsDependentOn("Clean")
///                .IsDependentOn("Restore")
///                .IsDependentOn("Build")
///                .Does(() =&gt;
///            {
///                var files = new string[] { "Core.dll", "Common.dll" };
///                Sign(files, new SignToolSignSettings {
///                        TimeStampUri = new Uri("http://timestamp.digicert.com"),
///                        CertPath = "digitalcertificate.pfx",
///                        Password = "TopSecret"
///                });
///            });
///            </code>
///            </example>
public void Sign(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
    Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assemblies, settings);
}

/// <summary>
///            Signs the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The target assembly.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            Task("Sign")
///                .IsDependentOn("Clean")
///                .IsDependentOn("Restore")
///                .IsDependentOn("Build")
///                .Does(() =&gt;
///            {
///                var files = GetFiles(solutionDir + "/**/bin/" + configuration + "/**/*.exe");
///                Sign(files, new SignToolSignSettings {
///                        TimeStampUri = new Uri("http://timestamp.digicert.com"),
///                        CertPath = "digitalcertificate.pfx",
///                        Password = "TopSecret"
///                });
///            });
///            </code>
///            </example>
public void Sign(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.SignTool.SignToolSignSettings settings)
{
    Cake.Common.Tools.SignTool.SignToolSignAliases.Sign(Context, assemblies, settings);
}

/// <summary>
///            Executes Roundhouse with the given configured settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            RoundhouseMigrate(new RoundhouseSettings{
///                ServerName = "Sql2008R2",
///                DatabaseName = "AdventureWorks2008R2",
///                SqlFilesDirectory = "./src/sql"
///                });
///            </code>
///            </example>
public void RoundhouseMigrate(Cake.Common.Tools.Roundhouse.RoundhouseSettings settings)
{
    Cake.Common.Tools.Roundhouse.RoundhouseAliases.RoundhouseMigrate(Context, settings);
}

/// <summary>
///            Executes Roundhouse migration to drop the database using the provided settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            RoundhouseDrop(new RoundhouseSettings{
///                ServerName = "Sql2008R2",
///                DatabaseName = "AdventureWorks2008R2"
///                });
///            </code>
///            </example>
public void RoundhouseDrop(Cake.Common.Tools.Roundhouse.RoundhouseSettings settings)
{
    Cake.Common.Tools.Roundhouse.RoundhouseAliases.RoundhouseDrop(Context, settings);
}

/// <summary>
///             Creates a release for the specified Octopus Deploy Project.
///             </summary>
/// <param name="context">The cake context.</param>
/// <param name="projectName">The name of the project.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 // Minimum required
///                 OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
///                     Server = "http://octopus-deploy.example",
///                     ApiKey = "API-XXXXXXXXXXXXXXXXXXXX"
///                 });
///            
///                 OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
///                     Server = "http://octopus-deploy.example",
///                     Username = "DeployUser",
///                     Password = "a-very-secure-password"
///                 });
///            
///                 OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
///                     ConfigurationFile = @"C:\OctopusDeploy.config"
///                 });
///            
///                 // Additional Options
///                 OctoCreateRelease(projectNameOnServer, new CreateReleaseSettings {
///                     ToolPath = "./tools/OctopusTools/Octo.exe"
///                     EnableDebugLogging = true,
///                     IgnoreSslErrors = true,
///                     EnableServiceMessages = true, // Enables teamcity services messages when logging
///                     ReleaseNumber = "1.8.2",
///                     DefaultPackageVersion = "1.0.0.0", // All packages in the release should be 1.0.0.0
///                     Packages = new Dictionary&lt;string, string&gt;
///                                 {
///                                     { "PackageOne", "1.0.2.3" },
///                                     { "PackageTwo", "5.2.3" }
///                                 },
///                     PackagesFolder = @"C:\MyOtherNugetFeed",
///            
///                     // One or the other
///                     ReleaseNotes = "Version 2.0 \n What a milestone we have ...",
///                     ReleaseNotesFile = "./ReleaseNotes.md",
///            
///                     IgnoreExisting = true // if this release number already exists, ignore it
///                 });
///             </code>
///             </example>
public void OctoCreateRelease(System.String projectName, Cake.Common.Tools.OctopusDeploy.CreateReleaseSettings settings)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoCreateRelease(Context, projectName, settings);
}

/// <summary>
///            Pushes the specified package to the Octopus Deploy repository
///            </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="packagePath">Path to the package</param>
/// <param name="settings">The settings</param>
public void OctoPush(System.String server, System.String apiKey, Cake.Core.IO.FilePath packagePath, Cake.Common.Tools.OctopusDeploy.OctopusPushSettings settings)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPush(Context, server, apiKey, packagePath, settings);
}

/// <summary>
///            Pushes the specified packages to the Octopus Deploy repository
///            </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="packagePaths">Paths to the packages</param>
/// <param name="settings">The settings</param>
public void OctoPush(System.String server, System.String apiKey, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packagePaths, Cake.Common.Tools.OctopusDeploy.OctopusPushSettings settings)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPush(Context, server, apiKey, packagePaths, settings);
}

/// <summary>
///            Packs the specified folder into an Octopus Deploy package.
///            </summary>
/// <param name="context">The cake context</param>
/// <param name="id">The package ID.</param>
public void OctoPack(System.String id)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPack(Context, id);
}

/// <summary>
///            Packs the specified folder into an Octopus Deploy package.
///            </summary>
/// <param name="context">The cake context</param>
/// <param name="id">The package ID.</param>
/// <param name="settings">The settings</param>
public void OctoPack(System.String id, Cake.Common.Tools.OctopusDeploy.OctopusPackSettings settings = null)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoPack(Context, id, settings);
}

/// <summary>
///             Deploys the specified already existing release into a specified environment
///             See <see href="http://docs.octopusdeploy.com/display/OD/Deploying+releases">Octopus Documentation</see> for more details.
///             </summary>
/// <param name="context">The cake context</param>
/// <param name="server">The Octopus server URL</param>
/// <param name="apiKey">The user's API key</param>
/// <param name="projectName">Name of the target project</param>
/// <param name="deployTo">Target environment name</param>
/// <param name="releaseNumber">Version number of the release to deploy. Specify "latest" for the latest release</param>
/// <param name="settings">Deployment settings</param>
/// <example>
///             <code>
///                 // bare minimum
///                 OctoDeployRelease("http://octopus-deploy.example", "API-XXXXXXXXXXXXXXXXXXXX", "MyGreatProject", "Testing", "2.1.15-RC" new OctopusDeployReleaseDeploymentSettings());
///            
///                 // All of deployment arguments
///                 OctoDeployRelease("http://octopus-deploy.example", "API-XXXXXXXXXXXXXXXXXXXX", "MyGreatProject", "Testing", "2.1.15-RC" new OctopusDeployReleaseDeploymentSettings {
///                     ShowProgress = true,
///                     ForcePackageDownload = true,
///                     WaitForDeployment = true,
///                     DeploymentTimeout = TimeSpan.FromMinutes(1),
///                     CancelOnTimeout = true,
///                     DeploymentChecksLeepCycle = TimeSpan.FromMinutes(77),
///                     GuidedFailure = true,
///                     SpecificMachines = new string[] { "Machine1", "Machine2" },
///                     Force = true,
///                     SkipSteps = new[] { "Step1", "Step2" },
///                     NoRawLog = true,
///                     RawLogFile = "someFile.txt",
///                     DeployAt = new DateTime(2010, 6, 15).AddMinutes(1),
///                     Tenant = new[] { "Tenant1", "Tenant2" },
///                     TenantTags = new[] { "Tag1", "Tag2" },
///                 });
///             </code>
///             </example>
public void OctoDeployRelease(System.String server, System.String apiKey, System.String projectName, System.String deployTo, System.String releaseNumber, Cake.Common.Tools.OctopusDeploy.OctopusDeployReleaseDeploymentSettings settings)
{
    Cake.Common.Tools.OctopusDeploy.OctopusDeployAliases.OctoDeployRelease(Context, server, apiKey, projectName, deployTo, releaseNumber, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            NUnit3("./src/**/bin/Release/*.Tests.dll");
///            </code>
///            </example>
public void NUnit3(System.String pattern)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, pattern);
}

/// <summary>
///            Runs all NUnit unit tests in the assemblies matching the specified pattern,
///            using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NUnit3("./src/**/bin/Release/*.Tests.dll", new NUnit3Settings {
///                NoResults = true
///                });
///            </code>
///            </example>
public void NUnit3(System.String pattern, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, pattern, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            NUnit3(new [] { "./src/Example.Tests/bin/Release/Example.Tests.dll" });
///            </code>
///            </example>
public void NUnit3(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            NUnit3(testAssemblies);
///            </code>
///            </example>
public void NUnit3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NUnit3(new [] { "./src/Example.Tests/bin/Release/Example.Tests.dll" }, new NUnit3Settings {
///                NoResults = true
///                });
///            </code>
///            </example>
public void NUnit3(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var testAssemblies = GetFiles("./src/**/bin/Release/*.Tests.dll");
///            NUnit3(testAssemblies, new NUnit3Settings {
///                NoResults = true
///                });
///            </code>
///            </example>
public void NUnit3(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.NUnit.NUnit3Settings settings)
{
    Cake.Common.Tools.NUnit.NUnit3Aliases.NUnit3(Context, assemblies, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            NUnit("./src/UnitTests/*.dll");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void NUnit(System.String pattern)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, pattern);
}

/// <summary>
///            Runs all NUnit unit tests in the assemblies matching the specified pattern,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            NUnit("./src/UnitTests/*.dll", new NUnitSettings {
///                Timeout = 4000,
///                StopOnError = true
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.String pattern, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, pattern, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var assemblies = new [] {
///                "UnitTests1.dll",
///                "UnitTests2.dll"
///            };
///            NUnit(assemblies);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void NUnit(System.Collections.Generic.IEnumerable<System.String> assemblies)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var assemblies = GetFiles("./src/UnitTests/*.dll");
///            NUnit(assemblies);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
public void NUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            var assemblies = new [] {
///                "UnitTests1.dll",
///                "UnitTests2.dll"
///            };
///            NUnit(assemblies, new NUnitSettings {
///                Timeout = 4000,
///                StopOnError = true
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.Collections.Generic.IEnumerable<System.String> assemblies, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies, settings);
}

/// <summary>
///            Runs all NUnit unit tests in the specified assemblies,
///            using the specified settings.
///            </summary>
/// <example>
///            <code>
///            var assemblies = GetFiles(""./src/UnitTests/*.dll"");
///            NUnit(assemblies, new NUnitSettings {
///                Timeout = 4000,
///                StopOnError = true
///                });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblies">The assemblies.</param>
/// <param name="settings">The settings.</param>
public void NUnit(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblies, Cake.Common.Tools.NUnit.NUnitSettings settings)
{
    Cake.Common.Tools.NUnit.NUnitAliases.NUnit(Context, assemblies, settings);
}

/// <summary>
///             Creates a NuGet package using the specified Nuspec or project file.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The nuspec or project file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var nuGetPackSettings   = new NuGetPackSettings {
///                                                 Id                      = "TestNuget",
///                                                 Version                 = "0.0.0.1",
///                                                 Title                   = "The tile of the package",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Description             = "The description of the package",
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestNuget/"),
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
///                                                 Copyright               = "Some company 2015",
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 RequireLicenseAcceptance= false,
///                                                 Symbols                 = false,
///                                                 NoPackageAnalysis       = true,
///                                                 Files                   = new [] {
///                                                                                      new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
///                                                                                   },
///                                                 BasePath                = "./src/TestNuget/bin/release",
///                                                 OutputDirectory         = "./nuget"
///                                             };
///            
///                 NuGetPack("./nuspec/TestNuget.nuspec", nuGetPackSettings);
///             </code>
///             </example>
public void NuGetPack(Cake.Core.IO.FilePath filePath, Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, filePath, settings);
}

/// <summary>
///             Creates NuGet packages using the specified Nuspec or project files.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The nuspec or project file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var nuGetPackSettings   = new NuGetPackSettings {
///                                                 Id                      = "TestNuget",
///                                                 Version                 = "0.0.0.1",
///                                                 Title                   = "The tile of the package",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Description             = "The description of the package",
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestNuget/"),
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
///                                                 Copyright               = "Some company 2015",
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 RequireLicenseAcceptance= false,
///                                                 Symbols                 = false,
///                                                 NoPackageAnalysis       = true,
///                                                 Files                   = new [] {
///                                                                                      new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
///                                                                                   },
///                                                 BasePath                = "./src/TestNuget/bin/release",
///                                                 OutputDirectory         = "./nuget"
///                                             };
///            
///                 var nuspecFiles = GetFiles("./**/*.nuspec");
///                 NuGetPack(nuspecFiles, nuGetPackSettings);
///             </code>
///             </example>
public void NuGetPack(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, filePaths, settings);
}

/// <summary>
///             Creates a NuGet package using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///                 var nuGetPackSettings   = new NuGetPackSettings {
///                                                 Id                      = "TestNuget",
///                                                 Version                 = "0.0.0.1",
///                                                 Title                   = "The tile of the package",
///                                                 Authors                 = new[] {"John Doe"},
///                                                 Owners                  = new[] {"Contoso"},
///                                                 Description             = "The description of the package",
///                                                 Summary                 = "Excellent summary of what the package does",
///                                                 ProjectUrl              = new Uri("https://github.com/SomeUser/TestNuget/"),
///                                                 IconUrl                 = new Uri("http://cdn.rawgit.com/SomeUser/TestNuget/master/icons/testnuget.png"),
///                                                 LicenseUrl              = new Uri("https://github.com/SomeUser/TestNuget/blob/master/LICENSE.md"),
///                                                 Copyright               = "Some company 2015",
///                                                 ReleaseNotes            = new [] {"Bug fixes", "Issue fixes", "Typos"},
///                                                 Tags                    = new [] {"Cake", "Script", "Build"},
///                                                 RequireLicenseAcceptance= false,
///                                                 Symbols                 = false,
///                                                 NoPackageAnalysis       = true,
///                                                 Files                   = new [] {
///                                                                                      new NuSpecContent {Source = "bin/TestNuget.dll", Target = "bin"},
///                                                                                   },
///                                                 BasePath                = "./src/TestNuget/bin/release",
///                                                 OutputDirectory         = "./nuget"
///                                             };
///            
///                 NuGetPack(nuGetPackSettings);
///             </code>
///             </example>
public void NuGetPack(Cake.Common.Tools.NuGet.Pack.NuGetPackSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetPack(Context, settings);
}

/// <summary>
///            Restores NuGet packages for the specified target.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePath">The target to restore.</param>
/// <example>
///            <code>
///                var solutions = GetFiles("./**/*.sln");
///                // Restore all NuGet packages.
///                foreach(var solution in solutions)
///                {
///                    Information("Restoring {0}", solution);
///                    NuGetRestore(solution);
///                }
///            </code>
///            </example>
public void NuGetRestore(Cake.Core.IO.FilePath targetFilePath)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePath);
}

/// <summary>
///            Restores NuGet packages for the specified targets.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePaths">The targets to restore.</param>
/// <example>
///            <code>
///                var solutions = GetFiles("./**/*.sln");
///                NuGetRestore(solutions);
///            </code>
///            </example>
public void NuGetRestore(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFilePaths)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePaths);
}

/// <summary>
///            Restores NuGet packages using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePath">The target to restore.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///                var solutions = GetFiles("./**/*.sln");
///                // Restore all NuGet packages.
///                foreach(var solution in solutions)
///                {
///                    Information("Restoring {0}", solution);
///                    NuGetRestore(solution, new NuGetRestoreSettings { NoCache = true });
///                }
///            </code>
///            </example>
public void NuGetRestore(Cake.Core.IO.FilePath targetFilePath, Cake.Common.Tools.NuGet.Restore.NuGetRestoreSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePath, settings);
}

/// <summary>
///            Restores NuGet packages using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFilePaths">The targets to restore.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///                var solutions = GetFiles("./**/*.sln");
///                NuGetRestore(solutions, new NuGetRestoreSettings { NoCache = true });
///            </code>
///            </example>
public void NuGetRestore(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFilePaths, Cake.Common.Tools.NuGet.Restore.NuGetRestoreSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRestore(Context, targetFilePaths, settings);
}

/// <summary>
///             Pushes a NuGet package to a NuGet server and publishes it.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePath">The <c>.nupkg</c> file path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <para>NOTE: Starting with NuGet 3.4.2, the Source parameter is a mandatory parameter.</para>
///             <para>It is strongly recommended that you ALWAYS set the Source property within the <see cref="T:Cake.Common.Tools.NuGet.Push.NuGetPushSettings" /> instance.</para>
///             <code>
///             // Get the path to the package.
///             var package = "./nuget/SlackPRTGCommander.0.0.1.nupkg";
///            
///             // Push the package.
///             NuGetPush(package, new NuGetPushSettings {
///                 Source = "http://example.com/nugetfeed",
///                 ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
///             });
///             </code>
///             </example>
public void NuGetPush(Cake.Core.IO.FilePath packageFilePath, Cake.Common.Tools.NuGet.Push.NuGetPushSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetPush(Context, packageFilePath, settings);
}

/// <summary>
///             Pushes NuGet packages to a NuGet server and publishes them.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageFilePaths">The <c>.nupkg</c> file paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <para>NOTE: Starting with NuGet 3.4.2, the Source parameter is a mandatory parameter.</para>
///             <para>It is strongly recommended that you ALWAYS set the Source property within the <see cref="T:Cake.Common.Tools.NuGet.Push.NuGetPushSettings" /> instance.</para>
///             <code>
///             // Get the paths to the packages.
///             var packages = GetFiles("./**/*.nupkg");
///            
///             // Push the package.
///             NuGetPush(packages, new NuGetPushSettings {
///                 Source = "http://example.com/nugetfeed",
///                 ApiKey = "4003d786-cc37-4004-bfdf-c4f3e8ef9b3a"
///             });
///             </code>
///             </example>
public void NuGetPush(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageFilePaths, Cake.Common.Tools.NuGet.Push.NuGetPushSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetPush(Context, packageFilePaths, settings);
}

/// <summary>
///             Adds NuGet package source using the specified name &amp;source to global user config
///             </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
///             <code>
///             var feed = new
///                         {
///                             Name = EnvironmentVariable("PUBLIC_FEED_NAME"),
///                             Source = EnvironmentVariable("PUBLIC_FEED_SOURCE")
///                         };
///            
///             NuGetAddSource(
///                 name:feed.Name,
///                 source:feed.Source
///             );
///             </code>
///             </example>
public void NuGetAddSource(System.String name, System.String source)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetAddSource(Context, name, source);
}

/// <summary>
///             Adds NuGet package source using the specified name, source &amp; settings to global user config
///             </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var nugetSourceSettings = new NuGetSourcesSettings
///                                         {
///                                             UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
///                                             Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
///                                             IsSensitiveSource = true,
///                                             Verbosity = NuGetVerbosity.Detailed
///                                         };
///            
///             var feed = new
///                         {
///                             Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
///                             Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
///                         };
///            
///             NuGetAddSource(
///                 name:feed.Name,
///                 source:feed.Source,
///                 settings:nugetSourceSettings
///             );
///             </code>
///             </example>
public void NuGetAddSource(System.String name, System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetAddSource(Context, name, source, settings);
}

/// <summary>
///             Removes NuGet package source using the specified name &amp; source from global user config
///             </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <example>
///             <code>
///             var feed = new
///                         {
///                             Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
///                             Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
///                         };
///            
///             NuGetRemoveSource(
///                name:feed.Name,
///                source:feed.Source
///             );
///             </code>
///             </example>
public void NuGetRemoveSource(System.String name, System.String source)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRemoveSource(Context, name, source);
}

/// <summary>
///             Removes NuGet package source using the specified name, source &amp; settings from global user config
///             </summary>
/// <param name="context">The context.</param>
/// <param name="name">Name of the source.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var nugetSourceSettings = new NuGetSourcesSettings
///                                         {
///                                             UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
///                                             Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
///                                             IsSensitiveSource = true,
///                                             Verbosity = NuGetVerbosity.Detailed
///                                         };
///            
///             var feed = new
///                         {
///                             Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
///                             Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
///                         };
///            
///             NuGetRemoveSource(
///                name:feed.Name,
///                source:feed.Source,
///                settings:nugetSourceSettings
///             );
///             </code>
///             </example>
public void NuGetRemoveSource(System.String name, System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetRemoveSource(Context, name, source, settings);
}

/// <summary>
///            Checks whether or not a NuGet package source exists in the global user configuration, using the specified source.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <returns>Whether or not the NuGet package source exists in the global user configuration.</returns>
/// <example>
///              <code>
///            var feed = new
///            {
///                Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
///                Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
///            };
///            if (!NuGetHasSource(source:feed.Source))
///            {
///                Information("Source missing");
///            }
///            else
///            {
///                Information("Source already exists");
///            }
///            </code>
///            </example>
public System.Boolean NuGetHasSource(System.String source)
{
    return Cake.Common.Tools.NuGet.NuGetAliases.NuGetHasSource(Context, source);
}

/// <summary>
///            Checks whether or not a NuGet package source exists in the global user configuration, using the specified source and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="source">Path to the package(s) source.</param>
/// <param name="settings">The settings.</param>
/// <returns>Whether the specified NuGet package source exist.</returns>
/// <example>
///              <code>
///            var nugetSourceSettings = new NuGetSourcesSettings
///            {
///                UserName = EnvironmentVariable("PRIVATE_FEED_USERNAME"),
///                Password = EnvironmentVariable("PRIVATE_FEED_PASSWORD"),
///                IsSensitiveSource = true,
///                Verbosity = NuGetVerbosity.Detailed
///            };
///            var feed = new
///            {
///                Name = EnvironmentVariable("PRIVATE_FEED_NAME"),
///                Source = EnvironmentVariable("PRIVATE_FEED_SOURCE")
///            };
///            if (!NuGetHasSource(
///                source:feed.Source,
///                settings:nugetSourceSettings))
///            {
///                Information("Source missing");
///            }
///            else
///            {
///                Information("Source already exists");
///            }
///            </code>
///            </example>
public System.Boolean NuGetHasSource(System.String source, Cake.Common.Tools.NuGet.Sources.NuGetSourcesSettings settings)
{
    return Cake.Common.Tools.NuGet.NuGetAliases.NuGetHasSource(Context, source, settings);
}

/// <summary>
///            Installs a NuGet package.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <example>
///            <code>
///            NuGetInstall("MyNugetPackage");
///            </code>
///            </example>
public void NuGetInstall(System.String packageId)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageId);
}

/// <summary>
///            Installs NuGet packages.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The id's of the package to install.</param>
/// <example>
///            <code>
///            NuGetInstall(new[] { "MyNugetPackage", "OtherNugetPackage" });
///            </code>
///            </example>
public void NuGetInstall(System.Collections.Generic.IEnumerable<System.String> packageIds)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageIds);
}

/// <summary>
///            Installs a NuGet package using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetInstall("MyNugetPackage", new NuGetInstallSettings {
///                ExcludeVersion  = true,
///                OutputDirectory = "./tools"
///                });
///            </code>
///            </example>
public void NuGetInstall(System.String packageId, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageId, settings);
}

/// <summary>
///            Installs NuGet packages using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageIds">The id's of the package to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetInstall(new[] { "MyNugetPackage", "OtherNugetPackage" }, new NuGetInstallSettings {
///                ExcludeVersion  = true,
///                OutputDirectory = "./tools"
///                });
///            </code>
///            </example>
public void NuGetInstall(System.Collections.Generic.IEnumerable<System.String> packageIds, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstall(Context, packageIds, settings);
}

/// <summary>
///            Installs NuGet packages using the specified package configuration.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <example>
///            <code>
///            NuGetInstallFromConfig("./tools/packages.config");
///            </code>
///            </example>
public void NuGetInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPath);
}

/// <summary>
///             Installs NuGet packages using the specified package configurations.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPaths">The package configurations to install.</param>
/// <example>
///             <code>
///             var packageConfigs = GetFiles("./**/packages.config");
///            
///             NuGetInstallFromConfig(packageConfigs);
///             </code>
///             </example>
public void NuGetInstallFromConfig(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageConfigPaths)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPaths);
}

/// <summary>
///            Installs NuGet packages using the specified package configuration and settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPath">The package configuration to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetInstallFromConfig("./tools/packages.config", new NuGetInstallSettings {
///                ExcludeVersion  = true,
///                OutputDirectory = "./tools"
///                });
///            </code>
///            </example>
public void NuGetInstallFromConfig(Cake.Core.IO.FilePath packageConfigPath, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPath, settings);
}

/// <summary>
///             Installs NuGet packages using the specified package configurations and settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="packageConfigPaths">The package configurations to install.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var packageConfigs = GetFiles("./**/packages.config");
///            
///             NuGetInstallFromConfig(packageConfigs, new NuGetInstallSettings {
///                 ExcludeVersion  = true,
///                 OutputDirectory = "./tools"
///                 });
///             </code>
///             </example>
public void NuGetInstallFromConfig(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> packageConfigPaths, Cake.Common.Tools.NuGet.Install.NuGetInstallSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInstallFromConfig(Context, packageConfigPaths, settings);
}

/// <summary>
///            Installs NuGet packages using the specified API key, source and settings.
///            </summary>
/// <example>
///            <code>
///            var setting = new NuGetSetApiKeySettings {
///                Verbosity = NuGetVerbosity.Detailed
///                };
///            NuGetSetApiKey("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "https://nuget.org/api/v2/", setting);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API key.</param>
/// <param name="source">Server URL where the API key is valid.</param>
/// <param name="settings">The settings.</param>
public void NuGetSetApiKey(System.String apiKey, System.String source, Cake.Common.Tools.NuGet.SetApiKey.NuGetSetApiKeySettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetApiKey(Context, apiKey, source, settings);
}

/// <summary>
///            Installs NuGet packages using the specified API key and source.
///            </summary>
/// <example>
///            <code>
///            NuGetSetApiKey("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "https://nuget.org/api/v2/");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="apiKey">The API key.</param>
/// <param name="source">Server URL where the API key is valid.</param>
public void NuGetSetApiKey(System.String apiKey, System.String source)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetApiKey(Context, apiKey, source);
}

/// <summary>
///            Set the proxy settings to be used while connecting to your NuGet feed, including settings.
///            </summary>
/// <example>
///            <code>
///            var setting = new NuGetSetProxySettings {
///                Verbosity = NuGetVerbosity.Detailed
///                };
///            NuGetSetProxy("127.0.0.1:8080", "proxyuser","Pa$$w0rd1", setting);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="proxy">The url of the proxy.</param>
/// <param name="username">The username used to access the proxy.</param>
/// <param name="password">The password used to access the proxy.</param>
/// <param name="settings">The settings.</param>
public void NuGetSetProxy(System.String proxy, System.String username, System.String password, Cake.Common.Tools.NuGet.SetProxy.NuGetSetProxySettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetProxy(Context, proxy, username, password, settings);
}

/// <summary>
///            Set the proxy settings to be used while connecting to your NuGet feed.
///            </summary>
/// <example>
///            <code>
///            NuGetSetProxy("127.0.0.1:8080", "proxyuser","Pa$$w0rd1");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="proxy">The url of the proxy.</param>
/// <param name="username">The username used to access the proxy.</param>
/// <param name="password">The password used to access the proxy.</param>
public void NuGetSetProxy(System.String proxy, System.String username, System.String password)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetSetProxy(Context, proxy, username, password);
}

/// <summary>
///            Updates NuGet packages.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFile">The target to update.</param>
/// <example>
///            <code>
///            NuGetUpdate("./tools/packages.config");
///            </code>
///            </example>
public void NuGetUpdate(Cake.Core.IO.FilePath targetFile)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFile);
}

/// <summary>
///             Updates NuGet packages.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="targetFiles">The targets to update.</param>
/// <example>
///             <code>
///             var targets = GetFiles("./**/packages.config");
///            
///             NuGetUpdate(targets);
///             </code>
///             </example>
public void NuGetUpdate(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFiles)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFiles);
}

/// <summary>
///            Updates NuGet packages using the specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="targetFile">The target to update.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetUpdate("./tools/packages.config", new NuGetUpdateSettings {
///                Prerelease = true,
///            });
///            </code>
///            </example>
public void NuGetUpdate(Cake.Core.IO.FilePath targetFile, Cake.Common.Tools.NuGet.Update.NuGetUpdateSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFile, settings);
}

/// <summary>
///             Updates NuGet packages using the specified settings.
///             </summary>
/// <param name="context">The context.</param>
/// <param name="targetFiles">The targets to update.</param>
/// <param name="settings">The settings.</param>
/// <example>
///             <code>
///             var targets = GetFiles("./**/packages.config");
///            
///             NuGetUpdate(targets, new NuGetUpdateSettings {
///                 Prerelease = true,
///             });
///             </code>
///             </example>
public void NuGetUpdate(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> targetFiles, Cake.Common.Tools.NuGet.Update.NuGetUpdateSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetUpdate(Context, targetFiles, settings);
}

/// <summary>
///            Adds a NuGet package using package id and source.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to add.</param>
/// <param name="source">Path to the local feed source.</param>
/// <example>
///            <code>
///            NuGetAdd("MyNugetPackage", "//bar/packages/");
///            </code>
///            </example>
public void NuGetAdd(System.String packageId, System.String source)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetAdd(Context, packageId, source);
}

/// <summary>
///            Adds a NuGet package using package id and source.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="packageId">The id of the package to add.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetAdd("MyNugetPackage", new NuGetAddSettings({
///                Source = "//bar/packages/"
///                });
///            </code>
///            </example>
public void NuGetAdd(System.String packageId, Cake.Common.Tools.NuGet.Add.NuGetAddSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetAdd(Context, packageId, settings);
}

/// <summary>
///            Adds all packages from source to destination.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="source">The local feed package source.</param>
/// <param name="destination">The local feed destination source.</param>
/// <example>
///            <code>
///            NuGetInit("//foo/packages", "//bar/packages/");
///            </code>
///            </example>
public void NuGetInit(System.String source, System.String destination)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInit(Context, source, destination);
}

/// <summary>
///            Adds all packages from source to destination using specified settings.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="source">The local feed package source.</param>
/// <param name="destination">The local feed destination source.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            NuGetInit("//foo/packages", "//bar/packages/", new NuGetInitSettings {
///                Expand = true
///                });
///            </code>
///            </example>
public void NuGetInit(System.String source, System.String destination, Cake.Common.Tools.NuGet.Init.NuGetInitSettings settings)
{
    Cake.Common.Tools.NuGet.NuGetAliases.NuGetInit(Context, source, destination, settings);
}

/// <summary>
///            Runs all MSTest unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            MSTest("./Tests/*.UnitTests.dll");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
public void MSTest(System.String pattern)
{
    Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, pattern);
}

/// <summary>
///            Runs all MSTest unit tests in the assemblies matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            MSTest("./Tests/*.UnitTests.dll", new MSTestSettings() { NoIsolation = false });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="settings">The settings.</param>
public void MSTest(System.String pattern, Cake.Common.Tools.MSTest.MSTestSettings settings)
{
    Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, pattern, settings);
}

/// <summary>
///            Runs all MSTest unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
///            MSTest(paths);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
public void MSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
    Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, assemblyPaths);
}

/// <summary>
///            Runs all MSTest unit tests in the specified assemblies.
///            </summary>
/// <example>
///            <code>
///            var paths = new List&lt;FilePath&gt;() { "./assemblydir1", "./assemblydir2" };
///            MSTest(paths, new MSTestSettings() { NoIsolation = false });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
public void MSTest(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.MSTest.MSTestSettings settings)
{
    Cake.Common.Tools.MSTest.MSTestAliases.MSTest(Context, assemblyPaths, settings);
}

/// <summary>
///            Builds the specified solution using MSBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution.</param>
/// <example>
///            <code>
///            MSBuild("./src/Cake.sln");
///            </code>
///            </example>
public void MSBuild(Cake.Core.IO.FilePath solution)
{
    Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution);
}

/// <summary>
///            Builds the specified solution using MSBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="configurator">The settings configurator.</param>
/// <example>
///            <code>
///            MSBuild("./src/Cake.sln", configurator =&gt;
///                configurator.SetConfiguration("Debug")
///                    .SetVerbosity(Verbosity.Minimal)
///                    .UseToolVersion(MSBuildToolVersion.VS2015)
///                    .SetMSBuildPlatform(MSBuildPlatform.x86)
///                    .SetPlatformTarget(PlatformTarget.MSIL));
///            </code>
///            </example>
public void MSBuild(Cake.Core.IO.FilePath solution, System.Action<Cake.Common.Tools.MSBuild.MSBuildSettings> configurator)
{
    Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution, configurator);
}

/// <summary>
///            Builds the specified solution using MSBuild.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solution">The solution to build.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            MSBuild("./src/Cake.sln", new MSBuildSettings {
///                Verbosity = Verbosity.Minimal,
///                ToolVersion = MSBuildToolVersion.VS2015,
///                Configuration = "Release",
///                PlatformTarget = PlatformTarget.MSIL
///                });
///            </code>
///            </example>
public void MSBuild(Cake.Core.IO.FilePath solution, Cake.Common.Tools.MSBuild.MSBuildSettings settings)
{
    Cake.Common.Tools.MSBuild.MSBuildAliases.MSBuild(Context, solution, settings);
}

/// <summary>
///            Merges the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <example>
///            <code>
///            var assemblyPaths = GetFiles("./**/Cake.*.dll");
///            ILMerge("./MergedCake.exe", "./Cake.exe", assemblyPaths);
///            </code>
///            </example>
public void ILMerge(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths)
{
    Cake.Common.Tools.ILMerge.ILMergeAliases.ILMerge(Context, outputFile, primaryAssembly, assemblyPaths);
}

/// <summary>
///            Merges the specified assemblies.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputFile">The output file.</param>
/// <param name="primaryAssembly">The primary assembly.</param>
/// <param name="assemblyPaths">The assembly paths.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var assemblyPaths = GetFiles("./**/Cake.*.dll");
///            ILMerge(
///                "./MergedCake.exe",
///                "./Cake.exe",
///                assemblyPaths,
///                new ILMergeSettings { Internalize = true });
///            </code>
///            </example>
public void ILMerge(Cake.Core.IO.FilePath outputFile, Cake.Core.IO.FilePath primaryAssembly, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> assemblyPaths, Cake.Common.Tools.ILMerge.ILMergeSettings settings)
{
    Cake.Common.Tools.ILMerge.ILMergeAliases.ILMerge(Context, outputFile, primaryAssembly, assemblyPaths, settings);
}

/// <summary>
///            Executes cake script out of process
///            </summary>
/// <param name="context">The context.</param>
/// <param name="cakeScriptPath">The script file.</param>
/// <example>
///            <code>
///            CakeExecuteScript("./helloworld.cake");
///            </code>
///            </example>
public void CakeExecuteScript(Cake.Core.IO.FilePath cakeScriptPath)
{
    Cake.Common.Tools.Cake.CakeAliases.CakeExecuteScript(Context, cakeScriptPath);
}

/// <summary>
///            Executes cake script out of process
///            </summary>
/// <param name="context">The context.</param>
/// <param name="cakeScriptPath">The script file.</param>
/// <param name="settings">The settings <see cref="T:Cake.Common.Tools.Cake.CakeSettings" />.</param>
/// <example>
///            <code>
///            CakeExecuteScript("./helloworld.cake", new CakeSettings{ ToolPath="./Cake.exe" });
///            </code>
///            </example>
public void CakeExecuteScript(Cake.Core.IO.FilePath cakeScriptPath, Cake.Common.Tools.Cake.CakeSettings settings)
{
    Cake.Common.Tools.Cake.CakeAliases.CakeExecuteScript(Context, cakeScriptPath, settings);
}

/// <summary>
///            Executes Cake expression out of process
///            </summary>
/// <param name="context">The context.</param>
/// <param name="cakeExpression">The cake expression</param>
/// <example>
///            <code>
///            CakeExecuteExpression("Information(\"Hello {0}\", \"World\");");
///            </code>
///            </example>
public void CakeExecuteExpression(System.String cakeExpression)
{
    Cake.Common.Tools.Cake.CakeAliases.CakeExecuteExpression(Context, cakeExpression);
}

/// <summary>
///            Executes Cake expression out of process
///            </summary>
/// <param name="context">The context.</param>
/// <param name="cakeExpression">The cake expression</param>
/// <param name="settings">The settings <see cref="T:Cake.Common.Tools.Cake.CakeSettings" />.</param>
/// <example>
///            <code>
///            CakeExecuteExpression(
///                "Information(\"Hello {0}!\", Argument&lt;string&gt;(\"name\"));",
///                new CakeSettings {
///                    ToolPath="./Cake.exe" ,
///                    Arguments = new Dictionary&lt;string, string&gt;{{"name", "World"}}
///                    });
///            </code>
///            </example>
public void CakeExecuteExpression(System.String cakeExpression, Cake.Common.Tools.Cake.CakeSettings settings)
{
    Cake.Common.Tools.Cake.CakeAliases.CakeExecuteExpression(Context, cakeExpression, settings);
}

/// <summary>
///            Creates a text transformation from the provided template.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="template">The template.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
///            This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
///            the specified template.
///            <code>
///            string text = TransformText("Hello &lt;%subject%&gt;!")
///               .WithToken("subject", "world")
///               .ToString();
///            </code>
///            </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformText(System.String template)
{
    return Cake.Common.Text.TextTransformationAliases.TransformText(Context, template);
}

/// <summary>
///            Creates a text transformation from the provided template, using the specified placeholder.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="template">The template.</param>
/// <param name="leftPlaceholder">The left placeholder.</param>
/// <param name="rightPlaceholder">The right placeholder.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
///            This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
///            the specified template and placeholder.
///            <code>
///            string text = TransformText("Hello {subject}!", "{", "}")
///               .WithToken("subject", "world")
///               .ToString();
///            </code>
///            </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformText(System.String template, System.String leftPlaceholder, System.String rightPlaceholder)
{
    return Cake.Common.Text.TextTransformationAliases.TransformText(Context, template, leftPlaceholder, rightPlaceholder);
}

/// <summary>
///            Creates a text transformation from the provided template on disc.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="path">The template file path.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
///            This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
///            the specified template file with the placeholder format <c>&lt;%key%&gt;</c>.
///            <code>
///            string text = TransformTextFile("./template.txt")
///               .WithToken("subject", "world")
///               .ToString();
///            </code>
///            </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformTextFile(Cake.Core.IO.FilePath path)
{
    return Cake.Common.Text.TextTransformationAliases.TransformTextFile(Context, path);
}

/// <summary>
///            Creates a text transformation from the provided template on disc, using the specified placeholder.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="path">The template file path.</param>
/// <param name="leftPlaceholder">The left placeholder.</param>
/// <param name="rightPlaceholder">The right placeholder.</param>
/// <returns>A <see cref="T:Cake.Common.Text.TextTransformation`1" /> representing the provided template.</returns>
/// <example>
///            This sample shows how to create a <see cref="T:Cake.Common.Text.TextTransformation`1" /> using
///            the specified template file and placeholder.
///            <code>
///            string text = TransformTextFile("./template.txt", "{", "}")
///               .WithToken("subject", "world")
///               .ToString();
///            </code>
///            </example>
public Cake.Common.Text.TextTransformation<Cake.Core.Text.TextTransformationTemplate> TransformTextFile(Cake.Core.IO.FilePath path, System.String leftPlaceholder, System.String rightPlaceholder)
{
    return Cake.Common.Text.TextTransformationAliases.TransformTextFile(Context, path, leftPlaceholder, rightPlaceholder);
}

/// <summary>
///            Parses project information from a solution file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="solutionPath">The solution path.</param>
/// <returns>A parsed solution.</returns>
/// <example>
///            <code>
///            var solutionPath = "./src/Cake.sln";
///            Information("Parsing {0}", solutionPath);
///            var parsedSolution = ParseSolution(solutionPath);
///            foreach(var project in parsedSolution.Projects)
///            {
///                Information(
///                    @"Solution project file:
///                Name: {0}
///                Path: {1}
///                Id  : {2}
///                Type: {3}",
///                    project.Name,
///                    project.Path,
///                    project.Id,
///                    project.Type
///                );
///            }
///            </code>
///            </example>
public Cake.Common.Solution.SolutionParserResult ParseSolution(Cake.Core.IO.FilePath solutionPath)
{
    return Cake.Common.Solution.SolutionAliases.ParseSolution(Context, solutionPath);
}

/// <summary>
///            Parses project information from project file
///            </summary>
/// <param name="context">The context.</param>
/// <param name="projectPath">The project file path.</param>
/// <returns>A parsed project.</returns>
/// <example>
///            <code>
///            var parsedProject = ParseProject("./src/Cake/Cake.csproj");
///            Information(
///                @"    Parsed project file:
///                Configuration         : {0}
///                Platform              : {1}
///                OutputType            : {2}
///                OutputPath            : {3}
///                RootNameSpace         : {4}
///                AssemblyName          : {5}
///                TargetFrameworkVersion: {6}
///                Files                 : {7}",
///                parsedProject.Configuration,
///                parsedProject.Platform,
///                parsedProject.OutputType,
///                parsedProject.OutputPath,
///                parsedProject.RootNameSpace,
///                parsedProject.AssemblyName,
///                parsedProject.TargetFrameworkVersion,
///                string.Concat(
///                    parsedProject
///                        .Files
///                        .Select(
///                            file=&gt;  string.Format(
///                                        "\r\n            {0}",
///                                        file.FilePath
///                                    )
///                        )
///                )
///            );
///            </code>
///            </example>
public Cake.Common.Solution.Project.ProjectParserResult ParseProject(Cake.Core.IO.FilePath projectPath)
{
    return Cake.Common.Solution.Project.ProjectAliases.ParseProject(Context, projectPath);
}

/// <summary>
///            Parses Xml documentation example code from given path.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="xmlFilePath">The Path to the file to parse.</param>
/// <returns>Parsed example code.</returns>
/// <example>
///            <code>
///            var exampleCodes = ParseXmlDocExampleCode("./Cake.Common.xml");
///            foreach(var exampleCode in exampleCodes)
///            {
///                Information(
///                    "{0}\r\n{1}",
///                    exampleCode.Name,
///                    exampleCode.Code
///                );
///            }
///            </code>
///            </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Solution.Project.XmlDoc.XmlDocExampleCode> ParseXmlDocExampleCode(Cake.Core.IO.FilePath xmlFilePath)
{
    return Cake.Common.Solution.Project.XmlDoc.XmlDocAliases.ParseXmlDocExampleCode(Context, xmlFilePath);
}

/// <summary>
///            Parses Xml documentation example code from file(s) using given pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The globber file pattern.</param>
/// <returns>Parsed example code.</returns>
/// <example>
///            <code>
///            var filesExampleCodes = ParseXmlDocFilesExampleCode("./Cake.*.xml");
///            foreach(var exampleCode in filesExampleCodes)
///            {
///                Information(
///                    "{0}\r\n{1}",
///                    exampleCode.Name,
///                    exampleCode.Code
///                );
///            }
///            </code>
///            </example>
public System.Collections.Generic.IEnumerable<Cake.Common.Solution.Project.XmlDoc.XmlDocExampleCode> ParseXmlDocFilesExampleCode(System.String pattern)
{
    return Cake.Common.Solution.Project.XmlDoc.XmlDocAliases.ParseXmlDocFilesExampleCode(Context, pattern);
}

/// <summary>
///            Creates an assembly information file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
/// <example>
///            <code>
///            var file = "./SolutionInfo.cs";
///            var version = "0.0.1";
///            var buildNo = "123";
///            var semVersion = string.Concat(version + "-" + buildNo);
///            CreateAssemblyInfo(file, new AssemblyInfoSettings {
///                Product = "SampleProject",
///                Version = version,
///                FileVersion = version,
///                InformationalVersion = semVersion,
///                Copyright = string.Format("Copyright (c) Contoso 2014 - {0}", DateTime.Now.Year)
///            });
///            </code>
///            </example>
public void CreateAssemblyInfo(Cake.Core.IO.FilePath outputPath, Cake.Common.Solution.Project.Properties.AssemblyInfoSettings settings)
{
    Cake.Common.Solution.Project.Properties.AssemblyInfoAliases.CreateAssemblyInfo(Context, outputPath, settings);
}

/// <summary>
///            Parses an existing assembly information file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="assemblyInfoPath">The assembly info path.</param>
/// <returns>The content of the assembly info file.</returns>
/// <example>
///            <code>
///            var assemblyInfo = ParseAssemblyInfo("./SolutionInfo.cs");
///            Information("Version: {0}", assemblyInfo.AssemblyVersion);
///            Information("File version: {0}", assemblyInfo.AssemblyFileVersion);
///            Information("Informational version: {0}", assemblyInfo.AssemblyInformationalVersion);
///            </code>
///            </example>
public Cake.Common.Solution.Project.Properties.AssemblyInfoParseResult ParseAssemblyInfo(Cake.Core.IO.FilePath assemblyInfoPath)
{
    return Cake.Common.Solution.Project.Properties.AssemblyInfoAliases.ParseAssemblyInfo(Context, assemblyInfoPath);
}

/// <summary>
///            Downloads the specified resource over HTTP to a temporary file.
///            </summary>
/// <example>
///            <code>
///            var resource = DownloadFile("http://www.example.org/index.html");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.String address)
{
    return Cake.Common.Net.HttpAliases.DownloadFile(Context, address);
}

/// <summary>
///            Downloads the specified resource over HTTP to a temporary file with specified settings.
///            </summary>
/// <example>
///            <code>
///            var resource = DownloadFile("http://www.example.org/index.html", new DownloadFileSettings()
///            {
///                Username = "bob",
///                Password = "builder"
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="settings">The settings.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.String address, Cake.Common.Net.DownloadFileSettings settings)
{
    return Cake.Common.Net.HttpAliases.DownloadFile(Context, address, settings);
}

/// <summary>
///            Downloads the specified resource over HTTP to a temporary file.
///            </summary>
/// <example>
///            <code>
///            var address = new Uri("http://www.example.org/index.html");
///            var resource = DownloadFile(address);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of file to download.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.Uri address)
{
    return Cake.Common.Net.HttpAliases.DownloadFile(Context, address);
}

/// <summary>
///            Downloads the specified resource over HTTP to a temporary file with specified settings.
///            </summary>
/// <example>
///            <code>
///            var address = new Uri("http://www.example.org/index.html");
///            var resource = DownloadFile(address, new DownloadFileSettings()
///            {
///                Username = "bob",
///                Password = "builder"
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of file to download.</param>
/// <param name="settings">The settings.</param>
/// <returns>The path to the downloaded file.</returns>
public Cake.Core.IO.FilePath DownloadFile(System.Uri address, Cake.Common.Net.DownloadFileSettings settings)
{
    return Cake.Common.Net.HttpAliases.DownloadFile(Context, address, settings);
}

/// <summary>
///            Downloads the specified resource over HTTP to the specified output path.
///            </summary>
/// <example>
///            <code>
///            var outputPath = File("./index.html");
///            DownloadFile("http://www.example.org/index.html", outputPath);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
public void DownloadFile(System.String address, Cake.Core.IO.FilePath outputPath)
{
    Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath);
}

/// <summary>
///            Downloads the specified resource over HTTP to the specified output path and settings.
///            </summary>
/// <example>
///            <code>
///            var outputPath = File("./index.html");
///            DownloadFile("http://www.example.org/index.html", outputPath, new DownloadFileSettings()
///            {
///                Username = "bob",
///                Password = "builder"
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
public void DownloadFile(System.String address, Cake.Core.IO.FilePath outputPath, Cake.Common.Net.DownloadFileSettings settings)
{
    Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath, settings);
}

/// <summary>
///            Downloads the specified resource over HTTP to the specified output path.
///            </summary>
/// <example>
///            <code>
///            var address = new Uri("http://www.example.org/index.html");
///            var outputPath = File("./index.html");
///            DownloadFile(address, outputPath, new DownloadFileSettings()
///            {
///                Username = "bob",
///                Password = "builder"
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the resource to download.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="settings">The settings.</param>
public void DownloadFile(System.Uri address, Cake.Core.IO.FilePath outputPath, Cake.Common.Net.DownloadFileSettings settings)
{
    Cake.Common.Net.HttpAliases.DownloadFile(Context, address, outputPath, settings);
}

/// <summary>
///            Uploads the specified file via a HTTP POST to the specified uri using multipart/form-data.
///            </summary>
/// <example>
///            <code>
///            var address = new Uri("http://www.example.org/upload");
///            UploadFile(address, @"path/to/file.txt");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="filePath">The file to upload.</param>
public void UploadFile(System.Uri address, Cake.Core.IO.FilePath filePath)
{
    Cake.Common.Net.HttpAliases.UploadFile(Context, address, filePath);
}

/// <summary>
///            Uploads the specified file via a HTTP POST to the specified uri using multipart/form-data.
///            </summary>
/// <example>
///            <code>
///            var address = "http://www.example.org/upload";
///            UploadFile(address, @"path/to/file.txt");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="filePath">The file to upload.</param>
public void UploadFile(System.String address, Cake.Core.IO.FilePath filePath)
{
    Cake.Common.Net.HttpAliases.UploadFile(Context, address, filePath);
}

/// <summary>
///            Uploads the specified byte array via a HTTP POST to the specified uri using multipart/form-data.
///            </summary>
/// <example>
///            <code>
///            var address = new Uri("http://www.example.org/upload");
///            UploadFile(address, @"path/to/file.txt");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="data">The data to upload.</param>
/// <param name="fileName">The filename to give the uploaded data</param>
public void UploadFile(System.Uri address, System.Byte[] data, System.String fileName)
{
    Cake.Common.Net.HttpAliases.UploadFile(Context, address, data, fileName);
}

/// <summary>
///            Uploads the specified byte array via a HTTP POST to the specified uri using multipart/form-data.
///            </summary>
/// <example>
///            <code>
///            var address = "http://www.example.org/upload";
///            UploadFile(address, @"path/to/file.txt");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="address">The URL of the upload resource.</param>
/// <param name="data">The data to upload.</param>
/// <param name="fileName">The filename to give the uploaded data</param>
public void UploadFile(System.String address, System.Byte[] data, System.String fileName)
{
    Cake.Common.Net.HttpAliases.UploadFile(Context, address, data, fileName);
}

/// <summary>
///             Gets a directory path from string.
///             </summary>
/// <example>
///             <code>
///             // Get the temp directory.
///             var root = Directory("./");
///             var temp = root + Directory("temp");
///            
///             // Clean the directory.
///             CleanDirectory(temp);
///             </code>
///             </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>A directory path.</returns>
public Cake.Common.IO.Paths.ConvertableDirectoryPath Directory(System.String path)
{
    return Cake.Common.IO.DirectoryAliases.Directory(Context, path);
}

/// <summary>
///            Deletes the specified directories.
///            </summary>
/// <example>
///            <code>
///            var directoriesToDelete = new DirectoryPath[]{
///                Directory("be"),
///                Directory("gone")
///            };
///            DeleteDirectories(directoriesToDelete, recursive:true);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories, System.Boolean recursive = false)
{
    Context.Log.Warning("Warning: The alias DeleteDirectories has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
    #pragma warning disable 0618
    Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, recursive);
    #pragma warning restore 0618
}

/// <summary>
///            Deletes the specified directories.
///            </summary>
/// <example>
///            <code>
///            var directoriesToDelete = new DirectoryPath[]{
///                Directory("be"),
///                Directory("gone")
///            };
///            DeleteDirectories(directoriesToDelete, new DeleteDirectorySettings {
///                Recursive = true,
///                Force = true
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories, Cake.Common.IO.DeleteDirectorySettings settings)
{
    Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, settings);
}

/// <summary>
///            Deletes the specified directories.
///            </summary>
/// <example>
///            <code>
///            var directoriesToDelete = new []{
///                "be",
///                "gone"
///            };
///            DeleteDirectories(directoriesToDelete, recursive:true);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<System.String> directories, System.Boolean recursive = false)
{
    Context.Log.Warning("Warning: The alias DeleteDirectories has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
    #pragma warning disable 0618
    Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, recursive);
    #pragma warning restore 0618
}

/// <summary>
///            Deletes the specified directories.
///            </summary>
/// <example>
///            <code>
///            var directoriesToDelete = new []{
///                "be",
///                "gone"
///            };
///            DeleteDirectories(directoriesToDelete, new DeleteDirectorySettings {
///                Recursive = true,
///                Force = true
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectories(System.Collections.Generic.IEnumerable<System.String> directories, Cake.Common.IO.DeleteDirectorySettings settings)
{
    Cake.Common.IO.DirectoryAliases.DeleteDirectories(Context, directories, settings);
}

/// <summary>
///            Deletes the specified directory.
///            </summary>
/// <example>
///            <code>
///            DeleteDirectory("./be/gone", recursive:true);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="recursive">Will perform a recursive delete if set to <c>true</c>.</param>
public void DeleteDirectory(Cake.Core.IO.DirectoryPath path, System.Boolean recursive = false)
{
    Context.Log.Warning("Warning: The alias DeleteDirectory has been made obsolete. Use the overload that accepts DeleteDirectorySettings instead.");
    #pragma warning disable 0618
    Cake.Common.IO.DirectoryAliases.DeleteDirectory(Context, path, recursive);
    #pragma warning restore 0618
}

/// <summary>
///            Deletes the specified directory.
///            </summary>
/// <example>
///            <code>
///            DeleteDirectory("./be/gone", new DeleteDirectorySettings {
///                Recursive = true,
///                Force = true
///            });
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="settings">The delete settings.</param>
public void DeleteDirectory(Cake.Core.IO.DirectoryPath path, Cake.Common.IO.DeleteDirectorySettings settings)
{
    Cake.Common.IO.DirectoryAliases.DeleteDirectory(Context, path, settings);
}

/// <summary>
///            Cleans the directories matching the specified pattern.
///            Cleaning the directory will remove all its content but not the directory itself.
///            </summary>
/// <example>
///            <code>
///            CleanDirectories("./src/**/bin/debug");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern to match.</param>
public void CleanDirectories(System.String pattern)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, pattern);
}

/// <summary>
///            Cleans the directories matching the specified pattern.
///            Cleaning the directory will remove all its content but not the directory itself.
///            </summary>
/// <example>
///            <code>
///            Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
///            fileSystemInfo=&gt;!fileSystemInfo.Path.FullPath.EndsWith(
///                            "node_modules",
///                            StringComparison.OrdinalIgnoreCase);
///            CleanDirectories("./src/**/bin/debug", exclude_node_modules);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
public void CleanDirectories(System.String pattern, System.Func<Cake.Core.IO.IFileSystemInfo, System.Boolean> predicate)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, pattern, predicate);
}

/// <summary>
///            Cleans the specified directories.
///            Cleaning a directory will remove all its content but not the directory itself.
///            </summary>
/// <example>
///            <code>
///            var directoriesToClean = GetDirectories("./src/**/bin/");
///            CleanDirectories(directoriesToClean);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
public void CleanDirectories(System.Collections.Generic.IEnumerable<Cake.Core.IO.DirectoryPath> directories)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, directories);
}

/// <summary>
///            Cleans the specified directories.
///            Cleaning a directory will remove all its content but not the directory itself.
///            </summary>
/// <example>
///            <code>
///            var directoriesToClean = new []{
///                "./src/Cake/obj",
///                "./src/Cake.Common/obj"
///            };
///            CleanDirectories(directoriesToClean);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directories">The directory paths.</param>
public void CleanDirectories(System.Collections.Generic.IEnumerable<System.String> directories)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectories(Context, directories);
}

/// <summary>
///            Cleans the specified directory.
///            </summary>
/// <example>
///            <code>
///            CleanDirectory("./src/Cake.Common/obj");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void CleanDirectory(Cake.Core.IO.DirectoryPath path)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectory(Context, path);
}

/// <summary>
///            Cleans the specified directory.
///            </summary>
/// <example>
///            <code>
///            CleanDirectory("./src/Cake.Common/obj", fileSystemInfo=&gt;!fileSystemInfo.Hidden);
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
/// <param name="predicate">Predicate used to determine which files/directories should get deleted.</param>
public void CleanDirectory(Cake.Core.IO.DirectoryPath path, System.Func<Cake.Core.IO.IFileSystemInfo, System.Boolean> predicate)
{
    Cake.Common.IO.DirectoryAliases.CleanDirectory(Context, path, predicate);
}

/// <summary>
///            Creates the specified directory.
///            </summary>
/// <example>
///            <code>
///            CreateDirectory("publish");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void CreateDirectory(Cake.Core.IO.DirectoryPath path)
{
    Cake.Common.IO.DirectoryAliases.CreateDirectory(Context, path);
}

/// <summary>
///            Creates the specified directory if it does not exist.
///            </summary>
/// <example>
///            <code>
///            EnsureDirectoryExists("publish");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The directory path.</param>
public void EnsureDirectoryExists(Cake.Core.IO.DirectoryPath path)
{
    Cake.Common.IO.DirectoryAliases.EnsureDirectoryExists(Context, path);
}

/// <summary>
///            Copies the contents of a directory, including subdirectories to the specified location.
///            </summary>
/// <example>
///            <code>
///            CopyDirectory("source_path", "destination_path");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="source">The source directory path.</param>
/// <param name="destination">The destination directory path.</param>
public void CopyDirectory(Cake.Core.IO.DirectoryPath source, Cake.Core.IO.DirectoryPath destination)
{
    Cake.Common.IO.DirectoryAliases.CopyDirectory(Context, source, destination);
}

/// <summary>
///            Determines whether the given path refers to an existing directory.
///            </summary>
/// <example>
///            <code>
///            var dir = "publish";
///            if (!DirectoryExists(dir))
///            {
///                CreateDirectory(dir);
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The <see cref="T:Cake.Core.IO.DirectoryPath" /> to check.</param>
/// <returns>
///  <c>true</c> if <paramref name="path" /> refers to an existing directory;
///            <c>false</c> if the directory does not exist or an error occurs when trying to
///            determine if the specified path exists.</returns>
public System.Boolean DirectoryExists(Cake.Core.IO.DirectoryPath path)
{
    return Cake.Common.IO.DirectoryAliases.DirectoryExists(Context, path);
}

/// <summary>
///            Makes the path absolute (if relative) using the current working directory.
///            </summary>
/// <example>
///            <code>
///            var path = MakeAbsolute(Directory("./resources"));
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>An absolute directory path.</returns>
public Cake.Core.IO.DirectoryPath MakeAbsolute(Cake.Core.IO.DirectoryPath path)
{
    return Cake.Common.IO.DirectoryAliases.MakeAbsolute(Context, path);
}

/// <summary>
///            Moves an existing directory to a new location, providing the option to specify a new directory name.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            MoveDirectory("mydir", "newparent/newdir");
///            </code>
///            </example>
public void MoveDirectory(Cake.Core.IO.DirectoryPath directoryPath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.DirectoryAliases.MoveDirectory(Context, directoryPath, targetDirectoryPath);
}

/// <summary>
///            Gets a list of all the directories inside a directory.
///            </summary>
/// <example>
///            <code>
///            var directories = GetSubDirectories("some/dir");
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="directoryPath">The directory path.</param>
/// <returns>An absolute directory path.</returns>
public Cake.Core.IO.DirectoryPathCollection GetSubDirectories(Cake.Core.IO.DirectoryPath directoryPath)
{
    return Cake.Common.IO.DirectoryAliases.GetSubDirectories(Context, directoryPath);
}

/// <summary>
///             Gets a file path from string.
///             </summary>
/// <example>
///             <code>
///             // Get the temp file.
///             var root = Directory("./");
///             var temp = root + File("temp");
///            
///             // Delete the file.
///             CleanDirectory(temp);
///             </code>
///             </example>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>A file path.</returns>
public Cake.Common.IO.Paths.ConvertableFilePath File(System.String path)
{
    return Cake.Common.IO.FileAliases.File(Context, path);
}

/// <summary>
///            Copies an existing file to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            CopyFileToDirectory("test.txt", "./targetdir");
///            </code>
///            </example>
public void CopyFileToDirectory(Cake.Core.IO.FilePath filePath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.CopyFileToDirectory(Context, filePath, targetDirectoryPath);
}

/// <summary>
///            Copies an existing file to a new file, providing the option to specify a new file name.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetFilePath">The target file path.</param>
/// <example>
///            <code>
///            CopyFile("test.tmp", "test.txt");
///            </code>
///            </example>
public void CopyFile(Cake.Core.IO.FilePath filePath, Cake.Core.IO.FilePath targetFilePath)
{
    Cake.Common.IO.FileAliases.CopyFile(Context, filePath, targetFilePath);
}

/// <summary>
///            Copies all files matching the provided pattern to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            CopyFiles("Cake.*", "./publish");
///            </code>
///            </example>
public void CopyFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, pattern, targetDirectoryPath);
}

/// <summary>
///            Copies existing files to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            var files = GetFiles("./**/Cake.*");
///            CopyFiles(files, "destination");
///            </code>
///            </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath);
}

/// <summary>
///            Copies existing files to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            CreateDirectory("destination");
///            var files = new [] {
///                "Cake.exe",
///                "Cake.pdb"
///            };
///            CopyFiles(files, "destination");
///            </code>
///            </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<System.String> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath);
}

/// <summary>
///            Copies all files matching the provided pattern to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
///            <code>
///            CopyFiles("Cake.*", "./publish");
///            </code>
///            </example>
public void CopyFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, pattern, targetDirectoryPath, preserveFolderStructure);
}

/// <summary>
///            Copies existing files to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
///            <code>
///            var files = GetFiles("./**/Cake.*");
///            CopyFiles(files, "destination");
///            </code>
///            </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath, preserveFolderStructure);
}

/// <summary>
///            Copies existing files to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <param name="preserveFolderStructure">Keep the folder structure.</param>
/// <example>
///            <code>
///            CreateDirectory("destination");
///            var files = new [] {
///                "Cake.exe",
///                "Cake.pdb"
///            };
///            CopyFiles(files, "destination");
///            </code>
///            </example>
public void CopyFiles(System.Collections.Generic.IEnumerable<System.String> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath, System.Boolean preserveFolderStructure)
{
    Cake.Common.IO.FileAliases.CopyFiles(Context, filePaths, targetDirectoryPath, preserveFolderStructure);
}

/// <summary>
///            Moves an existing file to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            MoveFileToDirectory("test.txt", "./targetdir");
///            </code>
///            </example>
public void MoveFileToDirectory(Cake.Core.IO.FilePath filePath, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.MoveFileToDirectory(Context, filePath, targetDirectoryPath);
}

/// <summary>
///            Moves existing files matching the specified pattern to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            MoveFiles("./publish/Cake.*", "./destination");
///            </code>
///            </example>
public void MoveFiles(System.String pattern, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.MoveFiles(Context, pattern, targetDirectoryPath);
}

/// <summary>
///            Moves existing files to a new location.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <param name="targetDirectoryPath">The target directory path.</param>
/// <example>
///            <code>
///            var files = GetFiles("./publish/Cake.*");
///            MoveFiles(files, "destination");
///            </code>
///            </example>
public void MoveFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths, Cake.Core.IO.DirectoryPath targetDirectoryPath)
{
    Cake.Common.IO.FileAliases.MoveFiles(Context, filePaths, targetDirectoryPath);
}

/// <summary>
///            Moves an existing file to a new location, providing the option to specify a new file name.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <param name="targetFilePath">The target file path.</param>
/// <example>
///            <code>
///            MoveFile("test.tmp", "test.txt");
///            </code>
///            </example>
public void MoveFile(Cake.Core.IO.FilePath filePath, Cake.Core.IO.FilePath targetFilePath)
{
    Cake.Common.IO.FileAliases.MoveFile(Context, filePath, targetFilePath);
}

/// <summary>
///            Deletes the specified files.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            DeleteFiles("./publish/Cake.*");
///            </code>
///            </example>
public void DeleteFiles(System.String pattern)
{
    Cake.Common.IO.FileAliases.DeleteFiles(Context, pattern);
}

/// <summary>
///            Deletes the specified files.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
///            <code>
///            var files = GetFiles("./destination/Cake.*");
///            DeleteFiles(files);
///            </code>
///            </example>
public void DeleteFiles(System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths)
{
    Cake.Common.IO.FileAliases.DeleteFiles(Context, filePaths);
}

/// <summary>
///            Deletes the specified file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The file path.</param>
/// <example>
///            <code>
///            DeleteFile("deleteme.txt");
///            </code>
///            </example>
public void DeleteFile(Cake.Core.IO.FilePath filePath)
{
    Cake.Common.IO.FileAliases.DeleteFile(Context, filePath);
}

/// <summary>
///            Determines whether the given path refers to an existing file.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The <see cref="T:Cake.Core.IO.FilePath" /> to check.</param>
/// <returns>
///  <c>true</c> if <paramref name="filePath" /> refers to an existing file;
///            <c>false</c> if the file does not exist or an error occurs when trying to
///            determine if the specified file exists.</returns>
/// <example>
///            <code>
///            if (FileExists("findme.txt"))
///            {
///                Information("File exists!");
///            }
///            </code>
///            </example>
public System.Boolean FileExists(Cake.Core.IO.FilePath filePath)
{
    return Cake.Common.IO.FileAliases.FileExists(Context, filePath);
}

/// <summary>
///            Makes the path absolute (if relative) using the current working directory.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="path">The path.</param>
/// <returns>An absolute file path.</returns>
/// <example>
///            <code>
///            var path = MakeAbsolute(File("./resources"));
///            </code>
///            </example>
public Cake.Core.IO.FilePath MakeAbsolute(Cake.Core.IO.FilePath path)
{
    return Cake.Common.IO.FileAliases.MakeAbsolute(Context, path);
}

/// <summary>
///            Gets the size of a file in bytes.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="filePath">The path.</param>
/// <returns>Size of file in bytes or -1 if file doesn't exist.</returns>
/// <example>
///            <code>
///            Information("File size: {0}", FileSize("./build.cake"));
///            </code>
///            </example>
public System.Int64 FileSize(Cake.Core.IO.FilePath filePath)
{
    return Cake.Common.IO.FileAliases.FileSize(Context, filePath);
}

/// <summary>
///            Gets all files matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            var files = GetFiles("./**/Cake.*.dll");
///            foreach(var file in files)
///            {
///                Information("File: {0}", file);
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <returns>A <see cref="T:Cake.Core.IO.FilePathCollection" />.</returns>
public Cake.Core.IO.FilePathCollection GetFiles(System.String pattern)
{
    return Cake.Common.IO.GlobbingAliases.GetFiles(Context, pattern);
}

/// <summary>
///             Gets all files matching the specified pattern.
///             </summary>
/// <example>
///             <code>
///             Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
///                 fileSystemInfo =&gt; !fileSystemInfo.Path.FullPath.EndsWith(
///                     "node_modules", StringComparison.OrdinalIgnoreCase);
///            
///             var files = GetFiles("./**/Cake.*.dll", exclude_node_modules);
///             foreach(var file in files)
///             {
///                 Information("File: {0}", file);
///             }
///             </code>
///             </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
/// <returns>A <see cref="T:Cake.Core.IO.FilePathCollection" />.</returns>
public Cake.Core.IO.FilePathCollection GetFiles(System.String pattern, System.Func<Cake.Core.IO.IDirectory, System.Boolean> predicate)
{
    return Cake.Common.IO.GlobbingAliases.GetFiles(Context, pattern, predicate);
}

/// <summary>
///            Gets all directory matching the specified pattern.
///            </summary>
/// <example>
///            <code>
///            var directories = GetDirectories("./src/**/obj/*");
///            foreach(var directory in directories)
///            {
///                Information("Directory: {0}", directory);
///            }
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <returns>A <see cref="T:Cake.Core.IO.DirectoryPathCollection" />.</returns>
public Cake.Core.IO.DirectoryPathCollection GetDirectories(System.String pattern)
{
    return Cake.Common.IO.GlobbingAliases.GetDirectories(Context, pattern);
}

/// <summary>
///             Gets all directory matching the specified pattern.
///             </summary>
/// <example>
///             <code>
///             Func&lt;IFileSystemInfo, bool&gt; exclude_node_modules =
///                 fileSystemInfo =&gt; !fileSystemInfo.Path.FullPath.EndsWith(
///                     "node_modules", StringComparison.OrdinalIgnoreCase);
///            
///             var directories = GetDirectories("./src/**/obj/*", exclude_node_modules);
///             foreach(var directory in directories)
///             {
///                 Information("Directory: {0}", directory);
///             }
///             </code>
///             </example>
/// <param name="context">The context.</param>
/// <param name="pattern">The glob pattern to match.</param>
/// <param name="predicate">The predicate used to filter directories based on file system information.</param>
/// <returns>A <see cref="T:Cake.Core.IO.DirectoryPathCollection" />.</returns>
public Cake.Core.IO.DirectoryPathCollection GetDirectories(System.String pattern, System.Func<Cake.Core.IO.IDirectory, System.Boolean> predicate)
{
    return Cake.Common.IO.GlobbingAliases.GetDirectories(Context, pattern, predicate);
}

/// <summary>
///            Zips the specified directory.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <example>
///            <code>
///            Zip("./publish", "publish.zip");
///            </code>
///            </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath)
{
    Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath);
}

/// <summary>
///            Zips the files matching the specified pattern.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="pattern">The pattern.</param>
/// <example>
///            <code>
///            Zip("./", "xmlfiles.zip", "./*.xml");
///            </code>
///            </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.String pattern)
{
    Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, pattern);
}

/// <summary>
///            Zips the specified files.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
///            <code>
///            var files = GetFiles("./**/Cake.*.dll");
///            Zip("./", "cakeassemblies.zip", files);
///            </code>
///            </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.Collections.Generic.IEnumerable<Cake.Core.IO.FilePath> filePaths)
{
    Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, filePaths);
}

/// <summary>
///            Zips the specified files.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="rootPath">The root path.</param>
/// <param name="outputPath">The output path.</param>
/// <param name="filePaths">The file paths.</param>
/// <example>
///            <code>
///            var files = new [] {
///                "./src/Cake/bin/Debug/Autofac.dll",
///                "./src/Cake/bin/Debug/Cake.Common.dll",
///                "./src/Cake/bin/Debug/Cake.Core.dll",
///                "./src/Cake/bin/Debug/Cake.exe"
///            };
///            Zip("./", "cakebinaries.zip", files);
///            </code>
///            </example>
public void Zip(Cake.Core.IO.DirectoryPath rootPath, Cake.Core.IO.FilePath outputPath, System.Collections.Generic.IEnumerable<System.String> filePaths)
{
    Cake.Common.IO.ZipAliases.Zip(Context, rootPath, outputPath, filePaths);
}

/// <summary>
///            Unzips the specified file
///            </summary>
/// <param name="context">The context.</param>
/// <param name="zipFile">Zip file to unzip.</param>
/// <param name="outputPath">Output path to unzip into.</param>
/// <example>
///            <code>
///            Unzip("Cake.zip", "./cake");
///            </code>
///            </example>
public void Unzip(Cake.Core.IO.FilePath zipFile, Cake.Core.IO.DirectoryPath outputPath)
{
    Cake.Common.IO.ZipAliases.Unzip(Context, zipFile, outputPath);
}

/// <summary>
///            Writes an error message to the log using the specified format information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
///            <code>
///            Error("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
///            </code>
///            </example>
public void Error(System.String format, params System.Object[] args)
{
    Cake.Common.Diagnostics.LoggingAliases.Error(Context, format, args);
}

/// <summary>
///            Writes an error message to the log using the specified log message action.
///            Evaluation message only if verbosity same or more verbose.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
///            <code>
///            Error(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
///            </code>
///            </example>
public void Error(Cake.Core.Diagnostics.LogAction logAction)
{
    Cake.Common.Diagnostics.LoggingAliases.Error(Context, logAction);
}

/// <summary>
///            Writes an error message to the log using the specified value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Error(new {FirstName = "John", LastName="Doe"});
///            </code>
///            </example>
public void Error(System.Object value)
{
    Cake.Common.Diagnostics.LoggingAliases.Error(Context, value);
}

/// <summary>
///            Writes an error message to the log using the specified string value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Error("{string}");
///            </code>
///            </example>
public void Error(System.String value)
{
    Cake.Common.Diagnostics.LoggingAliases.Error(Context, value);
}

/// <summary>
///            Writes a warning message to the log using the specified format information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
///            <code>
///            Warning("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
///            </code>
///            </example>
public void Warning(System.String format, params System.Object[] args)
{
    Cake.Common.Diagnostics.LoggingAliases.Warning(Context, format, args);
}

/// <summary>
///            Writes a warning message to the log using the specified log message action.
///            Evaluation message only if verbosity same or more verbose.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
///            <code>
///            Warning(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
///            </code>
///            </example>
public void Warning(Cake.Core.Diagnostics.LogAction logAction)
{
    Cake.Common.Diagnostics.LoggingAliases.Warning(Context, logAction);
}

/// <summary>
///            Writes an warning message to the log using the specified value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Warning(new {FirstName = "John", LastName="Doe"});
///            </code>
///            </example>
public void Warning(System.Object value)
{
    Cake.Common.Diagnostics.LoggingAliases.Warning(Context, value);
}

/// <summary>
///            Writes an warning message to the log using the specified string value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Warning("{string}");
///            </code>
///            </example>
public void Warning(System.String value)
{
    Cake.Common.Diagnostics.LoggingAliases.Warning(Context, value);
}

/// <summary>
///            Writes an informational message to the log using the specified format information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
///            <code>
///            Information("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
///            </code>
///            </example>
public void Information(System.String format, params System.Object[] args)
{
    Cake.Common.Diagnostics.LoggingAliases.Information(Context, format, args);
}

/// <summary>
///            Writes an informational message to the log using the specified log message action.
///            Evaluation message only if verbosity same or more verbose.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
///            <code>
///            Information(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
///            </code>
///            </example>
public void Information(Cake.Core.Diagnostics.LogAction logAction)
{
    Cake.Common.Diagnostics.LoggingAliases.Information(Context, logAction);
}

/// <summary>
///            Writes an informational message to the log using the specified value.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Information(new {FirstName = "John", LastName="Doe"});
///            </code>
///            </example>
public void Information(System.Object value)
{
    Cake.Common.Diagnostics.LoggingAliases.Information(Context, value);
}

/// <summary>
///            Writes an informational message to the log using the specified string value.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Information("{string}");
///            </code>
///            </example>
public void Information(System.String value)
{
    Cake.Common.Diagnostics.LoggingAliases.Information(Context, value);
}

/// <summary>
///            Writes a verbose message to the log using the specified format information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
///            <code>
///            Verbose("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
///            </code>
///            </example>
public void Verbose(System.String format, params System.Object[] args)
{
    Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, format, args);
}

/// <summary>
///            Writes a verbose message to the log using the specified log message action.
///            Evaluation message only if verbosity same or more verbose.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
///            <code>
///            Verbose(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
///            </code>
///            </example>
public void Verbose(Cake.Core.Diagnostics.LogAction logAction)
{
    Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, logAction);
}

/// <summary>
///            Writes a verbose message to the log using the specified value.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Verbose(new {FirstName = "John", LastName="Doe"});
///            </code>
///            </example>
public void Verbose(System.Object value)
{
    Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, value);
}

/// <summary>
///            Writes a verbose message to the log using the specified string value.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Verbose("{string}");
///            </code>
///            </example>
public void Verbose(System.String value)
{
    Cake.Common.Diagnostics.LoggingAliases.Verbose(Context, value);
}

/// <summary>
///            Writes a debug message to the log using the specified format information.
///            </summary>
/// <param name="context">The context.</param>
/// <param name="format">The format.</param>
/// <param name="args">The arguments.</param>
/// <example>
///            <code>
///            Debug("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now);
///            </code>
///            </example>
public void Debug(System.String format, params System.Object[] args)
{
    Cake.Common.Diagnostics.LoggingAliases.Debug(Context, format, args);
}

/// <summary>
///            Writes a debug message to the log using the specified log message action.
///            Evaluation message only if verbosity same or more verbose.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="logAction">The function called for message when logging.</param>
/// <example>
///            <code>
///            Debug(logAction=&gt;logAction("Hello {0}! Today is an {1:dddd}", "World", DateTime.Now));
///            </code>
///            </example>
public void Debug(Cake.Core.Diagnostics.LogAction logAction)
{
    Cake.Common.Diagnostics.LoggingAliases.Debug(Context, logAction);
}

/// <summary>
///            Writes a debug message to the log using the specified value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Debug(new {FirstName = "John", LastName="Doe"});
///            </code>
///            </example>
public void Debug(System.Object value)
{
    Cake.Common.Diagnostics.LoggingAliases.Debug(Context, value);
}

/// <summary>
///            Writes a debug message to the log using the specified string value.
///            </summary>
/// <param name="context">the context.</param>
/// <param name="value">The value.</param>
/// <example>
///            <code>
///            Debug("{string}");
///            </code>
///            </example>
public void Debug(System.String value)
{
    Cake.Common.Diagnostics.LoggingAliases.Debug(Context, value);
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.BuildSystem" /> instance that can
///            be used to query for information about the current build system.
///            </summary>
/// <example>
///            <code>
///            var isLocal = BuildSystem.IsLocalBuild;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="T:Cake.Common.Build.BuildSystem" /> instance.</returns>
private Cake.Common.Build.BuildSystem _BuildSystem;
public Cake.Common.Build.BuildSystem BuildSystem
{
    get
    {
        if (_BuildSystem==null)
        {
            _BuildSystem = Cake.Common.Build.BuildSystemAliases.BuildSystem(Context);
        }
        return _BuildSystem;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.AppVeyor.AppVeyorProvider" /> instance that can
///            be used to manipulate the AppVeyor environment.
///            </summary>
/// <example>
///            <code>
///            var isAppVeyorBuild = AppVeyor.IsRunningOnAppVeyor;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.AppVeyor" /> instance.</returns>
private Cake.Common.Build.AppVeyor.IAppVeyorProvider _AppVeyor;
public Cake.Common.Build.AppVeyor.IAppVeyorProvider AppVeyor
{
    get
    {
        if (_AppVeyor==null)
        {
            _AppVeyor = Cake.Common.Build.BuildSystemAliases.AppVeyor(Context);
        }
        return _AppVeyor;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.TeamCity.TeamCityProvider" /> instance that can
///            be used to manipulate the TeamCity environment.
///            </summary>
/// <example>
///            <code>
///            var isTeamCityBuild = TeamCity.IsRunningOnTeamCity;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TeamCity" /> instance.</returns>
private Cake.Common.Build.TeamCity.ITeamCityProvider _TeamCity;
public Cake.Common.Build.TeamCity.ITeamCityProvider TeamCity
{
    get
    {
        if (_TeamCity==null)
        {
            _TeamCity = Cake.Common.Build.BuildSystemAliases.TeamCity(Context);
        }
        return _TeamCity;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.MyGet.MyGetProvider" /> instance that can
///            be used to manipulate the MyGet environment.
///            </summary>
/// <example>
///            <code>
///            var isMyGetBuild = MyGet.IsRunningOnMyGet;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.MyGet" /> instance.</returns>
private Cake.Common.Build.MyGet.IMyGetProvider _MyGet;
public Cake.Common.Build.MyGet.IMyGetProvider MyGet
{
    get
    {
        if (_MyGet==null)
        {
            _MyGet = Cake.Common.Build.BuildSystemAliases.MyGet(Context);
        }
        return _MyGet;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.Bamboo.BambooProvider" /> instance that can
///            be used to manipulate the Bamboo environment.
///            </summary>
/// <example>
///            <code>
///            var isBambooBuild = Bamboo.IsRunningOnBamboo;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Bamboo" /> instance.</returns>
private Cake.Common.Build.Bamboo.IBambooProvider _Bamboo;
public Cake.Common.Build.Bamboo.IBambooProvider Bamboo
{
    get
    {
        if (_Bamboo==null)
        {
            _Bamboo = Cake.Common.Build.BuildSystemAliases.Bamboo(Context);
        }
        return _Bamboo;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.ContinuaCI.ContinuaCIProvider" /> instance that can
///            be used to manipulate the Continua CI environment.
///            </summary>
/// <example>
///            <code>
///            var isContinuaCIBuild = ContinuaCI.IsRunningContinuaCI;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.ContinuaCI" /> instance.</returns>
private Cake.Common.Build.ContinuaCI.IContinuaCIProvider _ContinuaCI;
public Cake.Common.Build.ContinuaCI.IContinuaCIProvider ContinuaCI
{
    get
    {
        if (_ContinuaCI==null)
        {
            _ContinuaCI = Cake.Common.Build.BuildSystemAliases.ContinuaCI(Context);
        }
        return _ContinuaCI;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.Jenkins.JenkinsProvider" /> instance that can be used to
///            obtain information from the Jenkins environment.
///            </summary>
/// <example>
///            <code>
///            var isJenkinsBuild = Jenkins.IsRunningOnJenkins;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Jenkins" /> instance.</returns>
private Cake.Common.Build.Jenkins.IJenkinsProvider _Jenkins;
public Cake.Common.Build.Jenkins.IJenkinsProvider Jenkins
{
    get
    {
        if (_Jenkins==null)
        {
            _Jenkins = Cake.Common.Build.BuildSystemAliases.Jenkins(Context);
        }
        return _Jenkins;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.Bitrise.BitriseProvider" /> instance that can be used to
///            obtain information from the Bitrise environment.
///            </summary>
/// <example>
///            <code>
///            var isBitriseBuild = Bitrise.IsRunningOnBitrise;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.Bitrise" /> instance.</returns>
private Cake.Common.Build.Bitrise.IBitriseProvider _Bitrise;
public Cake.Common.Build.Bitrise.IBitriseProvider Bitrise
{
    get
    {
        if (_Bitrise==null)
        {
            _Bitrise = Cake.Common.Build.BuildSystemAliases.Bitrise(Context);
        }
        return _Bitrise;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.TravisCI.TravisCIProvider" /> instance that can be used to
///            obtain information from the Travis CI environment.
///            </summary>
/// <example>
///            <code>
///            var isTravisCIBuild = TravisCI.IsRunningOnTravisCI;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TravisCI" /> instance.</returns>
private Cake.Common.Build.TravisCI.ITravisCIProvider _TravisCI;
public Cake.Common.Build.TravisCI.ITravisCIProvider TravisCI
{
    get
    {
        if (_TravisCI==null)
        {
            _TravisCI = Cake.Common.Build.BuildSystemAliases.TravisCI(Context);
        }
        return _TravisCI;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.BitbucketPipelines.BitbucketPipelinesProvider" /> instance that can be used to
///            obtain information from the Bitbucket Pipelines environment.
///            </summary>
/// <example>
///            <code>
///            var isBitbucketPipelinesBuild = BitbucketPipelines.IsRunningOnBitbucketPipelines;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.BitbucketPipelines" /> instance.</returns>
private Cake.Common.Build.BitbucketPipelines.IBitbucketPipelinesProvider _BitbucketPipelines;
public Cake.Common.Build.BitbucketPipelines.IBitbucketPipelinesProvider BitbucketPipelines
{
    get
    {
        if (_BitbucketPipelines==null)
        {
            _BitbucketPipelines = Cake.Common.Build.BuildSystemAliases.BitbucketPipelines(Context);
        }
        return _BitbucketPipelines;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.GoCD.GoCDProvider" /> instance that can be used to
///            obtain information from the Go.CD environment.
///            </summary>
/// <example>
///            <code>
///            var isGoCDBuild = GoCD.IsRunningOnGoCD;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.GoCD" /> instance.</returns>
private Cake.Common.Build.GoCD.IGoCDProvider _GoCD;
public Cake.Common.Build.GoCD.IGoCDProvider GoCD
{
    get
    {
        if (_GoCD==null)
        {
            _GoCD = Cake.Common.Build.BuildSystemAliases.GoCD(Context);
        }
        return _GoCD;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.GitLabCI.GitLabCIProvider" /> instance that can be used to
///            obtain information from the GitLab CI environment.
///            </summary>
/// <example>
///            <code>
///            var isGitLabCIBuild = GitLabCI.IsRunningOnGitLabCI;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.GitLabCI" /> instance.</returns>
private Cake.Common.Build.GitLabCI.IGitLabCIProvider _GitLabCI;
public Cake.Common.Build.GitLabCI.IGitLabCIProvider GitLabCI
{
    get
    {
        if (_GitLabCI==null)
        {
            _GitLabCI = Cake.Common.Build.BuildSystemAliases.GitLabCI(Context);
        }
        return _GitLabCI;
    }
}

/// <summary>
///            Gets a <see cref="T:Cake.Common.Build.TFBuild.TFBuildProvider" /> instance that can be used to
///            obtain information from the Team Foundation Build environment.
///            </summary>
/// <example>
///            <code>
///            var isTFSBuild = TFBuild.IsRunningOnTFS;
///            </code>
///            </example>
/// <param name="context">The context.</param>
/// <returns>A <see cref="N:Cake.Common.Build.TFBuild" /> instance.</returns>
private Cake.Common.Build.TFBuild.ITFBuildProvider _TFBuild;
public Cake.Common.Build.TFBuild.ITFBuildProvider TFBuild
{
    get
    {
        if (_TFBuild==null)
        {
            _TFBuild = Cake.Common.Build.BuildSystemAliases.TFBuild(Context);
        }
        return _TFBuild;
    }
}

#line 1 "C:/Work/single.cake"
public class Foo
{
    public static Foo Create()
    {
        return new Foo();
    }

    public void Bar()
    {
        return;
    }
}
