Import files from BootstrapperCore repo.

26 files changed, 5377 insertions, 0 deletions

diff --git a/src/WixToolset.Mba.Core/BaseBootstrapperApplicationFactory.cs b/src/WixToolset.Mba.Core/BaseBootstrapperApplicationFactory.cs
new file mode 100644
index 00000000..e9b60929
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BaseBootstrapperApplicationFactory.cs
@@ -0,0 +1,16 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    public abstract class BaseBootstrapperApplicationFactory : IBootstrapperApplicationFactory
+    {
+        public IBootstrapperApplication Create(IBootstrapperEngine pEngine, ref Command command)
+        {
+            IEngine engine = new Engine(pEngine);
+            IBootstrapperCommand bootstrapperCommand = command.GetBootstrapperCommand();
+            return this.Create(engine, bootstrapperCommand);
+        }
+
+        protected abstract IBootstrapperApplication Create(IEngine engine, IBootstrapperCommand bootstrapperCommand);
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperApplication.cs b/src/WixToolset.Mba.Core/BootstrapperApplication.cs
new file mode 100644
index 00000000..c08a60c7
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperApplication.cs
@@ -0,0 +1,1591 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using System.Threading;
+
+    /// <summary>
+    /// The default bootstrapper application.
+    /// </summary>
+    [ClassInterface(ClassInterfaceType.None)]
+    public abstract class BootstrapperApplication : MarshalByRefObject, IDefaultBootstrapperApplication
+    {
+        /// <summary>
+        /// Specifies whether this bootstrapper should run asynchronously. The default is true.
+        /// </summary>
+        protected readonly bool asyncExecution;
+
+        /// <summary>
+        /// Gets the <see cref="IEngine"/> for interaction with the engine.
+        /// </summary>
+        protected readonly IEngine engine;
+
+        private bool applying;
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="BootstrapperApplication"/> class.
+        /// </summary>
+        protected BootstrapperApplication(IEngine engine)
+        {
+            this.engine = engine;
+            this.applying = false;
+            this.asyncExecution = true;
+        }
+
+        /// <summary>
+        /// Fired when the engine is starting up the bootstrapper application.
+        /// </summary>
+        public event EventHandler<StartupEventArgs> Startup;
+
+        /// <summary>
+        /// Fired when the engine is shutting down the bootstrapper application.
+        /// </summary>
+        public event EventHandler<ShutdownEventArgs> Shutdown;
+
+        /// <summary>
+        /// Fired when the system is shutting down or user is logging off.
+        /// </summary>
+        /// <remarks>
+        /// <para>To prevent shutting down or logging off, set <see cref="CancellableHResultEventArgs.Cancel"/> to
+        /// true; otherwise, set it to false.</para>
+        /// <para>By default setup will prevent shutting down or logging off between
+        /// <see cref="BootstrapperApplication.ApplyBegin"/> and <see cref="BootstrapperApplication.ApplyComplete"/>.
+        /// Derivatives can change this behavior by overriding <see cref="BootstrapperApplication.OnSystemShutdown"/>
+        /// or handling <see cref="BootstrapperApplication.SystemShutdown"/>.</para>
+        /// <para>If <see cref="SystemShutdownEventArgs.Reasons"/> contains <see cref="EndSessionReasons.Critical"/>
+        /// the bootstrapper cannot prevent the shutdown and only has a few seconds to save state or perform any other
+        /// critical operations before being closed by the operating system.</para>
+        /// <para>This event may be fired on a different thread.</para>
+        /// </remarks>
+        public event EventHandler<SystemShutdownEventArgs> SystemShutdown;
+
+        /// <summary>
+        /// Fired when the overall detection phase has begun.
+        /// </summary>
+        public event EventHandler<DetectBeginEventArgs> DetectBegin;
+
+        /// <summary>
+        /// Fired when a forward compatible bundle is detected.
+        /// </summary>
+        public event EventHandler<DetectForwardCompatibleBundleEventArgs> DetectForwardCompatibleBundle;
+
+        /// <summary>
+        /// Fired when the update detection phase has begun.
+        /// </summary>
+        public event EventHandler<DetectUpdateBeginEventArgs> DetectUpdateBegin;
+
+        /// <summary>
+        /// Fired when the update detection has found a potential update candidate.
+        /// </summary>
+        public event EventHandler<DetectUpdateEventArgs> DetectUpdate;
+
+        /// <summary>
+        /// Fired when the update detection phase has completed.
+        /// </summary>
+        public event EventHandler<DetectUpdateCompleteEventArgs> DetectUpdateComplete;
+
+        /// <summary>
+        /// Fired when a related bundle has been detected for a bundle.
+        /// </summary>
+        public event EventHandler<DetectRelatedBundleEventArgs> DetectRelatedBundle;
+
+        /// <summary>
+        /// Fired when the detection for a specific package has begun.
+        /// </summary>
+        public event EventHandler<DetectPackageBeginEventArgs> DetectPackageBegin;
+
+        /// <summary>
+        /// Fired when a package was not detected but a package using the same provider key was.
+        /// </summary>
+        public event EventHandler<DetectCompatibleMsiPackageEventArgs> DetectCompatibleMsiPackage;
+
+        /// <summary>
+        /// Fired when a related MSI package has been detected for a package.
+        /// </summary>
+        public event EventHandler<DetectRelatedMsiPackageEventArgs> DetectRelatedMsiPackage;
+
+        /// <summary>
+        /// Fired when an MSP package detects a target MSI has been detected.
+        /// </summary>
+        public event EventHandler<DetectTargetMsiPackageEventArgs> DetectTargetMsiPackage;
+
+        /// <summary>
+        /// Fired when a feature in an MSI package has been detected.
+        /// </summary>
+        public event EventHandler<DetectMsiFeatureEventArgs> DetectMsiFeature;
+
+        /// <summary>
+        /// Fired when the detection for a specific package has completed.
+        /// </summary>
+        public event EventHandler<DetectPackageCompleteEventArgs> DetectPackageComplete;
+
+        /// <summary>
+        /// Fired when the detection phase has completed.
+        /// </summary>
+        public event EventHandler<DetectCompleteEventArgs> DetectComplete;
+
+        /// <summary>
+        /// Fired when the engine has begun planning the installation.
+        /// </summary>
+        public event EventHandler<PlanBeginEventArgs> PlanBegin;
+
+        /// <summary>
+        /// Fired when the engine has begun planning for a related bundle.
+        /// </summary>
+        public event EventHandler<PlanRelatedBundleEventArgs> PlanRelatedBundle;
+
+        /// <summary>
+        /// Fired when the engine has begun planning the installation of a specific package.
+        /// </summary>
+        public event EventHandler<PlanPackageBeginEventArgs> PlanPackageBegin;
+
+        /// <summary>
+        /// Fired when the engine plans a new, compatible package using the same provider key.
+        /// </summary>
+        public event EventHandler<PlanCompatibleMsiPackageBeginEventArgs> PlanCompatibleMsiPackageBegin;
+
+        /// <summary>
+        /// Fired when the engine has completed planning the installation of a specific package.
+        /// </summary>
+        public event EventHandler<PlanCompatibleMsiPackageCompleteEventArgs> PlanCompatibleMsiPackageComplete;
+
+        /// <summary>
+        /// Fired when the engine is about to plan the target MSI of a MSP package.
+        /// </summary>
+        public event EventHandler<PlanTargetMsiPackageEventArgs> PlanTargetMsiPackage;
+
+        /// <summary>
+        /// Fired when the engine is about to plan a feature in an MSI package.
+        /// </summary>
+        public event EventHandler<PlanMsiFeatureEventArgs> PlanMsiFeature;
+
+        /// <summary>
+        /// Fired when the engine has completed planning the installation of a specific package.
+        /// </summary>
+        public event EventHandler<PlanPackageCompleteEventArgs> PlanPackageComplete;
+
+        /// <summary>
+        /// Fired when the engine has completed planning the installation.
+        /// </summary>
+        public event EventHandler<PlanCompleteEventArgs> PlanComplete;
+
+        /// <summary>
+        /// Fired when the engine has begun installing the bundle.
+        /// </summary>
+        public event EventHandler<ApplyBeginEventArgs> ApplyBegin;
+
+        /// <summary>
+        /// Fired when the engine is about to start the elevated process.
+        /// </summary>
+        public event EventHandler<ElevateBeginEventArgs> ElevateBegin;
+
+        /// <summary>
+        /// Fired when the engine has completed starting the elevated process.
+        /// </summary>
+        public event EventHandler<ElevateCompleteEventArgs> ElevateComplete;
+
+        /// <summary>
+        /// Fired when the engine has changed progress for the bundle installation.
+        /// </summary>
+        public event EventHandler<ProgressEventArgs> Progress;
+
+        /// <summary>
+        /// Fired when the engine has encountered an error.
+        /// </summary>
+        public event EventHandler<ErrorEventArgs> Error;
+
+        /// <summary>
+        /// Fired when the engine has begun registering the location and visibility of the bundle.
+        /// </summary>
+        public event EventHandler<RegisterBeginEventArgs> RegisterBegin;
+
+        /// <summary>
+        /// Fired when the engine has completed registering the location and visibility of the bundle.
+        /// </summary>
+        public event EventHandler<RegisterCompleteEventArgs> RegisterComplete;
+
+        /// <summary>
+        /// Fired when the engine has begun removing the registration for the location and visibility of the bundle.
+        /// </summary>
+        public event EventHandler<UnregisterBeginEventArgs> UnregisterBegin;
+
+        /// <summary>
+        /// Fired when the engine has completed removing the registration for the location and visibility of the bundle.
+        /// </summary>
+        public event EventHandler<UnregisterCompleteEventArgs> UnregisterComplete;
+
+        /// <summary>
+        /// Fired when the engine has begun caching the installation sources.
+        /// </summary>
+        public event EventHandler<CacheBeginEventArgs> CacheBegin;
+
+        /// <summary>
+        /// Fired when the engine has begun caching a specific package.
+        /// </summary>
+        public event EventHandler<CachePackageBeginEventArgs> CachePackageBegin;
+
+        /// <summary>
+        /// Fired when the engine has begun acquiring the installation sources.
+        /// </summary>
+        public event EventHandler<CacheAcquireBeginEventArgs> CacheAcquireBegin;
+
+        /// <summary>
+        /// Fired when the engine has progress acquiring the installation sources.
+        /// </summary>
+        public event EventHandler<CacheAcquireProgressEventArgs> CacheAcquireProgress;
+
+        /// <summary>
+        /// Fired by the engine to allow the BA to change the source
+        /// using <see cref="M:Engine.SetLocalSource"/> or <see cref="M:Engine.SetDownloadSource"/>.
+        /// </summary>
+        public event EventHandler<ResolveSourceEventArgs> ResolveSource;
+
+        /// <summary>
+        /// Fired when the engine has completed the acquisition of the installation sources.
+        /// </summary>
+        public event EventHandler<CacheAcquireCompleteEventArgs> CacheAcquireComplete;
+
+        /// <summary>
+        /// Fired when the engine begins the verification of the acquired installation sources.
+        /// </summary>
+        public event EventHandler<CacheVerifyBeginEventArgs> CacheVerifyBegin;
+
+        /// <summary>
+        /// Fired when the engine complete the verification of the acquired installation sources.
+        /// </summary>
+        public event EventHandler<CacheVerifyCompleteEventArgs> CacheVerifyComplete;
+
+        /// <summary>
+        /// Fired when the engine has completed caching a specific package.
+        /// </summary>
+        public event EventHandler<CachePackageCompleteEventArgs> CachePackageComplete;
+
+        /// <summary>
+        /// Fired after the engine has cached the installation sources.
+        /// </summary>
+        public event EventHandler<CacheCompleteEventArgs> CacheComplete;
+
+        /// <summary>
+        /// Fired when the engine has begun installing packages.
+        /// </summary>
+        public event EventHandler<ExecuteBeginEventArgs> ExecuteBegin;
+
+        /// <summary>
+        /// Fired when the engine has begun installing a specific package.
+        /// </summary>
+        public event EventHandler<ExecutePackageBeginEventArgs> ExecutePackageBegin;
+
+        /// <summary>
+        /// Fired when the engine executes one or more patches targeting a product.
+        /// </summary>
+        public event EventHandler<ExecutePatchTargetEventArgs> ExecutePatchTarget;
+
+        /// <summary>
+        /// Fired when Windows Installer sends an installation message.
+        /// </summary>
+        public event EventHandler<ExecuteMsiMessageEventArgs> ExecuteMsiMessage;
+
+        /// <summary>
+        /// Fired when Windows Installer sends a files in use installation message.
+        /// </summary>
+        public event EventHandler<ExecuteFilesInUseEventArgs> ExecuteFilesInUse;
+
+        /// <summary>
+        /// Fired when the engine has completed installing a specific package.
+        /// </summary>
+        public event EventHandler<ExecutePackageCompleteEventArgs> ExecutePackageComplete;
+
+        /// <summary>
+        /// Fired when the engine has completed installing packages.
+        /// </summary>
+        public event EventHandler<ExecuteCompleteEventArgs> ExecuteComplete;
+
+        /// <summary>
+        /// Fired when the engine has completed installing the bundle.
+        /// </summary>
+        public event EventHandler<ApplyCompleteEventArgs> ApplyComplete;
+
+        /// <summary>
+        /// Fired by the engine while executing on payload.
+        /// </summary>
+        public event EventHandler<ExecuteProgressEventArgs> ExecuteProgress;
+
+        /// <summary>
+        /// Fired when the engine is about to launch the preapproved executable.
+        /// </summary>
+        public event EventHandler<LaunchApprovedExeBeginArgs> LaunchApprovedExeBegin;
+
+        /// <summary>
+        /// Fired when the engine has completed launching the preapproved executable.
+        /// </summary>
+        public event EventHandler<LaunchApprovedExeCompleteArgs> LaunchApprovedExeComplete;
+
+        /// <summary>
+        /// Entry point that is called when the bootstrapper application is ready to run.
+        /// </summary>
+        protected abstract void Run();
+
+        /// <summary>
+        /// Called by the engine on startup of the bootstrapper application.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnStartup(StartupEventArgs args)
+        {
+            EventHandler<StartupEventArgs> handler = this.Startup;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+
+            if (this.asyncExecution)
+            {
+                this.engine.Log(LogLevel.Verbose, "Creating BA thread to run asynchronously.");
+                Thread uiThread = new Thread(this.Run);
+                uiThread.Name = "UIThread";
+                uiThread.SetApartmentState(ApartmentState.STA);
+                uiThread.Start();
+            }
+            else
+            {
+                this.engine.Log(LogLevel.Verbose, "Creating BA thread to run synchronously.");
+                this.Run();
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine to uninitialize the BA.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnShutdown(ShutdownEventArgs args)
+        {
+            EventHandler<ShutdownEventArgs> handler = this.Shutdown;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the system is shutting down or the user is logging off.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        /// <remarks>
+        /// <para>To prevent shutting down or logging off, set <see cref="CancellableHResultEventArgs.Cancel"/> to
+        /// true; otherwise, set it to false.</para>
+        /// <para>By default setup will prevent shutting down or logging off between
+        /// <see cref="BootstrapperApplication.ApplyBegin"/> and <see cref="BootstrapperApplication.ApplyComplete"/>.
+        /// Derivatives can change this behavior by overriding <see cref="BootstrapperApplication.OnSystemShutdown"/>
+        /// or handling <see cref="BootstrapperApplication.SystemShutdown"/>.</para>
+        /// <para>If <see cref="SystemShutdownEventArgs.Reasons"/> contains <see cref="EndSessionReasons.Critical"/>
+        /// the bootstrapper cannot prevent the shutdown and only has a few seconds to save state or perform any other
+        /// critical operations before being closed by the operating system.</para>
+        /// <para>This method may be called on a different thread.</para>
+        /// </remarks>
+        protected virtual void OnSystemShutdown(SystemShutdownEventArgs args)
+        {
+            EventHandler<SystemShutdownEventArgs> handler = this.SystemShutdown;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+            else if (null != args)
+            {
+                // Allow requests to shut down when critical or not applying.
+                bool critical = EndSessionReasons.Critical == (EndSessionReasons.Critical & args.Reasons);
+                args.Cancel = !critical && this.applying;
+            }
+        }
+
+        /// <summary>
+        /// Called when the overall detection phase has begun.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectBegin(DetectBeginEventArgs args)
+        {
+            EventHandler<DetectBeginEventArgs> handler = this.DetectBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the update detection phase has begun.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectForwardCompatibleBundle(DetectForwardCompatibleBundleEventArgs args)
+        {
+            EventHandler<DetectForwardCompatibleBundleEventArgs> handler = this.DetectForwardCompatibleBundle;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the update detection phase has begun.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectUpdateBegin(DetectUpdateBeginEventArgs args)
+        {
+            EventHandler<DetectUpdateBeginEventArgs> handler = this.DetectUpdateBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Fired when the update detection has found a potential update candidate.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectUpdate(DetectUpdateEventArgs args)
+        {
+            EventHandler<DetectUpdateEventArgs> handler = this.DetectUpdate;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the update detection phase has completed.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectUpdateComplete(DetectUpdateCompleteEventArgs args)
+        {
+            EventHandler<DetectUpdateCompleteEventArgs> handler = this.DetectUpdateComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when a related bundle has been detected for a bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectRelatedBundle(DetectRelatedBundleEventArgs args)
+        {
+            EventHandler<DetectRelatedBundleEventArgs> handler = this.DetectRelatedBundle;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the detection for a specific package has begun.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectPackageBegin(DetectPackageBeginEventArgs args)
+        {
+            EventHandler<DetectPackageBeginEventArgs> handler = this.DetectPackageBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when a package was not detected but a package using the same provider key was.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectCompatibleMsiPackage(DetectCompatibleMsiPackageEventArgs args)
+        {
+            EventHandler<DetectCompatibleMsiPackageEventArgs> handler = this.DetectCompatibleMsiPackage;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when a related MSI package has been detected for a package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectRelatedMsiPackage(DetectRelatedMsiPackageEventArgs args)
+        {
+            EventHandler<DetectRelatedMsiPackageEventArgs> handler = this.DetectRelatedMsiPackage;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when an MSP package detects a target MSI has been detected.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectTargetMsiPackage(DetectTargetMsiPackageEventArgs args)
+        {
+            EventHandler<DetectTargetMsiPackageEventArgs> handler = this.DetectTargetMsiPackage;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when an MSI feature has been detected for a package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectMsiFeature(DetectMsiFeatureEventArgs args)
+        {
+            EventHandler<DetectMsiFeatureEventArgs> handler = this.DetectMsiFeature;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the detection for a specific package has completed.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectPackageComplete(DetectPackageCompleteEventArgs args)
+        {
+            EventHandler<DetectPackageCompleteEventArgs> handler = this.DetectPackageComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the detection phase has completed.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnDetectComplete(DetectCompleteEventArgs args)
+        {
+            EventHandler<DetectCompleteEventArgs> handler = this.DetectComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun planning the installation.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanBegin(PlanBeginEventArgs args)
+        {
+            EventHandler<PlanBeginEventArgs> handler = this.PlanBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun planning for a prior bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanRelatedBundle(PlanRelatedBundleEventArgs args)
+        {
+            EventHandler<PlanRelatedBundleEventArgs> handler = this.PlanRelatedBundle;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun planning the installation of a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanPackageBegin(PlanPackageBeginEventArgs args)
+        {
+            EventHandler<PlanPackageBeginEventArgs> handler = this.PlanPackageBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine plans a new, compatible package using the same provider key.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanCompatibleMsiPackageBegin(PlanCompatibleMsiPackageBeginEventArgs args)
+        {
+            EventHandler<PlanCompatibleMsiPackageBeginEventArgs> handler = this.PlanCompatibleMsiPackageBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed planning the installation of a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanCompatibleMsiPackageComplete(PlanCompatibleMsiPackageCompleteEventArgs args)
+        {
+            EventHandler<PlanCompatibleMsiPackageCompleteEventArgs> handler = this.PlanCompatibleMsiPackageComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine is about to plan the target MSI of a MSP package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanTargetMsiPackage(PlanTargetMsiPackageEventArgs args)
+        {
+            EventHandler<PlanTargetMsiPackageEventArgs> handler = this.PlanTargetMsiPackage;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine is about to plan an MSI feature of a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanMsiFeature(PlanMsiFeatureEventArgs args)
+        {
+            EventHandler<PlanMsiFeatureEventArgs> handler = this.PlanMsiFeature;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when then engine has completed planning the installation of a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanPackageComplete(PlanPackageCompleteEventArgs args)
+        {
+            EventHandler<PlanPackageCompleteEventArgs> handler = this.PlanPackageComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed planning the installation.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnPlanComplete(PlanCompleteEventArgs args)
+        {
+            EventHandler<PlanCompleteEventArgs> handler = this.PlanComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun installing the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnApplyBegin(ApplyBeginEventArgs args)
+        {
+            EventHandler<ApplyBeginEventArgs> handler = this.ApplyBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine is about to start the elevated process.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnElevateBegin(ElevateBeginEventArgs args)
+        {
+            EventHandler<ElevateBeginEventArgs> handler = this.ElevateBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed starting the elevated process.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnElevateComplete(ElevateCompleteEventArgs args)
+        {
+            EventHandler<ElevateCompleteEventArgs> handler = this.ElevateComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has changed progress for the bundle installation.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnProgress(ProgressEventArgs args)
+        {
+            EventHandler<ProgressEventArgs> handler = this.Progress;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has encountered an error.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnError(ErrorEventArgs args)
+        {
+            EventHandler<ErrorEventArgs> handler = this.Error;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun registering the location and visibility of the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnRegisterBegin(RegisterBeginEventArgs args)
+        {
+            EventHandler<RegisterBeginEventArgs> handler = this.RegisterBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed registering the location and visilibity of the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnRegisterComplete(RegisterCompleteEventArgs args)
+        {
+            EventHandler<RegisterCompleteEventArgs> handler = this.RegisterComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun removing the registration for the location and visibility of the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnUnregisterBegin(UnregisterBeginEventArgs args)
+        {
+            EventHandler<UnregisterBeginEventArgs> handler = this.UnregisterBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed removing the registration for the location and visibility of the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnUnregisterComplete(UnregisterCompleteEventArgs args)
+        {
+            EventHandler<UnregisterCompleteEventArgs> handler = this.UnregisterComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine begins to cache the installation sources.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheBegin(CacheBeginEventArgs args)
+        {
+            EventHandler<CacheBeginEventArgs> handler = this.CacheBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine when it begins to cache a specific package.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCachePackageBegin(CachePackageBeginEventArgs args)
+        {
+            EventHandler<CachePackageBeginEventArgs> handler = this.CachePackageBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine begins to cache the container or payload.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheAcquireBegin(CacheAcquireBeginEventArgs args)
+        {
+            EventHandler<CacheAcquireBeginEventArgs> handler = this.CacheAcquireBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has progressed on caching the container or payload.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheAcquireProgress(CacheAcquireProgressEventArgs args)
+        {
+            EventHandler<CacheAcquireProgressEventArgs> handler = this.CacheAcquireProgress;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine to allow the BA to change the source
+        /// using <see cref="M:Engine.SetLocalSource"/> or <see cref="M:Engine.SetDownloadSource"/>.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnResolveSource(ResolveSourceEventArgs args)
+        {
+            EventHandler<ResolveSourceEventArgs> handler = this.ResolveSource;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine completes caching of the container or payload.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheAcquireComplete(CacheAcquireCompleteEventArgs args)
+        {
+            EventHandler<CacheAcquireCompleteEventArgs> handler = this.CacheAcquireComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has started verify the payload.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheVerifyBegin(CacheVerifyBeginEventArgs args)
+        {
+            EventHandler<CacheVerifyBeginEventArgs> handler = this.CacheVerifyBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine completes verification of the payload.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCacheVerifyComplete(CacheVerifyCompleteEventArgs args)
+        {
+            EventHandler<CacheVerifyCompleteEventArgs> handler = this.CacheVerifyComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine completes caching a specific package.
+        /// </summary>
+        /// <param name="args"></param>
+        protected virtual void OnCachePackageComplete(CachePackageCompleteEventArgs args)
+        {
+            EventHandler<CachePackageCompleteEventArgs> handler = this.CachePackageComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called after the engine has cached the installation sources.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnCacheComplete(CacheCompleteEventArgs args)
+        {
+            EventHandler<CacheCompleteEventArgs> handler = this.CacheComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun installing packages.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecuteBegin(ExecuteBeginEventArgs args)
+        {
+            EventHandler<ExecuteBeginEventArgs> handler = this.ExecuteBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has begun installing a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecutePackageBegin(ExecutePackageBeginEventArgs args)
+        {
+            EventHandler<ExecutePackageBeginEventArgs> handler = this.ExecutePackageBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine executes one or more patches targeting a product.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecutePatchTarget(ExecutePatchTargetEventArgs args)
+        {
+            EventHandler<ExecutePatchTargetEventArgs> handler = this.ExecutePatchTarget;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when Windows Installer sends an installation message.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecuteMsiMessage(ExecuteMsiMessageEventArgs args)
+        {
+            EventHandler<ExecuteMsiMessageEventArgs> handler = this.ExecuteMsiMessage;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when Windows Installer sends a file in use installation message.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecuteFilesInUse(ExecuteFilesInUseEventArgs args)
+        {
+            EventHandler<ExecuteFilesInUseEventArgs> handler = this.ExecuteFilesInUse;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed installing a specific package.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecutePackageComplete(ExecutePackageCompleteEventArgs args)
+        {
+            EventHandler<ExecutePackageCompleteEventArgs> handler = this.ExecutePackageComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed installing packages.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecuteComplete(ExecuteCompleteEventArgs args)
+        {
+            EventHandler<ExecuteCompleteEventArgs> handler = this.ExecuteComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called when the engine has completed installing the bundle.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnApplyComplete(ApplyCompleteEventArgs args)
+        {
+            EventHandler<ApplyCompleteEventArgs> handler = this.ApplyComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine while executing on payload.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnExecuteProgress(ExecuteProgressEventArgs args)
+        {
+            EventHandler<ExecuteProgressEventArgs> handler = this.ExecuteProgress;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine before trying to launch the preapproved executable.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnLaunchApprovedExeBegin(LaunchApprovedExeBeginArgs args)
+        {
+            EventHandler<LaunchApprovedExeBeginArgs> handler = this.LaunchApprovedExeBegin;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        /// <summary>
+        /// Called by the engine after trying to launch the preapproved executable.
+        /// </summary>
+        /// <param name="args">Additional arguments for this event.</param>
+        protected virtual void OnLaunchApprovedExeComplete(LaunchApprovedExeCompleteArgs args)
+        {
+            EventHandler<LaunchApprovedExeCompleteArgs> handler = this.LaunchApprovedExeComplete;
+            if (null != handler)
+            {
+                handler(this, args);
+            }
+        }
+
+        #region IBootstrapperApplication Members
+
+        int IBootstrapperApplication.OnStartup()
+        {
+            StartupEventArgs args = new StartupEventArgs();
+            this.OnStartup(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnShutdown(ref BOOTSTRAPPER_SHUTDOWN_ACTION action)
+        {
+            ShutdownEventArgs args = new ShutdownEventArgs(action);
+            this.OnShutdown(args);
+
+            action = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnSystemShutdown(EndSessionReasons dwEndSession, ref bool fCancel)
+        {
+            SystemShutdownEventArgs args = new SystemShutdownEventArgs(dwEndSession, fCancel);
+            this.OnSystemShutdown(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectBegin(bool fInstalled, int cPackages, ref bool fCancel)
+        {
+            DetectBeginEventArgs args = new DetectBeginEventArgs(fInstalled, cPackages, fCancel);
+            this.OnDetectBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectForwardCompatibleBundle(string wzBundleId, RelationType relationType, string wzBundleTag, bool fPerMachine, long version, ref bool fCancel, ref bool fIgnoreBundle)
+        {
+            DetectForwardCompatibleBundleEventArgs args = new DetectForwardCompatibleBundleEventArgs(wzBundleId, relationType, wzBundleTag, fPerMachine, version, fCancel, fIgnoreBundle);
+            this.OnDetectForwardCompatibleBundle(args);
+
+            fCancel = args.Cancel;
+            fIgnoreBundle = args.IgnoreBundle;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectUpdateBegin(string wzUpdateLocation, ref bool fCancel, ref bool fSkip)
+        {
+            DetectUpdateBeginEventArgs args = new DetectUpdateBeginEventArgs(wzUpdateLocation, fCancel, fSkip);
+            this.OnDetectUpdateBegin(args);
+
+            fCancel = args.Cancel;
+            fSkip = args.Skip;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectUpdate(string wzUpdateLocation, long dw64Size, long dw64Version, string wzTitle, string wzSummary, string wzContentType, string wzContent, ref bool fCancel, ref bool fStopProcessingUpdates)
+        {
+            DetectUpdateEventArgs args = new DetectUpdateEventArgs(wzUpdateLocation, dw64Size, dw64Version, wzTitle, wzSummary, wzContentType, wzContent, fCancel, fStopProcessingUpdates);
+            this.OnDetectUpdate(args);
+
+            fCancel = args.Cancel;
+            fStopProcessingUpdates = args.StopProcessingUpdates;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectUpdateComplete(int hrStatus, ref bool fIgnoreError)
+        {
+            DetectUpdateCompleteEventArgs args = new DetectUpdateCompleteEventArgs(hrStatus, fIgnoreError);
+            this.OnDetectUpdateComplete(args);
+
+            fIgnoreError = args.IgnoreError;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectRelatedBundle(string wzProductCode, RelationType relationType, string wzBundleTag, bool fPerMachine, long version, RelatedOperation operation, ref bool fCancel)
+        {
+            DetectRelatedBundleEventArgs args = new DetectRelatedBundleEventArgs(wzProductCode, relationType, wzBundleTag, fPerMachine, version, operation, fCancel);
+            this.OnDetectRelatedBundle(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectPackageBegin(string wzPackageId, ref bool fCancel)
+        {
+            DetectPackageBeginEventArgs args = new DetectPackageBeginEventArgs(wzPackageId, fCancel);
+            this.OnDetectPackageBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectCompatibleMsiPackage(string wzPackageId, string wzCompatiblePackageId, long dw64CompatiblePackageVersion, ref bool fCancel)
+        {
+            DetectCompatibleMsiPackageEventArgs args = new DetectCompatibleMsiPackageEventArgs(wzPackageId, wzCompatiblePackageId, dw64CompatiblePackageVersion, fCancel);
+            this.OnDetectCompatibleMsiPackage(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectRelatedMsiPackage(string wzPackageId, string wzUpgradeCode, string wzProductCode, bool fPerMachine, long version, RelatedOperation operation, ref bool fCancel)
+        {
+            DetectRelatedMsiPackageEventArgs args = new DetectRelatedMsiPackageEventArgs(wzPackageId, wzUpgradeCode, wzProductCode, fPerMachine, version, operation, fCancel);
+            this.OnDetectRelatedMsiPackage(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectTargetMsiPackage(string wzPackageId, string wzProductCode, PackageState patchState, ref bool fCancel)
+        {
+            DetectTargetMsiPackageEventArgs args = new DetectTargetMsiPackageEventArgs(wzPackageId, wzProductCode, patchState, fCancel);
+            this.OnDetectTargetMsiPackage(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectMsiFeature(string wzPackageId, string wzFeatureId, FeatureState state, ref bool fCancel)
+        {
+            DetectMsiFeatureEventArgs args = new DetectMsiFeatureEventArgs(wzPackageId, wzFeatureId, state, fCancel);
+            this.OnDetectMsiFeature(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectPackageComplete(string wzPackageId, int hrStatus, PackageState state)
+        {
+            DetectPackageCompleteEventArgs args = new DetectPackageCompleteEventArgs(wzPackageId, hrStatus, state);
+            this.OnDetectPackageComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnDetectComplete(int hrStatus)
+        {
+            DetectCompleteEventArgs args = new DetectCompleteEventArgs(hrStatus);
+            this.OnDetectComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanBegin(int cPackages, ref bool fCancel)
+        {
+            PlanBeginEventArgs args = new PlanBeginEventArgs(cPackages, fCancel);
+            this.OnPlanBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanRelatedBundle(string wzBundleId, RequestState recommendedState, ref RequestState pRequestedState, ref bool fCancel)
+        {
+            PlanRelatedBundleEventArgs args = new PlanRelatedBundleEventArgs(wzBundleId, recommendedState, pRequestedState, fCancel);
+            this.OnPlanRelatedBundle(args);
+
+            pRequestedState = args.State;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanPackageBegin(string wzPackageId, RequestState recommendedState, ref RequestState pRequestedState, ref bool fCancel)
+        {
+            PlanPackageBeginEventArgs args = new PlanPackageBeginEventArgs(wzPackageId, recommendedState, pRequestedState, fCancel);
+            this.OnPlanPackageBegin(args);
+
+            pRequestedState = args.State;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanCompatibleMsiPackageBegin(string wzPackageId, string wzCompatiblePackageId, long dw64CompatiblePackageVersion, RequestState recommendedState, ref RequestState pRequestedState, ref bool fCancel)
+        {
+            PlanCompatibleMsiPackageBeginEventArgs args = new PlanCompatibleMsiPackageBeginEventArgs(wzPackageId, wzCompatiblePackageId, dw64CompatiblePackageVersion, recommendedState, pRequestedState, fCancel);
+            this.OnPlanCompatibleMsiPackageBegin(args);
+
+            pRequestedState = args.State;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanCompatibleMsiPackageComplete(string wzPackageId, string wzCompatiblePackageId, int hrStatus, PackageState state, RequestState requested, ActionState execute, ActionState rollback)
+        {
+            PlanCompatibleMsiPackageCompleteEventArgs args = new PlanCompatibleMsiPackageCompleteEventArgs(wzPackageId, wzCompatiblePackageId, hrStatus, state, requested, execute, rollback);
+            this.OnPlanCompatibleMsiPackageComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanTargetMsiPackage(string wzPackageId, string wzProductCode, RequestState recommendedState, ref RequestState pRequestedState, ref bool fCancel)
+        {
+            PlanTargetMsiPackageEventArgs args = new PlanTargetMsiPackageEventArgs(wzPackageId, wzProductCode, recommendedState, pRequestedState, fCancel);
+            this.OnPlanTargetMsiPackage(args);
+
+            pRequestedState = args.State;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanMsiFeature(string wzPackageId, string wzFeatureId, FeatureState recommendedState, ref FeatureState pRequestedState, ref bool fCancel)
+        {
+            PlanMsiFeatureEventArgs args = new PlanMsiFeatureEventArgs(wzPackageId, wzFeatureId, recommendedState, pRequestedState, fCancel);
+            this.OnPlanMsiFeature(args);
+
+            pRequestedState = args.State;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanPackageComplete(string wzPackageId, int hrStatus, PackageState state, RequestState requested, ActionState execute, ActionState rollback)
+        {
+            var args = new PlanPackageCompleteEventArgs(wzPackageId, hrStatus, state, requested, execute, rollback);
+            this.OnPlanPackageComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnPlanComplete(int hrStatus)
+        {
+            PlanCompleteEventArgs args = new PlanCompleteEventArgs(hrStatus);
+            this.OnPlanComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnApplyBegin(int dwPhaseCount, ref bool fCancel)
+        {
+            this.applying = true;
+
+            ApplyBeginEventArgs args = new ApplyBeginEventArgs(dwPhaseCount, fCancel);
+            this.OnApplyBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnElevateBegin(ref bool fCancel)
+        {
+            ElevateBeginEventArgs args = new ElevateBeginEventArgs(fCancel);
+            this.OnElevateBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnElevateComplete(int hrStatus)
+        {
+            ElevateCompleteEventArgs args = new ElevateCompleteEventArgs(hrStatus);
+            this.OnElevateComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnProgress(int dwProgressPercentage, int dwOverallPercentage, ref bool fCancel)
+        {
+            ProgressEventArgs args = new ProgressEventArgs(dwProgressPercentage, dwOverallPercentage, fCancel);
+            this.OnProgress(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnError(ErrorType errorType, string wzPackageId, int dwCode, string wzError, int dwUIHint, int cData, string[] rgwzData, Result nRecommendation, ref Result pResult)
+        {
+            ErrorEventArgs args = new ErrorEventArgs(errorType, wzPackageId, dwCode, wzError, dwUIHint, rgwzData, nRecommendation, pResult);
+            this.OnError(args);
+
+            pResult = args.Result;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnRegisterBegin(ref bool fCancel)
+        {
+            RegisterBeginEventArgs args = new RegisterBeginEventArgs(fCancel);
+            this.OnRegisterBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnRegisterComplete(int hrStatus)
+        {
+            RegisterCompleteEventArgs args = new RegisterCompleteEventArgs(hrStatus);
+            this.OnRegisterComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheBegin(ref bool fCancel)
+        {
+            CacheBeginEventArgs args = new CacheBeginEventArgs(fCancel);
+            this.OnCacheBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCachePackageBegin(string wzPackageId, int cCachePayloads, long dw64PackageCacheSize, ref bool fCancel)
+        {
+            CachePackageBeginEventArgs args = new CachePackageBeginEventArgs(wzPackageId, cCachePayloads, dw64PackageCacheSize, fCancel);
+            this.OnCachePackageBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheAcquireBegin(string wzPackageOrContainerId, string wzPayloadId, CacheOperation operation, string wzSource, ref bool fCancel)
+        {
+            CacheAcquireBeginEventArgs args = new CacheAcquireBeginEventArgs(wzPackageOrContainerId, wzPayloadId, operation, wzSource, fCancel);
+            this.OnCacheAcquireBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheAcquireProgress(string wzPackageOrContainerId, string wzPayloadId, long dw64Progress, long dw64Total, int dwOverallPercentage, ref bool fCancel)
+        {
+            CacheAcquireProgressEventArgs args = new CacheAcquireProgressEventArgs(wzPackageOrContainerId, wzPayloadId, dw64Progress, dw64Total, dwOverallPercentage, fCancel);
+            this.OnCacheAcquireProgress(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnResolveSource(string wzPackageOrContainerId, string wzPayloadId, string wzLocalSource, string wzDownloadSource, BOOTSTRAPPER_RESOLVESOURCE_ACTION recommendation, ref BOOTSTRAPPER_RESOLVESOURCE_ACTION action, ref bool fCancel)
+        {
+            ResolveSourceEventArgs args = new ResolveSourceEventArgs(wzPackageOrContainerId, wzPayloadId, wzLocalSource, wzDownloadSource, action, recommendation, fCancel);
+            this.OnResolveSource(args);
+
+            action = args.Action;
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheAcquireComplete(string wzPackageOrContainerId, string wzPayloadId, int hrStatus, BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION recommendation, ref BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION action)
+        {
+            CacheAcquireCompleteEventArgs args = new CacheAcquireCompleteEventArgs(wzPackageOrContainerId, wzPayloadId, hrStatus, recommendation, action);
+            this.OnCacheAcquireComplete(args);
+
+            action = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheVerifyBegin(string wzPackageId, string wzPayloadId, ref bool fCancel)
+        {
+            CacheVerifyBeginEventArgs args = new CacheVerifyBeginEventArgs(wzPackageId, wzPayloadId, fCancel);
+            this.OnCacheVerifyBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheVerifyComplete(string wzPackageId, string wzPayloadId, int hrStatus, BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION recommendation, ref BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION action)
+        {
+            CacheVerifyCompleteEventArgs args = new CacheVerifyCompleteEventArgs(wzPackageId, wzPayloadId, hrStatus, recommendation, action);
+            this.OnCacheVerifyComplete(args);
+
+            action = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCachePackageComplete(string wzPackageId, int hrStatus, BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION recommendation, ref BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION action)
+        {
+            CachePackageCompleteEventArgs args = new CachePackageCompleteEventArgs(wzPackageId, hrStatus, recommendation, action);
+            this.OnCachePackageComplete(args);
+
+            action = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnCacheComplete(int hrStatus)
+        {
+            CacheCompleteEventArgs args = new CacheCompleteEventArgs(hrStatus);
+            this.OnCacheComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecuteBegin(int cExecutingPackages, ref bool fCancel)
+        {
+            ExecuteBeginEventArgs args = new ExecuteBeginEventArgs(cExecutingPackages, fCancel);
+            this.OnExecuteBegin(args);
+
+            args.Cancel = fCancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecutePackageBegin(string wzPackageId, bool fExecute, ref bool fCancel)
+        {
+            ExecutePackageBeginEventArgs args = new ExecutePackageBeginEventArgs(wzPackageId, fExecute, fCancel);
+            this.OnExecutePackageBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecutePatchTarget(string wzPackageId, string wzTargetProductCode, ref bool fCancel)
+        {
+            ExecutePatchTargetEventArgs args = new ExecutePatchTargetEventArgs(wzPackageId, wzTargetProductCode, fCancel);
+            this.OnExecutePatchTarget(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecuteProgress(string wzPackageId, int dwProgressPercentage, int dwOverallPercentage, ref bool fCancel)
+        {
+            ExecuteProgressEventArgs args = new ExecuteProgressEventArgs(wzPackageId, dwProgressPercentage, dwOverallPercentage, fCancel);
+            this.OnExecuteProgress(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecuteMsiMessage(string wzPackageId, InstallMessage messageType, int dwUIHint, string wzMessage, int cData, string[] rgwzData, Result nRecommendation, ref Result pResult)
+        {
+            ExecuteMsiMessageEventArgs args = new ExecuteMsiMessageEventArgs(wzPackageId, messageType, dwUIHint, wzMessage, rgwzData, nRecommendation, pResult);
+            this.OnExecuteMsiMessage(args);
+
+            pResult = args.Result;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecuteFilesInUse(string wzPackageId, int cFiles, string[] rgwzFiles, Result nRecommendation, ref Result pResult)
+        {
+            ExecuteFilesInUseEventArgs args = new ExecuteFilesInUseEventArgs(wzPackageId, rgwzFiles, nRecommendation, pResult);
+            this.OnExecuteFilesInUse(args);
+
+            pResult = args.Result;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecutePackageComplete(string wzPackageId, int hrStatus, ApplyRestart restart, BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION recommendation, ref BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION pAction)
+        {
+            ExecutePackageCompleteEventArgs args = new ExecutePackageCompleteEventArgs(wzPackageId, hrStatus, restart, recommendation, pAction);
+            this.OnExecutePackageComplete(args);
+
+            pAction = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnExecuteComplete(int hrStatus)
+        {
+            ExecuteCompleteEventArgs args = new ExecuteCompleteEventArgs(hrStatus);
+            this.OnExecuteComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnUnregisterBegin(ref bool fCancel)
+        {
+            UnregisterBeginEventArgs args = new UnregisterBeginEventArgs(fCancel);
+            this.OnUnregisterBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnUnregisterComplete(int hrStatus)
+        {
+            UnregisterCompleteEventArgs args = new UnregisterCompleteEventArgs(hrStatus);
+            this.OnUnregisterComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnApplyComplete(int hrStatus, ApplyRestart restart, BOOTSTRAPPER_APPLYCOMPLETE_ACTION recommendation, ref BOOTSTRAPPER_APPLYCOMPLETE_ACTION pAction)
+        {
+            ApplyCompleteEventArgs args = new ApplyCompleteEventArgs(hrStatus, restart, recommendation, pAction);
+            this.OnApplyComplete(args);
+
+            this.applying = false;
+
+            pAction = args.Action;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnLaunchApprovedExeBegin(ref bool fCancel)
+        {
+            LaunchApprovedExeBeginArgs args = new LaunchApprovedExeBeginArgs(fCancel);
+            this.OnLaunchApprovedExeBegin(args);
+
+            fCancel = args.Cancel;
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.OnLaunchApprovedExeComplete(int hrStatus, int processId)
+        {
+            LaunchApprovedExeCompleteArgs args = new LaunchApprovedExeCompleteArgs(hrStatus, processId);
+            this.OnLaunchApprovedExeComplete(args);
+
+            return args.HResult;
+        }
+
+        int IBootstrapperApplication.BAProc(BOOTSTRAPPER_APPLICATION_MESSAGE message, IntPtr pvArgs, IntPtr pvResults, IntPtr pvContext)
+        {
+            switch (message)
+            {
+                default:
+                    return NativeMethods.E_NOTIMPL;
+            }
+        }
+
+        void IBootstrapperApplication.BAProcFallback(BOOTSTRAPPER_APPLICATION_MESSAGE message, IntPtr pvArgs, IntPtr pvResults, ref int phr, IntPtr pvContext)
+        {
+        }
+
+        #endregion
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperApplicationData.cs b/src/WixToolset.Mba.Core/BootstrapperApplicationData.cs
new file mode 100644
index 00000000..a17f1a05
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperApplicationData.cs
@@ -0,0 +1,63 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.IO;
+    using System.Xml.XPath;
+
+    public class BootstrapperApplicationData : IBootstrapperApplicationData
+    {
+        public const string DefaultFileName = "BootstrapperApplicationData.xml";
+        public const string XMLNamespace = "http://wixtoolset.org/schemas/v4/2010/BootstrapperApplicationData";
+
+        public static readonly DirectoryInfo DefaultFolder;
+        public static readonly FileInfo DefaultFile;
+
+        static BootstrapperApplicationData()
+        {
+            DefaultFolder = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
+            DefaultFile = new FileInfo(Path.Combine(DefaultFolder.FullName, DefaultFileName));
+        }
+
+        public FileInfo BADataFile { get; private set; }
+
+        public IBundleInfo Bundle { get; private set; }
+
+        public BootstrapperApplicationData() : this(DefaultFile) { }
+
+        public BootstrapperApplicationData(FileInfo baDataFile)
+        {
+            this.BADataFile = baDataFile;
+
+            using (FileStream fs = this.BADataFile.OpenRead())
+            {
+                this.Bundle = BundleInfo.ParseBundleFromStream(fs);
+            }
+        }
+
+        public static string GetAttribute(XPathNavigator node, string attributeName)
+        {
+            XPathNavigator attribute = node.SelectSingleNode("@" + attributeName);
+
+            if (attribute == null)
+            {
+                return null;
+            }
+
+            return attribute.Value;
+        }
+
+        public static bool? GetYesNoAttribute(XPathNavigator node, string attributeName)
+        {
+            string attributeValue = GetAttribute(node, attributeName);
+
+            if (attributeValue == null)
+            {
+                return null;
+            }
+
+            return attributeValue.Equals("yes", StringComparison.InvariantCulture);
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperApplicationFactory.cs b/src/WixToolset.Mba.Core/BootstrapperApplicationFactory.cs
new file mode 100644
index 00000000..28430bb8
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperApplicationFactory.cs
@@ -0,0 +1,86 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Configuration;
+    using System.Reflection;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Entry point for the MBA host to create and return the IBootstrapperApplication implementation to the engine.
+    /// </summary>
+    [ClassInterface(ClassInterfaceType.None)]
+    public sealed class BootstrapperApplicationFactory : MarshalByRefObject, IBootstrapperApplicationFactory
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="BootstrapperApplicationFactory"/> class.
+        /// </summary>
+        public BootstrapperApplicationFactory()
+        {
+        }
+
+        /// <summary>
+        /// Loads the bootstrapper application assembly and creates an instance of the IBootstrapperApplication.
+        /// </summary>
+        /// <param name="pEngine">IBootstrapperEngine provided for the bootstrapper application.</param>
+        /// <param name="command">Command line for the bootstrapper application.</param>
+        /// <returns>Bootstrapper application via <see cref="IBootstrapperApplication"/> interface.</returns>
+        /// <exception cref="MissingAttributeException">The bootstrapper application assembly
+        /// does not define the <see cref="BootstrapperApplicationFactoryAttribute"/>.</exception>
+        public IBootstrapperApplication Create(IBootstrapperEngine pEngine, ref Command command)
+        {
+            // Get the wix.boostrapper section group to get the name of the bootstrapper application assembly to host.
+            var section = ConfigurationManager.GetSection("wix.bootstrapper/host") as HostSection;
+            if (null == section)
+            {
+                throw new MissingAttributeException(); // TODO: throw a more specific exception than this.
+            }
+
+            // Load the BA's IBootstrapperApplicationFactory.
+            var baFactoryType = BootstrapperApplicationFactory.GetBAFactoryTypeFromAssembly(section.AssemblyName);
+            var baFactory = (IBootstrapperApplicationFactory)Activator.CreateInstance(baFactoryType);
+            if (null == baFactory)
+            {
+                throw new InvalidBootstrapperApplicationFactoryException();
+            }
+
+            var ba = baFactory.Create(pEngine, ref command);
+            return ba;
+        }
+
+        /// <summary>
+        /// Locates the <see cref="BootstrapperApplicationFactoryAttribute"/> and returns the specified type.
+        /// </summary>
+        /// <param name="assemblyName">The assembly that defines the IBootstrapperApplicationFactory implementation.</param>
+        /// <returns>The bootstrapper application factory <see cref="Type"/>.</returns>
+        private static Type GetBAFactoryTypeFromAssembly(string assemblyName)
+        {
+            Type baFactoryType = null;
+
+            // Load the requested assembly.
+            Assembly asm = AppDomain.CurrentDomain.Load(assemblyName);
+
+            // If an assembly was loaded and is not the current assembly, check for the required attribute.
+            // This is done to avoid using the BootstrapperApplicationFactoryAttribute which we use at build time
+            // to specify the BootstrapperApplicationFactory assembly in the manifest.
+            if (!Assembly.GetExecutingAssembly().Equals(asm))
+            {
+                // There must be one and only one BootstrapperApplicationFactoryAttribute.
+                // The attribute prevents multiple declarations already.
+                var attrs = (BootstrapperApplicationFactoryAttribute[])asm.GetCustomAttributes(typeof(BootstrapperApplicationFactoryAttribute), false);
+                if (null != attrs)
+                {
+                    baFactoryType = attrs[0].BootstrapperApplicationFactoryType;
+                }
+            }
+
+            if (null == baFactoryType)
+            {
+                throw new MissingAttributeException();
+            }
+
+            return baFactoryType;
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperApplicationFactoryAttribute.cs b/src/WixToolset.Mba.Core/BootstrapperApplicationFactoryAttribute.cs
new file mode 100644
index 00000000..781d4ea1
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperApplicationFactoryAttribute.cs
@@ -0,0 +1,35 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+
+    /// <summary>
+    /// Identifies the bootstrapper application factory class.
+    /// </summary>
+    /// <remarks>
+    /// This required assembly attribute identifies the bootstrapper application factory class.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
+    public sealed class BootstrapperApplicationFactoryAttribute : Attribute
+    {
+        private Type bootstrapperApplicationFactoryType;
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="BootstrapperApplicationFactoryAttribute"/> class.
+        /// </summary>
+        /// <param name="bootstrapperApplicationFactoryType">The <see cref="Type"/> of the BA factory.</param>
+        public BootstrapperApplicationFactoryAttribute(Type bootstrapperApplicationFactoryType)
+        {
+            this.bootstrapperApplicationFactoryType = bootstrapperApplicationFactoryType;
+        }
+
+        /// <summary>
+        /// Gets the type of the bootstrapper application factory class to create.
+        /// </summary>
+        public Type BootstrapperApplicationFactoryType
+        {
+            get { return this.bootstrapperApplicationFactoryType; }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperCommand.cs b/src/WixToolset.Mba.Core/BootstrapperCommand.cs
new file mode 100644
index 00000000..bbd10e1d
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperCommand.cs
@@ -0,0 +1,107 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime.InteropServices;
+
+    public sealed class BootstrapperCommand : IBootstrapperCommand
+    {
+        private readonly string commandLine;
+
+        public BootstrapperCommand(
+            LaunchAction action,
+            Display display,
+            Restart restart,
+            string commandLine,
+            int cmdShow,
+            ResumeType resume,
+            IntPtr splashScreen,
+            RelationType relation,
+            bool passthrough,
+            string layoutDirectory)
+        {
+            this.Action = action;
+            this.Display = display;
+            this.Restart = restart;
+            this.commandLine = commandLine;
+            this.CmdShow = cmdShow;
+            this.Resume = resume;
+            this.SplashScreen = splashScreen;
+            this.Relation = relation;
+            this.Passthrough = passthrough;
+            this.LayoutDirectory = layoutDirectory;
+        }
+
+        public LaunchAction Action { get; }
+
+        public Display Display { get; }
+
+        public Restart Restart { get; }
+
+        public string[] CommandLineArgs => GetCommandLineArgs(this.commandLine);
+
+        public int CmdShow { get; }
+
+        public ResumeType Resume { get; }
+
+        public IntPtr SplashScreen { get; }
+
+        public RelationType Relation { get; }
+
+        public bool Passthrough { get; }
+
+        public string LayoutDirectory { get; }
+
+        /// <summary>
+        /// Gets the command line arguments as a string array.
+        /// </summary>
+        /// <returns>
+        /// Array of command line arguments.
+        /// </returns>
+        /// <exception type="Win32Exception">The command line could not be parsed into an array.</exception>
+        /// <remarks>
+        /// This method uses the same parsing as the operating system which handles quotes and spaces correctly.
+        /// </remarks>
+        public static string[] GetCommandLineArgs(string commandLine)
+        {
+            if (null == commandLine)
+            {
+                return new string[0];
+            }
+
+            // Parse the filtered command line arguments into a native array.
+            int argc = 0;
+
+            // CommandLineToArgvW tries to treat the first argument as the path to the process,
+            // which fails pretty miserably if your first argument is something like
+            // FOO="C:\Program Files\My Company". So give it something harmless to play with.
+            IntPtr argv = NativeMethods.CommandLineToArgvW("ignored " + commandLine, out argc);
+
+            if (IntPtr.Zero == argv)
+            {
+                // Throw an exception with the last error.
+                throw new Win32Exception();
+            }
+
+            // Marshal each native array pointer to a managed string.
+            try
+            {
+                // Skip "ignored" argument/hack.
+                string[] args = new string[argc - 1];
+                for (int i = 1; i < argc; ++i)
+                {
+                    IntPtr argvi = Marshal.ReadIntPtr(argv, i * IntPtr.Size);
+                    args[i - 1] = Marshal.PtrToStringUni(argvi);
+                }
+
+                return args;
+            }
+            finally
+            {
+                NativeMethods.LocalFree(argv);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BootstrapperSectionGroup.cs b/src/WixToolset.Mba.Core/BootstrapperSectionGroup.cs
new file mode 100644
index 00000000..7721c027
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BootstrapperSectionGroup.cs
@@ -0,0 +1,29 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Configuration;
+
+    /// <summary>
+    /// Handler for the wix.bootstrapper configuration section group.
+    /// </summary>
+    public class BootstrapperSectionGroup : ConfigurationSectionGroup
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="BootstrapperSectionGroup"/> class.
+        /// </summary>
+        public BootstrapperSectionGroup()
+        {
+        }
+
+        /// <summary>
+        /// Gets the <see cref="HostSection"/> handler for the mba configuration section.
+        /// </summary>
+        [ConfigurationProperty("host")]
+        public HostSection Host
+        {
+            get { return (HostSection)base.Sections["host"]; }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/BundleInfo.cs b/src/WixToolset.Mba.Core/BundleInfo.cs
new file mode 100644
index 00000000..51c2d268
--- /dev/null
+++ b/src/WixToolset.Mba.Core/BundleInfo.cs
@@ -0,0 +1,67 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+    using System.Xml.XPath;
+
+    public class BundleInfo : IBundleInfo
+    {
+        public bool PerMachine { get; internal set; }
+        public string Name { get; internal set; }
+        public string LogVariable { get; internal set; }
+        public IDictionary<string, IPackageInfo> Packages { get; internal set; }
+
+        internal BundleInfo()
+        {
+            this.Packages = new Dictionary<string, IPackageInfo>();
+        }
+
+        public void AddRelatedBundleAsPackage(DetectRelatedBundleEventArgs e)
+        {
+            var package = PackageInfo.GetRelatedBundleAsPackage(e.ProductCode, e.RelationType, e.PerMachine, e.Version);
+            this.Packages.Add(package.Id, package);
+        }
+
+        public static IBundleInfo ParseBundleFromStream(Stream stream)
+        {
+            XPathDocument manifest = new XPathDocument(stream);
+            XPathNavigator root = manifest.CreateNavigator();
+            return ParseBundleFromXml(root);
+        }
+
+        public static IBundleInfo ParseBundleFromXml(XPathNavigator root)
+        {
+            BundleInfo bundle = new BundleInfo();
+
+            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(root.NameTable);
+            namespaceManager.AddNamespace("p", BootstrapperApplicationData.XMLNamespace);
+            XPathNavigator bundleNode = root.SelectSingleNode("/p:BootstrapperApplicationData/p:WixBundleProperties", namespaceManager);
+
+            if (bundleNode == null)
+            {
+                throw new Exception("Failed to select bundle information.");
+            }
+
+            bool? perMachine = BootstrapperApplicationData.GetYesNoAttribute(bundleNode, "PerMachine");
+            if (perMachine.HasValue)
+            {
+                bundle.PerMachine = perMachine.Value;
+            }
+
+            bundle.Name = BootstrapperApplicationData.GetAttribute(bundleNode, "DisplayName");
+
+            bundle.LogVariable = BootstrapperApplicationData.GetAttribute(bundleNode, "LogPathVariable");
+
+            foreach (var package in PackageInfo.ParsePackagesFromXml(root))
+            {
+                bundle.Packages.Add(package.Id, package);
+            }
+
+            return bundle;
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/Engine.cs b/src/WixToolset.Mba.Core/Engine.cs
new file mode 100644
index 00000000..ad62134f
--- /dev/null
+++ b/src/WixToolset.Mba.Core/Engine.cs
@@ -0,0 +1,516 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime.InteropServices;
+    using System.Security;
+    using System.Text;
+
+    /// <summary>
+    /// Container class for the <see cref="IBootstrapperEngine"/> interface.
+    /// </summary>
+    public sealed class Engine : IEngine
+    {
+        // Burn errs on empty strings, so declare initial buffer size.
+        private const int InitialBufferSize = 80;
+        private static readonly string normalizeVersionFormatString = "{0} must be less than or equal to " + UInt16.MaxValue;
+
+        private IBootstrapperEngine engine;
+        private Variables<long> numericVariables;
+        private Variables<SecureString> secureStringVariables;
+        private Variables<string> stringVariables;
+        private Variables<Version> versionVariables;
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="Engine"/> container class.
+        /// </summary>
+        /// <param name="engine">The <see cref="IBootstrapperEngine"/> to contain.</param>
+        internal Engine(IBootstrapperEngine engine)
+        {
+            this.engine = engine;
+
+            // Wrap the calls to get and set numeric variables.
+            this.numericVariables = new Variables<long>(
+                delegate(string name)
+                {
+                    long value;
+                    int ret = this.engine.GetVariableNumeric(name, out value);
+                    if (NativeMethods.S_OK != ret)
+                    {
+                        throw new Win32Exception(ret);
+                    }
+
+                    return value;
+                },
+                delegate(string name, long value)
+                {
+                    this.engine.SetVariableNumeric(name, value);
+                },
+                delegate(string name)
+                {
+                    long value;
+                    int ret = this.engine.GetVariableNumeric(name, out value);
+
+                    return NativeMethods.E_NOTFOUND != ret;
+                }
+            );
+
+            // Wrap the calls to get and set string variables using SecureStrings.
+            this.secureStringVariables = new Variables<SecureString>(
+                delegate(string name)
+                {
+                    var pUniString = this.getStringVariable(name, out var length);
+                    try
+                    {
+                        return this.convertToSecureString(pUniString, length);
+                    }
+                    finally
+                    {
+                        if (IntPtr.Zero != pUniString)
+                        {
+                            Marshal.FreeCoTaskMem(pUniString);
+                        }
+                    }
+                },
+                delegate(string name, SecureString value)
+                {
+                    IntPtr pValue = Marshal.SecureStringToCoTaskMemUnicode(value);
+                    try
+                    {
+                        this.engine.SetVariableString(name, pValue);
+                    }
+                    finally
+                    {
+                        Marshal.FreeCoTaskMem(pValue);
+                    }
+                },
+                delegate(string name)
+                {
+                    return this.containsVariable(name);
+                }
+            );
+
+            // Wrap the calls to get and set string variables.
+            this.stringVariables = new Variables<string>(
+                delegate(string name)
+                {
+                    int length;
+                    IntPtr pUniString = this.getStringVariable(name, out length);
+                    try
+                    {
+                        return Marshal.PtrToStringUni(pUniString, length);
+                    }
+                    finally
+                    {
+                        if (IntPtr.Zero != pUniString)
+                        {
+                            Marshal.FreeCoTaskMem(pUniString);
+                        }
+                    }
+                },
+                delegate(string name, string value)
+                {
+                    IntPtr pValue = Marshal.StringToCoTaskMemUni(value);
+                    try
+                    {
+                        this.engine.SetVariableString(name, pValue);
+                    }
+                    finally
+                    {
+                        Marshal.FreeCoTaskMem(pValue);
+                    }
+                },
+                delegate(string name)
+                {
+                    return this.containsVariable(name);
+                }
+            );
+
+            // Wrap the calls to get and set version variables.
+            this.versionVariables = new Variables<Version>(
+                delegate(string name)
+                {
+                    long value;
+                    int ret = this.engine.GetVariableVersion(name, out value);
+                    if (NativeMethods.S_OK != ret)
+                    {
+                        throw new Win32Exception(ret);
+                    }
+
+                    return LongToVersion(value);
+                },
+                delegate(string name, Version value)
+                {
+                    long version = VersionToLong(value);
+                    this.engine.SetVariableVersion(name, version);
+                },
+                delegate(string name)
+                {
+                    long value;
+                    int ret = this.engine.GetVariableVersion(name, out value);
+
+                    return NativeMethods.E_NOTFOUND != ret;
+                }
+            );
+        }
+
+        public IVariables<long> NumericVariables
+        {
+            get { return this.numericVariables; }
+        }
+
+        public int PackageCount
+        {
+            get
+            {
+                int count;
+                this.engine.GetPackageCount(out count);
+
+                return count;
+            }
+        }
+
+        public IVariables<SecureString> SecureStringVariables
+        {
+            get { return this.secureStringVariables; }
+        }
+
+        public IVariables<string> StringVariables
+        {
+            get { return this.stringVariables; }
+        }
+
+        public IVariables<Version> VersionVariables
+        {
+            get { return this.versionVariables; }
+        }
+
+        public void Apply(IntPtr hwndParent)
+        {
+            this.engine.Apply(hwndParent);
+        }
+
+        public void CloseSplashScreen()
+        {
+            this.engine.CloseSplashScreen();
+        }
+
+        public void Detect()
+        {
+            this.Detect(IntPtr.Zero);
+        }
+
+        public void Detect(IntPtr hwndParent)
+        {
+            this.engine.Detect(hwndParent);
+        }
+
+        public bool Elevate(IntPtr hwndParent)
+        {
+            int ret = this.engine.Elevate(hwndParent);
+
+            if (NativeMethods.S_OK == ret || NativeMethods.E_ALREADYINITIALIZED == ret)
+            {
+                return true;
+            }
+            else if (NativeMethods.E_CANCELLED == ret)
+            {
+                return false;
+            }
+            else
+            {
+                throw new Win32Exception(ret);
+            }
+        }
+
+        public string EscapeString(string input)
+        {
+            int capacity = InitialBufferSize;
+            StringBuilder sb = new StringBuilder(capacity);
+
+            // Get the size of the buffer.
+            int ret = this.engine.EscapeString(input, sb, ref capacity);
+            if (NativeMethods.E_INSUFFICIENT_BUFFER == ret || NativeMethods.E_MOREDATA == ret)
+            {
+                sb.Capacity = ++capacity; // Add one for the null terminator.
+                ret = this.engine.EscapeString(input, sb, ref capacity);
+            }
+
+            if (NativeMethods.S_OK != ret)
+            {
+                throw new Win32Exception(ret);
+            }
+
+            return sb.ToString();
+        }
+
+        public bool EvaluateCondition(string condition)
+        {
+            bool value;
+            this.engine.EvaluateCondition(condition, out value);
+
+            return value;
+        }
+
+        public string FormatString(string format)
+        {
+            int capacity = InitialBufferSize;
+            StringBuilder sb = new StringBuilder(capacity);
+
+            // Get the size of the buffer.
+            int ret = this.engine.FormatString(format, sb, ref capacity);
+            if (NativeMethods.E_INSUFFICIENT_BUFFER == ret || NativeMethods.E_MOREDATA == ret)
+            {
+                sb.Capacity = ++capacity; // Add one for the null terminator.
+                ret = this.engine.FormatString(format, sb, ref capacity);
+            }
+
+            if (NativeMethods.S_OK != ret)
+            {
+                throw new Win32Exception(ret);
+            }
+
+            return sb.ToString();
+        }
+
+        public void LaunchApprovedExe(IntPtr hwndParent, string approvedExeForElevationId, string arguments)
+        {
+            this.LaunchApprovedExe(hwndParent, approvedExeForElevationId, arguments, 0);
+        }
+
+        public void LaunchApprovedExe(IntPtr hwndParent, string approvedExeForElevationId, string arguments, int waitForInputIdleTimeout)
+        {
+            this.engine.LaunchApprovedExe(hwndParent, approvedExeForElevationId, arguments, waitForInputIdleTimeout);
+        }
+
+        public void Log(LogLevel level, string message)
+        {
+            this.engine.Log(level, message);
+        }
+
+        public void Plan(LaunchAction action)
+        {
+            this.engine.Plan(action);
+        }
+
+        public void SetUpdate(string localSource, string downloadSource, long size, UpdateHashType hashType, byte[] hash)
+        {
+            this.engine.SetUpdate(localSource, downloadSource, size, hashType, hash, null == hash ? 0 : hash.Length);
+        }
+
+        public void SetLocalSource(string packageOrContainerId, string payloadId, string path)
+        {
+            this.engine.SetLocalSource(packageOrContainerId, payloadId, path);
+        }
+
+        public void SetDownloadSource(string packageOrContainerId, string payloadId, string url, string user, string password)
+        {
+            this.engine.SetDownloadSource(packageOrContainerId, payloadId, url, user, password);
+        }
+
+        public int SendEmbeddedError(int errorCode, string message, int uiHint)
+        {
+            int result = 0;
+            this.engine.SendEmbeddedError(errorCode, message, uiHint, out result);
+            return result;
+        }
+
+        public int SendEmbeddedProgress(int progressPercentage, int overallPercentage)
+        {
+            int result = 0;
+            this.engine.SendEmbeddedProgress(progressPercentage, overallPercentage, out result);
+            return result;
+        }
+
+        public void Quit(int exitCode)
+        {
+            this.engine.Quit(exitCode);
+        }
+
+        internal sealed class Variables<T> : IVariables<T>
+        {
+            // .NET 2.0 does not support Func<T, TResult> or Action<T1, T2>.
+            internal delegate T Getter<T>(string name);
+            internal delegate void Setter<T>(string name, T value);
+
+            private Getter<T> getter;
+            private Setter<T> setter;
+            private Predicate<string> contains;
+
+            internal Variables(Getter<T> getter, Setter<T> setter, Predicate<string> contains)
+            {
+                this.getter = getter;
+                this.setter = setter;
+                this.contains = contains;
+            }
+
+            public T this[string name]
+            {
+                get { return this.getter(name); }
+                set { this.setter(name, value); }
+            }
+
+            public bool Contains(string name)
+            {
+                return this.contains(name);
+            }
+        }
+
+        /// <summary>
+        /// Gets whether the variable given by <paramref name="name"/> exists.
+        /// </summary>
+        /// <param name="name">The name of the variable to check.</param>
+        /// <returns>True if the variable given by <paramref name="name"/> exists; otherwise, false.</returns>
+        internal bool containsVariable(string name)
+        {
+            int capacity = 0;
+            IntPtr pValue = IntPtr.Zero;
+            int ret = this.engine.GetVariableString(name, pValue, ref capacity);
+
+            return NativeMethods.E_NOTFOUND != ret;
+        }
+
+        /// <summary>
+        /// Gets the variable given by <paramref name="name"/> as a string.
+        /// </summary>
+        /// <param name="name">The name of the variable to get.</param>
+        /// <param name="length">The length of the Unicode string.</param>
+        /// <returns>The value by a pointer to a Unicode string.  Must be freed by Marshal.FreeCoTaskMem.</returns>
+        /// <exception cref="Exception">An error occurred getting the variable.</exception>
+        internal IntPtr getStringVariable(string name, out int length)
+        {
+            int capacity = InitialBufferSize;
+            bool success = false;
+            IntPtr pValue = Marshal.AllocCoTaskMem(capacity * UnicodeEncoding.CharSize);
+            try
+            {
+                // Get the size of the buffer.
+                int ret = this.engine.GetVariableString(name, pValue, ref capacity);
+                if (NativeMethods.E_INSUFFICIENT_BUFFER == ret || NativeMethods.E_MOREDATA == ret)
+                {
+                    // Don't need to add 1 for the null terminator, the engine already includes that.
+                    pValue = Marshal.ReAllocCoTaskMem(pValue, capacity * UnicodeEncoding.CharSize);
+                    ret = this.engine.GetVariableString(name, pValue, ref capacity);
+                }
+
+                if (NativeMethods.S_OK != ret)
+                {
+                    throw Marshal.GetExceptionForHR(ret);
+                }
+
+                // The engine only returns the exact length of the string if the buffer was too small, so calculate it ourselves.
+                for (length = 0; length < capacity; ++length)
+                {
+                    if(0 == Marshal.ReadInt16(pValue, length * UnicodeEncoding.CharSize))
+                    {
+                        break;
+                    }
+                }
+
+                success = true;
+                return pValue;
+            }
+            finally
+            {
+                if (!success && IntPtr.Zero != pValue)
+                {
+                    Marshal.FreeCoTaskMem(pValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initialize a SecureString with the given Unicode string.
+        /// </summary>
+        /// <param name="pUniString">Pointer to Unicode string.</param>
+        /// <param name="length">The string's length.</param>
+        internal SecureString convertToSecureString(IntPtr pUniString, int length)
+        {
+            if (IntPtr.Zero == pUniString)
+            {
+                return null;
+            }
+
+            SecureString value = new SecureString();
+            short s;
+            char c;
+            for (int charIndex = 0; charIndex < length; charIndex++)
+            {
+                s = Marshal.ReadInt16(pUniString, charIndex * UnicodeEncoding.CharSize);
+                c = (char)s;
+                value.AppendChar(c);
+                s = 0;
+                c = (char)0;
+            }
+            return value;
+        }
+
+        public static long VersionToLong(Version version)
+        {
+            // In Windows, each version component has a max value of 65535,
+            // so we truncate the version before shifting it, which will overflow if invalid.
+            long major = (long)(ushort)version.Major << 48;
+            long minor = (long)(ushort)version.Minor << 32;
+            long build = (long)(ushort)version.Build << 16;
+            long revision = (long)(ushort)version.Revision;
+
+            return major | minor | build | revision;
+        }
+
+        public static Version LongToVersion(long version)
+        {
+            int major = (int)((version & ((long)0xffff << 48)) >> 48);
+            int minor = (int)((version & ((long)0xffff << 32)) >> 32);
+            int build = (int)((version & ((long)0xffff << 16)) >> 16);
+            int revision = (int)(version & 0xffff);
+
+            return new Version(major, minor, build, revision);
+        }
+
+        /// <summary>
+        /// Verifies that VersionVariables can pass on the given Version to the engine.
+        /// If the Build or Revision fields are undefined, they are set to zero.
+        /// </summary>
+        public static Version NormalizeVersion(Version version)
+        {
+            if (version == null)
+            {
+                throw new ArgumentNullException("version");
+            }
+
+            int major = version.Major;
+            int minor = version.Minor;
+            int build = version.Build;
+            int revision = version.Revision;
+
+            if (major > UInt16.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException("version", String.Format(normalizeVersionFormatString, "Major"));
+            }
+            if (minor > UInt16.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException("version", String.Format(normalizeVersionFormatString, "Minor"));
+            }
+            if (build > UInt16.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException("version", String.Format(normalizeVersionFormatString, "Build"));
+            }
+            if (build == -1)
+            {
+                build = 0;
+            }
+            if (revision > UInt16.MaxValue)
+            {
+                throw new ArgumentOutOfRangeException("version", String.Format(normalizeVersionFormatString, "Revision"));
+            }
+            if (revision == -1)
+            {
+                revision = 0;
+            }
+
+            return new Version(major, minor, build, revision);
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/EventArgs.cs b/src/WixToolset.Mba.Core/EventArgs.cs
new file mode 100644
index 00000000..9e8e6ecc
--- /dev/null
+++ b/src/WixToolset.Mba.Core/EventArgs.cs
@@ -0,0 +1,1903 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.ObjectModel;
+
+    /// <summary>
+    /// Base class for BA <see cref="EventArgs"/> classes.
+    /// </summary>
+    [Serializable]
+    public abstract class HResultEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="HResultEventArgs"/> class.
+        /// </summary>
+        public HResultEventArgs()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="HResult"/> of the operation. This is passed back to the engine.
+        /// </summary>
+        public int HResult { get; set; }
+    }
+
+    /// <summary>
+    /// Base class for cancellable BA <see cref="EventArgs"/> classes.
+    /// </summary>
+    [Serializable]
+    public abstract class CancellableHResultEventArgs : HResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CancellableHResultEventArgs"/> class.
+        /// </summary>
+        public CancellableHResultEventArgs(bool cancelRecommendation)
+        {
+            this.Cancel = cancelRecommendation;
+        }
+
+        /// <summary>
+        /// Gets or sets whether to cancel the operation. This is passed back to the engine.
+        /// </summary>
+        public bool Cancel { get; set; }
+    }
+
+    /// <summary>
+    /// Base class for <see cref="EventArgs"/> classes that must return a <see cref="Result"/>.
+    /// </summary>
+    [Serializable]
+    public abstract class ResultEventArgs : HResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ResultEventArgs"/> class.
+        /// </summary>
+        /// <param name="recommendation">Recommended result from engine.</param>
+        /// <param name="result">The result to return to the engine.</param>
+        public ResultEventArgs(Result recommendation, Result result)
+        {
+            this.Recommendation = recommendation;
+            this.Result = result;
+        }
+
+        /// <summary>
+        /// Gets the recommended <see cref="Result"/> of the operation.
+        /// </summary>
+        public Result Recommendation { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Result"/> of the operation. This is passed back to the engine.
+        /// </summary>
+        public Result Result { get; set; }
+    }
+
+    /// <summary>
+    /// Base class for <see cref="EventArgs"/> classes that receive status from the engine.
+    /// </summary>
+    [Serializable]
+    public abstract class StatusEventArgs : HResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="StatusEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public StatusEventArgs(int hrStatus)
+        {
+            this.Status = hrStatus;
+        }
+
+        /// <summary>
+        /// Gets the return code of the operation.
+        /// </summary>
+        public int Status { get; private set; }
+    }
+
+    /// <summary>
+    /// Base class for <see cref="EventArgs"/> classes that receive status from the engine and return an action.
+    /// </summary>
+    public abstract class ActionEventArgs<T> : StatusEventArgs
+    {
+        /// <summary>
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="recommendation">Recommended action from engine.</param>
+        /// <param name="action">The action to perform.</param>
+        public ActionEventArgs(int hrStatus, T recommendation, T action)
+            : base(hrStatus)
+        {
+            this.Recommendation = recommendation;
+            this.Action = action;
+        }
+
+        /// <summary>
+        /// Gets the recommended action from the engine.
+        /// </summary>
+        public T Recommendation { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the action to be performed. This is passed back to the engine.
+        /// </summary>
+        public T Action { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when startup has begun.
+    /// </summary>
+    [Serializable]
+    public class StartupEventArgs : HResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="StartupEventArgs"/> class.
+        /// </summary>
+        public StartupEventArgs()
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when shutdown has begun.
+    /// </summary>
+    [Serializable]
+    public class ShutdownEventArgs : HResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ShutdownEventArgs"/> class.
+        /// </summary>
+        public ShutdownEventArgs(BOOTSTRAPPER_SHUTDOWN_ACTION action)
+        {
+            this.Action = action;
+        }
+
+        /// <summary>
+        /// The action for OnShutdown.
+        /// </summary>
+        public BOOTSTRAPPER_SHUTDOWN_ACTION Action { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the system is shutting down or the user is logging off.
+    /// </summary>
+    /// <remarks>
+    /// <para>To prevent shutting down or logging off, set <see cref="CancellableHResultEventArgs.Cancel"/> to
+    /// true; otherwise, set it to false.</para>
+    /// <para>By default setup will prevent shutting down or logging off between
+    /// <see cref="BootstrapperApplication.ApplyBegin"/> and <see cref="BootstrapperApplication.ApplyComplete"/>.</para>
+    /// <para>If <see cref="SystemShutdownEventArgs.Reasons"/> contains <see cref="EndSessionReasons.Critical"/>
+    /// the bootstrapper cannot prevent the shutdown and only has a few seconds to save state or perform any other
+    /// critical operations before being closed by the operating system.</para>
+    /// </remarks>
+    [Serializable]
+    public class SystemShutdownEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="SystemShutdownEventArgs"/> class.
+        /// </summary>
+        /// <param name="reasons">The reason the application is requested to close or being closed.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public SystemShutdownEventArgs(EndSessionReasons reasons, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.Reasons = reasons;
+        }
+
+        /// <summary>
+        /// Gets the reason the application is requested to close or being closed.
+        /// </summary>
+        /// <remarks>
+        /// <para>To prevent shutting down or logging off, set <see cref="CancellableHResultEventArgs.Cancel"/> to
+        /// true; otherwise, set it to false.</para>
+        /// <para>If <see cref="SystemShutdownEventArgs.Reasons"/> contains <see cref="EndSessionReasons.Critical"/>
+        /// the bootstrapper cannot prevent the shutdown and only has a few seconds to save state or perform any other
+        /// critical operations before being closed by the operating system.</para>
+        /// </remarks>
+        public EndSessionReasons Reasons { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the overall detection phase has begun.
+    /// </summary>
+    [Serializable]
+    public class DetectBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="installed">Specifies whether the bundle is installed.</param>
+        /// <param name="packageCount">The number of packages to detect.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectBeginEventArgs(bool installed, int packageCount, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.Installed = installed;
+            this.PackageCount = packageCount;
+        }
+
+        /// <summary>
+        /// Gets whether the bundle is installed.
+        /// </summary>
+        public bool Installed { get; private set; }
+
+        /// <summary>
+        /// Gets the number of packages to detect.
+        /// </summary>
+        public int PackageCount { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when detected a forward compatible bundle.
+    /// </summary>
+    [Serializable]
+    public class DetectForwardCompatibleBundleEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectUpdateBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="bundleId">The identity of the forward compatible bundle.</param>
+        /// <param name="relationType">Relationship type for this forward compatible bundle.</param>
+        /// <param name="bundleTag">The tag of the forward compatible bundle.</param>
+        /// <param name="perMachine">Whether the detected forward compatible bundle is per machine.</param>
+        /// <param name="version">The version of the forward compatible bundle detected.</param>
+        /// <param name="cancelRecommendation">The cancel recommendation from the engine.</param>
+        /// <param name="ignoreBundleRecommendation">The ignore recommendation from the engine.</param>
+        public DetectForwardCompatibleBundleEventArgs(string bundleId, RelationType relationType, string bundleTag, bool perMachine, long version, bool cancelRecommendation, bool ignoreBundleRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.BundleId = bundleId;
+            this.RelationType = relationType;
+            this.BundleTag = bundleTag;
+            this.PerMachine = perMachine;
+            this.Version = Engine.LongToVersion(version);
+            this.IgnoreBundle = ignoreBundleRecommendation;
+        }
+
+        /// <summary>
+        /// Gets the identity of the forward compatible bundle detected.
+        /// </summary>
+        public string BundleId { get; private set; }
+
+        /// <summary>
+        /// Gets the relationship type of the forward compatible bundle.
+        /// </summary>
+        public RelationType RelationType { get; private set; }
+
+        /// <summary>
+        /// Gets the tag of the forward compatible bundle.
+        /// </summary>
+        public string BundleTag { get; private set; }
+
+        /// <summary>
+        /// Gets whether the detected forward compatible bundle is per machine.
+        /// </summary>
+        public bool PerMachine { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the forward compatible bundle detected.
+        /// </summary>
+        public Version Version { get; private set; }
+
+        /// <summary>
+        /// Instructs the engine whether to use the forward compatible bundle.
+        /// </summary>
+        public bool IgnoreBundle { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection for an update has begun.
+    /// </summary>
+    [Serializable]
+    public class DetectUpdateBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectUpdateBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="updateLocation">The location to check for an updated bundle.</param>
+        /// <param name="cancelRecommendation">The cancel recommendation from the engine.</param>
+        /// <param name="skipRecommendation">The skip recommendation from the engine.</param>
+        public DetectUpdateBeginEventArgs(string updateLocation, bool cancelRecommendation, bool skipRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.UpdateLocation = updateLocation;
+        }
+
+        /// <summary>
+        /// Gets the identity of the bundle to detect.
+        /// </summary>
+        public string UpdateLocation { get; private set; }
+
+        /// <summary>
+        /// Whether to skip checking for bundle updates.
+        /// </summary>
+        public bool Skip { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection for an update has begun.
+    /// </summary>
+    [Serializable]
+    public class DetectUpdateEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectUpdateBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="updateLocation">The location to check for an updated bundle.</param>
+        /// <param name="size">The expected size of the updated bundle.</param>
+        /// <param name="version">The expected version of the updated bundle.</param>
+        /// <param name="title">The title of the updated bundle.</param>
+        /// <param name="summary">The summary of the updated bundle.</param>
+        /// <param name="contentType">The content type of the content of the updated bundle.</param>
+        /// <param name="content">The content of the updated bundle.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        /// <param name="stopRecommendation">The recommendation from the engine.</param>
+        public DetectUpdateEventArgs(string updateLocation, long size, long version, string title, string summary, string contentType, string content, bool cancelRecommendation, bool stopRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.UpdateLocation = updateLocation;
+            this.Size = size;
+            this.Version = Engine.LongToVersion(version);
+            this.Title = title;
+            this.Summary = summary;
+            this.ContentType = contentType;
+            this.Content = content;
+            this.StopProcessingUpdates = stopRecommendation;
+        }
+
+        /// <summary>
+        /// Gets the identity of the bundle to detect.
+        /// </summary>
+        public string UpdateLocation { get; private set; }
+
+        /// <summary>
+        /// Gets the size of the updated bundle.
+        /// </summary>
+        public long Size { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the updated bundle.
+        /// </summary>
+        public Version Version { get; private set; }
+
+        /// <summary>
+        /// Gets the title of the the updated bundle.
+        /// </summary>
+        public string Title { get; private set; }
+
+        /// <summary>
+        /// Gets the summary of the updated bundle.
+        /// </summary>
+        public string Summary { get; private set; }
+
+        /// <summary>
+        /// Gets the content type of the content of the updated bundle.
+        /// </summary>
+        public string ContentType { get; private set; }
+
+        /// <summary>
+        /// Gets the content of the updated bundle.
+        /// </summary>
+        public string Content { get; private set; }
+
+        /// <summary>
+        /// Tells the engine to stop giving the rest of the updates found in the feed.
+        /// </summary>
+        public bool StopProcessingUpdates { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection for an update has completed.
+    /// </summary>
+    [Serializable]
+    public class DetectUpdateCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectUpdateCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="ignoreRecommendation">The recommendation from the engine.</param>
+        public DetectUpdateCompleteEventArgs(int hrStatus, bool ignoreRecommendation)
+            : base(hrStatus)
+        {
+            this.IgnoreError = ignoreRecommendation;
+        }
+
+        /// <summary>
+        /// If Status is an error, then set this to true to ignore it and continue detecting.
+        /// </summary>
+        public bool IgnoreError { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when a related bundle has been detected for a bundle.
+    /// </summary>
+    [Serializable]
+    public class DetectRelatedBundleEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectRelatedBundleEventArgs"/> class.
+        /// </summary>
+        /// <param name="productCode">The identity of the related package bundle.</param>
+        /// <param name="relationType">Relationship type for this related bundle.</param>
+        /// <param name="bundleTag">The tag of the related package bundle.</param>
+        /// <param name="perMachine">Whether the detected bundle is per machine.</param>
+        /// <param name="version">The version of the related bundle detected.</param>
+        /// <param name="operation">The operation that will be taken on the detected bundle.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectRelatedBundleEventArgs(string productCode, RelationType relationType, string bundleTag, bool perMachine, long version, RelatedOperation operation, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.ProductCode = productCode;
+            this.RelationType = relationType;
+            this.BundleTag = bundleTag;
+            this.PerMachine = perMachine;
+            this.Version = Engine.LongToVersion(version);
+            this.Operation = operation;
+        }
+
+        /// <summary>
+        /// Gets the identity of the related bundle detected.
+        /// </summary>
+        public string ProductCode { get; private set; }
+
+        /// <summary>
+        /// Gets the relationship type of the related bundle.
+        /// </summary>
+        public RelationType RelationType { get; private set; }
+
+        /// <summary>
+        /// Gets the tag of the related package bundle.
+        /// </summary>
+        public string BundleTag { get; private set; }
+
+        /// <summary>
+        /// Gets whether the detected bundle is per machine.
+        /// </summary>
+        public bool PerMachine { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the related bundle detected.
+        /// </summary>
+        public Version Version { get; private set; }
+
+        /// <summary>
+        /// Gets the operation that will be taken on the detected bundle.
+        /// </summary>
+        public RelatedOperation Operation { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection for a specific package has begun.
+    /// </summary>
+    [Serializable]
+    public class DetectPackageBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectPackageBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package to detect.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectPackageBeginEventArgs(string packageId, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package to detect.
+        /// </summary>
+        public string PackageId { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when a package was not found but a newer package using the same provider key was.
+    /// </summary>
+    [Serializable]
+    public class DetectCompatibleMsiPackageEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectCompatibleMsiPackageEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that was not detected.</param>
+        /// <param name="compatiblePackageId">The identity of the compatible package that was detected.</param>
+        /// <param name="compatiblePackageVersion">The version of the compatible package that was detected.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectCompatibleMsiPackageEventArgs(string packageId, string compatiblePackageId, long compatiblePackageVersion, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.CompatiblePackageId = compatiblePackageId;
+            this.CompatiblePackageVersion = Engine.LongToVersion(compatiblePackageVersion);
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that was not detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the compatible package that was detected.
+        /// </summary>
+        public string CompatiblePackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the compatible package that was detected.
+        /// </summary>
+        public Version CompatiblePackageVersion { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when a related MSI package has been detected for a package.
+    /// </summary>
+    [Serializable]
+    public class DetectRelatedMsiPackageEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectRelatedMsiPackageEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package detecting.</param>
+        /// <param name="upgradeCode">The upgrade code of the related package detected.</param>
+        /// <param name="productCode">The identity of the related package detected.</param>
+        /// <param name="perMachine">Whether the detected package is per machine.</param>
+        /// <param name="version">The version of the related package detected.</param>
+        /// <param name="operation">The operation that will be taken on the detected package.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectRelatedMsiPackageEventArgs(string packageId, string upgradeCode, string productCode, bool perMachine, long version, RelatedOperation operation, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.UpgradeCode = upgradeCode;
+            this.ProductCode = productCode;
+            this.PerMachine = perMachine;
+            this.Version = Engine.LongToVersion(version);
+            this.Operation = operation;
+        }
+
+        /// <summary>
+        /// Gets the identity of the product's package detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the upgrade code of the related package detected.
+        /// </summary>
+        public string UpgradeCode { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the related package detected.
+        /// </summary>
+        public string ProductCode { get; private set; }
+
+        /// <summary>
+        /// Gets whether the detected package is per machine.
+        /// </summary>
+        public bool PerMachine { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the related package detected.
+        /// </summary>
+        public Version Version { get; private set; }
+
+        /// <summary>
+        /// Gets the operation that will be taken on the detected package.
+        /// </summary>
+        public RelatedOperation Operation { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when a target MSI package has been detected.
+    /// </summary>
+    public class DetectTargetMsiPackageEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectMsiFeatureEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">Detected package identifier.</param>
+        /// <param name="productCode">Detected product code.</param>
+        /// <param name="state">Package state detected.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectTargetMsiPackageEventArgs(string packageId, string productCode, PackageState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.ProductCode = productCode;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the target's package detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the product code of the target MSI detected.
+        /// </summary>
+        public string ProductCode { get; private set; }
+
+        /// <summary>
+        /// Gets the detected patch package state.
+        /// </summary>
+        public PackageState State { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when a feature in an MSI package has been detected.
+    /// </summary>
+    public class DetectMsiFeatureEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectMsiFeatureEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">Detected package identifier.</param>
+        /// <param name="featureId">Detected feature identifier.</param>
+        /// <param name="state">Feature state detected.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public DetectMsiFeatureEventArgs(string packageId, string featureId, FeatureState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.FeatureId = featureId;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the feature's package detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the feature detected.
+        /// </summary>
+        public string FeatureId { get; private set; }
+
+        /// <summary>
+        /// Gets the detected feature state.
+        /// </summary>
+        public FeatureState State { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection for a specific package has completed.
+    /// </summary>
+    [Serializable]
+    public class DetectPackageCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectPackageCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package detected.</param>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="state">The state of the specified package.</param>
+        public DetectPackageCompleteEventArgs(string packageId, int hrStatus, PackageState state)
+            : base(hrStatus)
+        {
+            this.PackageId = packageId;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the state of the specified package.
+        /// </summary>
+        public PackageState State { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the detection phase has completed.
+    /// </summary>
+    [Serializable]
+    public class DetectCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="DetectCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public DetectCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun planning the installation.
+    /// </summary>
+    [Serializable]
+    public class PlanBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageCount">The number of packages to plan for.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanBeginEventArgs(int packageCount, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageCount = packageCount;
+        }
+
+        /// <summary>
+        /// Gets the number of packages to plan for.
+        /// </summary>
+        public int PackageCount { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun planning for a related bundle.
+    /// </summary>
+    [Serializable]
+    public class PlanRelatedBundleEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanRelatedBundleEventArgs"/> class.
+        /// </summary>
+        /// <param name="bundleId">The identity of the bundle to plan for.</param>
+        /// <param name="recommendedState">The recommended requested state for the bundle.</param>
+        /// <param name="state">The requested state for the bundle.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanRelatedBundleEventArgs(string bundleId, RequestState recommendedState, RequestState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.BundleId = bundleId;
+            this.RecommendedState = recommendedState;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the bundle to plan for.
+        /// </summary>
+        public string BundleId { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended requested state for the bundle.
+        /// </summary>
+        public RequestState RecommendedState { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the requested state for the bundle.
+        /// </summary>
+        public RequestState State { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun planning the installation of a specific package.
+    /// </summary>
+    [Serializable]
+    public class PlanPackageBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanPackageBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package to plan for.</param>
+        /// <param name="recommendedState">The recommended requested state for the package.</param>
+        /// <param name="state">The requested state for the package.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanPackageBeginEventArgs(string packageId, RequestState recommendedState, RequestState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.RecommendedState = recommendedState;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package to plan for.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended requested state for the package.
+        /// </summary>
+        public RequestState RecommendedState { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the requested state for the package.
+        /// </summary>
+        public RequestState State { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine is about to plan a newer package using the same provider key.
+    /// </summary>
+    [Serializable]
+    public class PlanCompatibleMsiPackageBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanCompatibleMsiPackageBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that was not detected.</param>
+        /// <param name="compatiblePackageId">The identity of the compatible package that was detected.</param>
+        /// <param name="compatiblePackageVersion">The version of the compatible package that was detected.</param>
+        /// <param name="recommendedState">The recommended request state for the compatible package.</param>
+        /// <param name="state">The requested state for the compatible package.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanCompatibleMsiPackageBeginEventArgs(string packageId, string compatiblePackageId, long compatiblePackageVersion, RequestState recommendedState, RequestState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.CompatiblePackageId = compatiblePackageId;
+            this.CompatiblePackageVersion = Engine.LongToVersion(compatiblePackageVersion);
+            this.RecommendedState = recommendedState;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that was not detected.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the compatible package detected.
+        /// </summary>
+        public string CompatiblePackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the version of the compatible package detected.
+        /// </summary>
+        public Version CompatiblePackageVersion { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended state to use for the compatible package for planning.
+        /// </summary>
+        public RequestState RecommendedState { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the state to use for the compatible package for planning.
+        /// </summary>
+        public RequestState State { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed planning the installation of a specific package.
+    /// </summary>
+    [Serializable]
+    public class PlanCompatibleMsiPackageCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanCompatibleMsiPackageCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package planned for.</param>
+        /// <param name="compatiblePackageId">The identity of the compatible package that was detected.</param>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="state">The current state of the package.</param>
+        /// <param name="requested">The requested state for the package</param>
+        /// <param name="execute">The execution action to take.</param>
+        /// <param name="rollback">The rollback action to take.</param>
+        public PlanCompatibleMsiPackageCompleteEventArgs(string packageId, string compatiblePackageId, int hrStatus, PackageState state, RequestState requested, ActionState execute, ActionState rollback)
+            : base(hrStatus)
+        {
+            this.PackageId = packageId;
+            this.CompatiblePackageId = compatiblePackageId;
+            this.State = state;
+            this.Requested = requested;
+            this.Execute = execute;
+            this.Rollback = rollback;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package planned for.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the compatible package detected.
+        /// </summary>
+        public string CompatiblePackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the current state of the package.
+        /// </summary>
+        public PackageState State { get; private set; }
+
+        /// <summary>
+        /// Gets the requested state for the package.
+        /// </summary>
+        public RequestState Requested { get; private set; }
+
+        /// <summary>
+        /// Gets the execution action to take.
+        /// </summary>
+        public ActionState Execute { get; private set; }
+
+        /// <summary>
+        /// Gets the rollback action to take.
+        /// </summary>
+        public ActionState Rollback { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when engine is about to plan a MSP applied to a target MSI package.
+    /// </summary>
+    [Serializable]
+    public class PlanTargetMsiPackageEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanMsiFeatureEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">Package identifier of the patch being planned.</param>
+        /// <param name="productCode">Product code identifier being planned.</param>
+        /// <param name="recommendedState">Recommended package state of the patch being planned.</param>
+        /// <param name="state">Package state of the patch being planned.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanTargetMsiPackageEventArgs(string packageId, string productCode, RequestState recommendedState, RequestState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.ProductCode = productCode;
+            this.RecommendedState = recommendedState;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the patch package to plan.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the patch's target MSI to plan.
+        /// </summary>
+        public string ProductCode { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended state of the patch to use by planning.
+        /// </summary>
+        public RequestState RecommendedState { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the state of the patch to use by planning.
+        /// </summary>
+        public RequestState State { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when engine is about to plan a feature in an MSI package.
+    /// </summary>
+    [Serializable]
+    public class PlanMsiFeatureEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanMsiFeatureEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">Package identifier being planned.</param>
+        /// <param name="featureId">Feature identifier being planned.</param>
+        /// <param name="recommendedState">Recommended feature state being planned.</param>
+        /// <param name="state">Feature state being planned.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public PlanMsiFeatureEventArgs(string packageId, string featureId, FeatureState recommendedState, FeatureState state, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.FeatureId = featureId;
+            this.RecommendedState = recommendedState;
+            this.State = state;
+        }
+
+        /// <summary>
+        /// Gets the identity of the feature's package to plan.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the feature to plan.
+        /// </summary>
+        public string FeatureId { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended feature state to use by planning.
+        /// </summary>
+        public FeatureState RecommendedState { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the feature state to use by planning.
+        /// </summary>
+        public FeatureState State { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when then engine has completed planning the installation of a specific package.
+    /// </summary>
+    [Serializable]
+    public class PlanPackageCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanPackageCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package planned for.</param>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="state">The current state of the package.</param>
+        /// <param name="requested">The requested state for the package</param>
+        /// <param name="execute">The execution action to take.</param>
+        /// <param name="rollback">The rollback action to take.</param>
+        public PlanPackageCompleteEventArgs(string packageId, int hrStatus, PackageState state, RequestState requested, ActionState execute, ActionState rollback)
+            : base(hrStatus)
+        {
+            this.PackageId = packageId;
+            this.State = state;
+            this.Requested = requested;
+            this.Execute = execute;
+            this.Rollback = rollback;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package planned for.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the current state of the package.
+        /// </summary>
+        public PackageState State { get; private set; }
+
+        /// <summary>
+        /// Gets the requested state for the package.
+        /// </summary>
+        public RequestState Requested { get; private set; }
+
+        /// <summary>
+        /// Gets the execution action to take.
+        /// </summary>
+        public ActionState Execute { get; private set; }
+
+        /// <summary>
+        /// Gets the rollback action to take.
+        /// </summary>
+        public ActionState Rollback { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed planning the installation.
+    /// </summary>
+    [Serializable]
+    public class PlanCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="PlanCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public PlanCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun installing the bundle.
+    /// </summary>
+    [Serializable]
+    public class ApplyBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ApplyBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="phaseCount">The number of phases during apply.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ApplyBeginEventArgs(int phaseCount, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PhaseCount = phaseCount;
+        }
+
+        /// <summary>
+        /// Gets the number of phases that the engine will go through in apply.
+        /// There are currently two possible phases: cache and execute.
+        /// </summary>
+        public int PhaseCount { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine is about to start the elevated process.
+    /// </summary>
+    [Serializable]
+    public class ElevateBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ElevateBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ElevateBeginEventArgs(bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed starting the elevated process.
+    /// </summary>
+    [Serializable]
+    public class ElevateCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ElevateCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public ElevateCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has changed progress for the bundle installation.
+    /// </summary>
+    [Serializable]
+    public class ProgressEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates an new instance of the <see cref="ProgressEventArgs"/> class.
+        /// </summary>
+        /// <param name="progressPercentage">The percentage from 0 to 100 completed for a package.</param>
+        /// <param name="overallPercentage">The percentage from 0 to 100 completed for the bundle.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ProgressEventArgs(int progressPercentage, int overallPercentage, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.ProgressPercentage = progressPercentage;
+            this.OverallPercentage = overallPercentage;
+        }
+
+        /// <summary>
+        /// Gets the percentage from 0 to 100 completed for a package.
+        /// </summary>
+        public int ProgressPercentage { get; private set; }
+
+        /// <summary>
+        /// Gets the percentage from 0 to 100 completed for the bundle.
+        /// </summary>
+        public int OverallPercentage { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has encountered an error.
+    /// </summary>
+    [Serializable]
+    public class ErrorEventArgs : ResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ErrorEventArgs"/> class.
+        /// </summary>
+        /// <param name="errorType">The error type.</param>
+        /// <param name="packageId">The identity of the package that yielded the error.</param>
+        /// <param name="errorCode">The error code.</param>
+        /// <param name="errorMessage">The error message.</param>
+        /// <param name="dwUIHint">Recommended display flags for an error dialog.</param>
+        /// <param name="data">The exteded data for the error.</param>
+        /// <param name="recommendation">Recommended result from engine.</param>
+        /// <param name="result">The result to return to the engine.</param>
+        public ErrorEventArgs(ErrorType errorType, string packageId, int errorCode, string errorMessage, int dwUIHint, string[] data, Result recommendation, Result result)
+            : base(recommendation, result)
+        {
+            this.ErrorType = errorType;
+            this.PackageId = packageId;
+            this.ErrorCode = errorCode;
+            this.ErrorMessage = errorMessage;
+            this.UIHint = dwUIHint;
+            this.Data = new ReadOnlyCollection<string>(data ?? new string[] { });
+        }
+
+        /// <summary>
+        /// Gets the type of error that occurred.
+        /// </summary>
+        public ErrorType ErrorType { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the package that yielded the error.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the error code.
+        /// </summary>
+        public int ErrorCode { get; private set; }
+
+        /// <summary>
+        /// Gets the error message.
+        /// </summary>
+        public string ErrorMessage { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended display flags for an error dialog.
+        /// </summary>
+        public int UIHint { get; private set; }
+
+        /// <summary>
+        /// Gets the extended data for the error.
+        /// </summary>
+        public IList<string> Data { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun registering the location and visibility of the bundle.
+    /// </summary>
+    [Serializable]
+    public class RegisterBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="RegisterBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public RegisterBeginEventArgs(bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed registering the location and visilibity of the bundle.
+    /// </summary>
+    [Serializable]
+    public class RegisterCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="RegisterCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public RegisterCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun removing the registration for the location and visibility of the bundle.
+    /// </summary>
+    [Serializable]
+    public class UnregisterBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="UnregisterBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public UnregisterBeginEventArgs(bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed removing the registration for the location and visibility of the bundle.
+    /// </summary>
+    [Serializable]
+    public class UnregisterCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="UnregisterCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public UnregisterCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun caching the installation sources.
+    /// </summary>
+    [Serializable]
+    public class CacheBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public CacheBeginEventArgs(bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine begins to acquire containers or payloads.
+    /// </summary>
+    [Serializable]
+    public class CacheAcquireBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheAcquireBeginEventArgs"/> class.
+        /// </summary>
+        public CacheAcquireBeginEventArgs(string packageOrContainerId, string payloadId, CacheOperation operation, string source, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageOrContainerId = packageOrContainerId;
+            this.PayloadId = payloadId;
+            this.Operation = operation;
+            this.Source = source;
+        }
+
+        /// <summary>
+        /// Gets the identifier of the container or package.
+        /// </summary>
+        public string PackageOrContainerId { get; private set; }
+
+        /// <summary>
+        /// Gets the identifier of the payload (if acquiring a payload).
+        /// </summary>
+        public string PayloadId { get; private set; }
+
+        /// <summary>
+        /// Gets the cache acquire operation.
+        /// </summary>
+        public CacheOperation Operation { get; private set; }
+
+        /// <summary>
+        /// Gets the source of the container or payload.
+        /// </summary>
+        public string Source { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine acquires some part of a container or payload.
+    /// </summary>
+    [Serializable]
+    public class CacheAcquireProgressEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheAcquireBeginEventArgs"/> class.
+        /// </summary>
+        public CacheAcquireProgressEventArgs(string packageOrContainerId, string payloadId, long progress, long total, int overallPercentage, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageOrContainerId = packageOrContainerId;
+            this.PayloadId = payloadId;
+            this.Progress = progress;
+            this.Total = total;
+            this.OverallPercentage = overallPercentage;
+        }
+
+        /// <summary>
+        /// Gets the identifier of the container or package.
+        /// </summary>
+        public string PackageOrContainerId { get; private set; }
+
+        /// <summary>
+        /// Gets the identifier of the payload (if acquiring a payload).
+        /// </summary>
+        public string PayloadId { get; private set; }
+
+        /// <summary>
+        /// Gets the number of bytes cached thus far.
+        /// </summary>
+        public long Progress { get; private set; }
+
+        /// <summary>
+        /// Gets the total bytes to cache.
+        /// </summary>
+        public long Total { get; private set; }
+
+        /// <summary>
+        /// Gets the overall percentage of progress of caching.
+        /// </summary>
+        public int OverallPercentage { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine completes the acquisition of a container or payload.
+    /// </summary>
+    [Serializable]
+    public class CacheAcquireCompleteEventArgs : ActionEventArgs<BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION>
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheAcquireCompleteEventArgs"/> class.
+        /// </summary>
+        public CacheAcquireCompleteEventArgs(string packageOrContainerId, string payloadId, int hrStatus, BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION recommendation, BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION action)
+            : base(hrStatus, recommendation, action)
+        {
+            this.PackageOrContainerId = packageOrContainerId;
+            this.PayloadId = payloadId;
+        }
+
+        /// <summary>
+        /// Gets the identifier of the container or package.
+        /// </summary>
+        public string PackageOrContainerId { get; private set; }
+
+        /// <summary>
+        /// Gets the identifier of the payload (if acquiring a payload).
+        /// </summary>
+        public string PayloadId { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine starts the verification of a payload.
+    /// </summary>
+    [Serializable]
+    public class CacheVerifyBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheVerifyBeginEventArgs"/> class.
+        /// </summary>
+        public CacheVerifyBeginEventArgs(string packageId, string payloadId, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.PayloadId = payloadId;
+        }
+
+        /// <summary>
+        /// Gets the identifier of the package.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identifier of the payload.
+        /// </summary>
+        public string PayloadId { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine completes the verification of a payload.
+    /// </summary>
+    [Serializable]
+    public class CacheVerifyCompleteEventArgs : ActionEventArgs<BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION>
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheVerifyCompleteEventArgs"/> class.
+        /// </summary>
+        public CacheVerifyCompleteEventArgs(string packageId, string payloadId, int hrStatus, BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION recommendation, BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION action)
+            : base(hrStatus, recommendation, action)
+        {
+            this.PackageId = packageId;
+            this.PayloadId = payloadId;
+        }
+
+        /// <summary>
+        /// Gets the identifier of the package.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the identifier of the payload.
+        /// </summary>
+        public string PayloadId { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used after the engine has cached the installation sources.
+    /// </summary>
+    [Serializable]
+    public class CacheCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CacheCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public CacheCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun installing packages.
+    /// </summary>
+    [Serializable]
+    public class ExecuteBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecuteBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageCount">The number of packages to act on.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ExecuteBeginEventArgs(int packageCount, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageCount = packageCount;
+        }
+
+        /// <summary>
+        /// Gets the number of packages to act on.
+        /// </summary>
+        public int PackageCount { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has begun installing a specific package.
+    /// </summary>
+    [Serializable]
+    public class ExecutePackageBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecutePackageBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package to act on.</param>
+        /// <param name="shouldExecute">Whether the package should really be acted on.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ExecutePackageBeginEventArgs(string packageId, bool shouldExecute, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.ShouldExecute = shouldExecute;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package to act on.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets whether the package should really be acted on.
+        /// </summary>
+        public bool ShouldExecute { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine executes one or more patches targeting a product.
+    /// </summary>
+    [Serializable]
+    public class ExecutePatchTargetEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecutePatchTargetEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package to act on.</param>
+        /// <param name="targetProductCode">The product code of the target of the patch.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ExecutePatchTargetEventArgs(string packageId, string targetProductCode, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.TargetProductCode = targetProductCode;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package to act on.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the product code being targeted.
+        /// </summary>
+        public string TargetProductCode { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when Windows Installer sends an installation message.
+    /// </summary>
+    [Serializable]
+    public class ExecuteMsiMessageEventArgs : ResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecuteMsiMessageEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that yielded this message.</param>
+        /// <param name="messageType">The type of this message.</param>
+        /// <param name="dwUIHint">Recommended display flags for this message.</param>
+        /// <param name="message">The message.</param>
+        /// <param name="data">The extended data for the message.</param>
+        /// <param name="recommendation">Recommended result from engine.</param>
+        /// <param name="result">The result to return to the engine.</param>
+        public ExecuteMsiMessageEventArgs(string packageId, InstallMessage messageType, int dwUIHint, string message, string[] data, Result recommendation, Result result)
+            : base(recommendation, result)
+        {
+            this.PackageId = packageId;
+            this.MessageType = messageType;
+            this.UIHint = dwUIHint;
+            this.Message = message;
+            this.Data = new ReadOnlyCollection<string>(data ?? new string[] { });
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that yielded this message.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the type of this message.
+        /// </summary>
+        public InstallMessage MessageType { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended display flags for this message.
+        /// </summary>
+        public int UIHint { get; private set; }
+
+        /// <summary>
+        /// Gets the message.
+        /// </summary>
+        public string Message { get; private set; }
+
+        /// <summary>
+        /// Gets the extended data for the message.
+        /// </summary>
+        public IList<string> Data { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arugments used for file in use installation messages.
+    /// </summary>
+    [Serializable]
+    public class ExecuteFilesInUseEventArgs : ResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecuteFilesInUseEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that yielded the files in use message.</param>
+        /// <param name="files">The list of files in use.</param>
+        /// <param name="recommendation">Recommended result from engine.</param>
+        /// <param name="result">The result to return to the engine.</param>
+        public ExecuteFilesInUseEventArgs(string packageId, string[] files, Result recommendation, Result result)
+            : base(recommendation, result)
+        {
+            this.PackageId = packageId;
+            this.Files = new ReadOnlyCollection<string>(files ?? new string[] { });
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that yielded the files in use message.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the list of files in use.
+        /// </summary>
+        public IList<string> Files { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed installing a specific package.
+    /// </summary>
+    [Serializable]
+    public class ExecutePackageCompleteEventArgs : ActionEventArgs<BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION>
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecutePackageCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that was acted on.</param>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="restart">Whether a restart is required.</param>
+        /// <param name="recommendation">Recommended action from engine.</param>
+        /// <param name="action">The action to perform.</param>
+        public ExecutePackageCompleteEventArgs(string packageId, int hrStatus, ApplyRestart restart, BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION recommendation, BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION action)
+            : base(hrStatus, recommendation, action)
+        {
+            this.PackageId = packageId;
+            this.Restart = restart;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that was acted on.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the package restart state after being applied.
+        /// </summary>
+        public ApplyRestart Restart { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed installing packages.
+    /// </summary>
+    [Serializable]
+    public class ExecuteCompleteEventArgs : StatusEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecuteCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        public ExecuteCompleteEventArgs(int hrStatus)
+            : base(hrStatus)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments used when the engine has completed installing the bundle.
+    /// </summary>
+    [Serializable]
+    public class ApplyCompleteEventArgs : ActionEventArgs<BOOTSTRAPPER_APPLYCOMPLETE_ACTION>
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ApplyCompleteEventArgs"/> clas.
+        /// </summary>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="restart">Whether a restart is required.</param>
+        /// <param name="recommendation">Recommended action from engine.</param>
+        /// <param name="action">The action to perform.</param>
+        public ApplyCompleteEventArgs(int hrStatus, ApplyRestart restart, BOOTSTRAPPER_APPLYCOMPLETE_ACTION recommendation, BOOTSTRAPPER_APPLYCOMPLETE_ACTION action)
+            : base(hrStatus, recommendation, action)
+        {
+            this.Restart = restart;
+        }
+
+        /// <summary>
+        /// Gets the apply restart state when complete.
+        /// </summary>
+        public ApplyRestart Restart { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used by the engine to allow the BA to change the source
+    /// using <see cref="Engine.SetLocalSource"/> or <see cref="Engine.SetDownloadSource"/>.
+    /// </summary>
+    [Serializable]
+    public class ResolveSourceEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ResolveSourceEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageOrContainerId">The identity of the package or container that requires source.</param>
+        /// <param name="payloadId">The identity of the payload that requires source.</param>
+        /// <param name="localSource">The current path used for source resolution.</param>
+        /// <param name="downloadSource">Optional URL to download container or payload.</param>
+        /// <param name="recommendation">The recommended action from the engine.</param>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ResolveSourceEventArgs(string packageOrContainerId, string payloadId, string localSource, string downloadSource, BOOTSTRAPPER_RESOLVESOURCE_ACTION recommendation, BOOTSTRAPPER_RESOLVESOURCE_ACTION action, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageOrContainerId = packageOrContainerId;
+            this.PayloadId = payloadId;
+            this.LocalSource = localSource;
+            this.DownloadSource = downloadSource;
+            this.Recommendation = recommendation;
+            this.Action = action;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package or container that requires source.
+        /// </summary>
+        public string PackageOrContainerId { get; private set; }
+
+        /// <summary>
+        /// Gets the identity of the payload that requires source.
+        /// </summary>
+        public string PayloadId { get; private set; }
+
+        /// <summary>
+        /// Gets the current path used for source resolution.
+        /// </summary>
+        public string LocalSource { get; private set; }
+
+        /// <summary>
+        /// Gets the optional URL to download container or payload.
+        /// </summary>
+        public string DownloadSource { get; private set; }
+
+        /// <summary>
+        /// Gets the recommended action from the engine.
+        /// </summary>
+        public BOOTSTRAPPER_RESOLVESOURCE_ACTION Recommendation { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the action to perform.
+        /// </summary>
+        public BOOTSTRAPPER_RESOLVESOURCE_ACTION Action { get; set; }
+    }
+
+    /// <summary>
+    /// Additional arguments used by the engine when it has begun caching a specific package.
+    /// </summary>
+    [Serializable]
+    public class CachePackageBeginEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CachePackageBeginEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that is being cached.</param>
+        /// <param name="cachePayloads">Number of payloads to be cached.</param>
+        /// <param name="packageCacheSize">The size on disk required by the specific package.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public CachePackageBeginEventArgs(string packageId, int cachePayloads, long packageCacheSize, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.CachePayloads = cachePayloads;
+            this.PackageCacheSize = packageCacheSize;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that is being cached.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets number of payloads to be cached.
+        /// </summary>
+        public long CachePayloads { get; private set; }
+
+        /// <summary>
+        /// Gets the size on disk required by the specific package.
+        /// </summary>
+        public long PackageCacheSize { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments passed by the engine when it has completed caching a specific package.
+    /// </summary>
+    [Serializable]
+    public class CachePackageCompleteEventArgs : ActionEventArgs<BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION>
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="CachePackageCompleteEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identity of the package that was cached.</param>
+        /// <param name="hrStatus">The return code of the operation.</param>
+        /// <param name="recommendation">Recommended action from engine.</param>
+        /// <param name="action">The action to perform.</param>
+        public CachePackageCompleteEventArgs(string packageId, int hrStatus, BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION recommendation, BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION action)
+            : base(hrStatus, recommendation, action)
+        {
+            this.PackageId = packageId;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that was cached.
+        /// </summary>
+        public string PackageId { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments passed by the engine while executing on payload.
+    /// </summary>
+    [Serializable]
+    public class ExecuteProgressEventArgs : CancellableHResultEventArgs
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ExecuteProgressEventArgs"/> class.
+        /// </summary>
+        /// <param name="packageId">The identifier of the package being executed.</param>
+        /// <param name="progressPercentage">The percentage from 0 to 100 of the execution progress for a single payload.</param>
+        /// <param name="overallPercentage">The percentage from 0 to 100 of the execution progress for all payload.</param>
+        /// <param name="cancelRecommendation">The recommendation from the engine.</param>
+        public ExecuteProgressEventArgs(string packageId, int progressPercentage, int overallPercentage, bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+            this.PackageId = packageId;
+            this.ProgressPercentage = progressPercentage;
+            this.OverallPercentage = overallPercentage;
+        }
+
+        /// <summary>
+        /// Gets the identity of the package that was executed.
+        /// </summary>
+        public string PackageId { get; private set; }
+
+        /// <summary>
+        /// Gets the percentage from 0 to 100 of the execution progress for a single payload.
+        /// </summary>
+        public int ProgressPercentage { get; private set; }
+
+        /// <summary>
+        /// Gets the percentage from 0 to 100 of the execution progress for all payloads.
+        /// </summary>
+        public int OverallPercentage { get; private set; }
+    }
+
+    /// <summary>
+    /// Additional arguments passed by the engine before it tries to launch the preapproved executable.
+    /// </summary>
+    [Serializable]
+    public class LaunchApprovedExeBeginArgs : CancellableHResultEventArgs
+    {
+        public LaunchApprovedExeBeginArgs(bool cancelRecommendation)
+            : base(cancelRecommendation)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Additional arguments passed by the engine after it finished trying to launch the preapproved executable.
+    /// </summary>
+    [Serializable]
+    public class LaunchApprovedExeCompleteArgs : StatusEventArgs
+    {
+        private int processId;
+
+        public LaunchApprovedExeCompleteArgs(int hrStatus, int processId)
+            : base(hrStatus)
+        {
+            this.processId = processId;
+        }
+
+        /// <summary>
+        /// Gets the ProcessId of the process that was launched.
+        /// This is only valid if the status reports success.
+        /// </summary>
+        public int ProcessId
+        {
+            get { return this.processId; }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/Exceptions.cs b/src/WixToolset.Mba.Core/Exceptions.cs
new file mode 100644
index 00000000..360b360d
--- /dev/null
+++ b/src/WixToolset.Mba.Core/Exceptions.cs
@@ -0,0 +1,145 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Base class for exception returned to the bootstrapper application host.
+    /// </summary>
+    [Serializable]
+    public abstract class BootstrapperException : Exception
+    {
+        /// <summary>
+        /// Creates an instance of the <see cref="BootstrapperException"/> base class with the given HRESULT.
+        /// </summary>
+        /// <param name="hr">The HRESULT for the exception that is used by the bootstrapper application host.</param>
+        public BootstrapperException(int hr)
+        {
+            this.HResult = hr;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BootstrapperException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message.</param>
+        public BootstrapperException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BootstrapperException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message</param>
+        /// <param name="innerException">Inner exception associated with this one</param>
+        public BootstrapperException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BootstrapperException"/> class.
+        /// </summary>
+        /// <param name="info">Serialization information for this exception</param>
+        /// <param name="context">Streaming context to serialize to</param>
+        protected BootstrapperException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+
+    /// <summary>
+    /// The bootstrapper application assembly loaded by the host does not contain exactly one instance of the
+    /// <see cref="BootstrapperApplicationFactoryAttribute"/> class.
+    /// </summary>
+    /// <seealso cref="BootstrapperApplicationFactoryAttribute"/>
+    [Serializable]
+    public class MissingAttributeException : BootstrapperException
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="MissingAttributeException"/> class.
+        /// </summary>
+        public MissingAttributeException()
+            : base(NativeMethods.E_NOTFOUND)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MissingAttributeException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message.</param>
+        public MissingAttributeException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MissingAttributeException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message</param>
+        /// <param name="innerException">Inner exception associated with this one</param>
+        public MissingAttributeException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MissingAttributeException"/> class.
+        /// </summary>
+        /// <param name="info">Serialization information for this exception</param>
+        /// <param name="context">Streaming context to serialize to</param>
+        protected MissingAttributeException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+
+    /// <summary>
+    /// The bootstrapper application factory specified by the <see cref="BootstrapperApplicationFactoryAttribute"/>
+    ///  does not extend the <see cref="IBootstrapperApplicationFactory"/> base class.
+    /// </summary>
+    /// <seealso cref="BaseBootstrapperApplicationFactory"/>
+    /// <seealso cref="BootstrapperApplicationFactoryAttribute"/>
+    [Serializable]
+    public class InvalidBootstrapperApplicationFactoryException : BootstrapperException
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="InvalidBootstrapperApplicationFactoryException"/> class.
+        /// </summary>
+        public InvalidBootstrapperApplicationFactoryException()
+            : base(NativeMethods.E_UNEXPECTED)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidBootstrapperApplicationFactoryException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message.</param>
+        public InvalidBootstrapperApplicationFactoryException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidBootstrapperApplicationFactoryException"/> class.
+        /// </summary>
+        /// <param name="message">Exception message</param>
+        /// <param name="innerException">Inner exception associated with this one</param>
+        public InvalidBootstrapperApplicationFactoryException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InvalidBootstrapperApplicationFactoryException"/> class.
+        /// </summary>
+        /// <param name="info">Serialization information for this exception</param>
+        /// <param name="context">Streaming context to serialize to</param>
+        protected InvalidBootstrapperApplicationFactoryException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/HostSection.cs b/src/WixToolset.Mba.Core/HostSection.cs
new file mode 100644
index 00000000..e5b7ea64
--- /dev/null
+++ b/src/WixToolset.Mba.Core/HostSection.cs
@@ -0,0 +1,47 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Configuration;
+
+    /// <summary>
+    /// Handler for the Host configuration section.
+    /// </summary>
+    public sealed class HostSection : ConfigurationSection
+    {
+        private static readonly ConfigurationProperty assemblyNameProperty = new ConfigurationProperty("assemblyName", typeof(string), null, ConfigurationPropertyOptions.IsRequired);
+        private static readonly ConfigurationProperty supportedFrameworksProperty = new ConfigurationProperty("", typeof(SupportedFrameworkElementCollection), null, ConfigurationPropertyOptions.IsDefaultCollection);
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="HostSection"/> class.
+        /// </summary>
+        public HostSection()
+        {
+        }
+
+        /// <summary>
+        /// Gets the name of the assembly that contians the <see cref="BootstrapperApplication"/> child class.
+        /// </summary>
+        /// <remarks>
+        /// The assembly specified by this name must contain the <see cref="BootstrapperApplicationFactoryAttribute"/> to identify
+        /// the type of the <see cref="BootstrapperApplication"/> child class.
+        /// </remarks>
+        [ConfigurationProperty("assemblyName", IsRequired = true)]
+        public string AssemblyName
+        {
+            get { return (string)base[assemblyNameProperty]; }
+            set { base[assemblyNameProperty] = value; }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="SupportedFrameworkElementCollection"/> of supported frameworks for the host configuration.
+        /// </summary>
+        [ConfigurationProperty("", IsDefaultCollection = true)]
+        [ConfigurationCollection(typeof(SupportedFrameworkElement))]
+        public SupportedFrameworkElementCollection SupportedFrameworks
+        {
+            get { return (SupportedFrameworkElementCollection)base[supportedFrameworksProperty]; }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/IBootstrapperApplicationData.cs b/src/WixToolset.Mba.Core/IBootstrapperApplicationData.cs
new file mode 100644
index 00000000..c8c6e6e3
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IBootstrapperApplicationData.cs
@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System.IO;
+
+    public interface IBootstrapperApplicationData
+    {
+        FileInfo BADataFile { get; }
+        IBundleInfo Bundle { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Mba.Core/IBootstrapperApplicationFactory.cs b/src/WixToolset.Mba.Core/IBootstrapperApplicationFactory.cs
new file mode 100644
index 00000000..414d28ed
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IBootstrapperApplicationFactory.cs
@@ -0,0 +1,52 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Runtime.InteropServices;
+
+    [ComVisible(true)]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [Guid("2965A12F-AC7B-43A0-85DF-E4B2168478A4")]
+    [GeneratedCodeAttribute("WixToolset.Bootstrapper.InteropCodeGenerator", "1.0.0.0")]
+    public interface IBootstrapperApplicationFactory
+    {
+        IBootstrapperApplication Create(
+            [MarshalAs(UnmanagedType.Interface)] IBootstrapperEngine pEngine,
+            ref Command command
+            );
+    }
+
+    [Serializable]
+    [StructLayout(LayoutKind.Sequential)]
+    [GeneratedCodeAttribute("WixToolset.Bootstrapper.InteropCodeGenerator", "1.0.0.0")]
+    public struct Command
+    {
+        [MarshalAs(UnmanagedType.U4)] private readonly LaunchAction action;
+        [MarshalAs(UnmanagedType.U4)] private readonly Display display;
+        [MarshalAs(UnmanagedType.U4)] private readonly Restart restart;
+        [MarshalAs(UnmanagedType.LPWStr)] private readonly string wzCommandLine;
+        [MarshalAs(UnmanagedType.I4)] private readonly int nCmdShow;
+        [MarshalAs(UnmanagedType.U4)] private readonly ResumeType resume;
+        private readonly IntPtr hwndSplashScreen;
+        [MarshalAs(UnmanagedType.I4)] private readonly RelationType relation;
+        [MarshalAs(UnmanagedType.Bool)] private readonly bool passthrough;
+        [MarshalAs(UnmanagedType.LPWStr)] private readonly string wzLayoutDirectory;
+
+        public IBootstrapperCommand GetBootstrapperCommand()
+        {
+            return new BootstrapperCommand(
+                this.action,
+                this.display,
+                this.restart,
+                this.wzCommandLine,
+                this.nCmdShow,
+                this.resume,
+                this.hwndSplashScreen,
+                this.relation,
+                this.passthrough,
+                this.wzLayoutDirectory);
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/IBootstrapperCommand.cs b/src/WixToolset.Mba.Core/IBootstrapperCommand.cs
new file mode 100644
index 00000000..332b4c3b
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IBootstrapperCommand.cs
@@ -0,0 +1,63 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+
+    /// <summary>
+    /// Command information passed from the engine for the BA to perform.
+    /// </summary>
+    public interface IBootstrapperCommand
+    {
+        /// <summary>
+        /// Gets the action for the BA to perform.
+        /// </summary>
+        LaunchAction Action { get; }
+
+        /// <summary>
+        /// Gets the display level for the BA.
+        /// </summary>
+        Display Display { get; }
+
+        /// <summary>
+        /// Gets the action to perform if a reboot is required.
+        /// </summary>
+        Restart Restart { get; }
+
+        /// <summary>
+        /// Gets the command line arguments as a string array.
+        /// </summary>
+        /// <returns>
+        /// Array of command line arguments not handled by the engine.
+        /// </returns>
+        /// <exception type="Win32Exception">The command line could not be parsed into an array.</exception>
+        string[] CommandLineArgs { get; }
+
+        int CmdShow { get; }
+
+        /// <summary>
+        /// Gets the method of how the engine was resumed from a previous installation step.
+        /// </summary>
+        ResumeType Resume { get; }
+
+        /// <summary>
+        /// Gets the handle to the splash screen window. If no splash screen was displayed this value will be IntPtr.Zero.
+        /// </summary>
+        IntPtr SplashScreen { get; }
+
+        /// <summary>
+        /// If this was run from a related bundle, specifies the relation type.
+        /// </summary>
+        RelationType Relation { get; }
+
+        /// <summary>
+        /// If this was run from a backward compatible bundle.
+        /// </summary>
+        bool Passthrough { get; }
+
+        /// <summary>
+        /// Gets layout directory.
+        /// </summary>
+        string LayoutDirectory { get; }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/IBundleInfo.cs b/src/WixToolset.Mba.Core/IBundleInfo.cs
new file mode 100644
index 00000000..a5f4b9c7
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IBundleInfo.cs
@@ -0,0 +1,16 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System.Collections.Generic;
+
+    public interface IBundleInfo
+    {
+        string LogVariable { get; }
+        string Name { get; }
+        IDictionary<string, IPackageInfo> Packages { get; }
+        bool PerMachine { get; }
+
+        void AddRelatedBundleAsPackage(DetectRelatedBundleEventArgs e);
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Mba.Core/IDefaultBootstrapperApplication.cs b/src/WixToolset.Mba.Core/IDefaultBootstrapperApplication.cs
new file mode 100644
index 00000000..ccbe84db
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IDefaultBootstrapperApplication.cs
@@ -0,0 +1,65 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+
+    public interface IDefaultBootstrapperApplication : IBootstrapperApplication
+    {
+        event EventHandler<ApplyBeginEventArgs> ApplyBegin;
+        event EventHandler<ApplyCompleteEventArgs> ApplyComplete;
+        event EventHandler<CacheAcquireBeginEventArgs> CacheAcquireBegin;
+        event EventHandler<CacheAcquireCompleteEventArgs> CacheAcquireComplete;
+        event EventHandler<CacheAcquireProgressEventArgs> CacheAcquireProgress;
+        event EventHandler<CacheBeginEventArgs> CacheBegin;
+        event EventHandler<CacheCompleteEventArgs> CacheComplete;
+        event EventHandler<CachePackageBeginEventArgs> CachePackageBegin;
+        event EventHandler<CachePackageCompleteEventArgs> CachePackageComplete;
+        event EventHandler<CacheVerifyBeginEventArgs> CacheVerifyBegin;
+        event EventHandler<CacheVerifyCompleteEventArgs> CacheVerifyComplete;
+        event EventHandler<DetectBeginEventArgs> DetectBegin;
+        event EventHandler<DetectCompatibleMsiPackageEventArgs> DetectCompatibleMsiPackage;
+        event EventHandler<DetectCompleteEventArgs> DetectComplete;
+        event EventHandler<DetectForwardCompatibleBundleEventArgs> DetectForwardCompatibleBundle;
+        event EventHandler<DetectMsiFeatureEventArgs> DetectMsiFeature;
+        event EventHandler<DetectPackageBeginEventArgs> DetectPackageBegin;
+        event EventHandler<DetectPackageCompleteEventArgs> DetectPackageComplete;
+        event EventHandler<DetectRelatedBundleEventArgs> DetectRelatedBundle;
+        event EventHandler<DetectRelatedMsiPackageEventArgs> DetectRelatedMsiPackage;
+        event EventHandler<DetectTargetMsiPackageEventArgs> DetectTargetMsiPackage;
+        event EventHandler<DetectUpdateEventArgs> DetectUpdate;
+        event EventHandler<DetectUpdateBeginEventArgs> DetectUpdateBegin;
+        event EventHandler<DetectUpdateCompleteEventArgs> DetectUpdateComplete;
+        event EventHandler<ElevateBeginEventArgs> ElevateBegin;
+        event EventHandler<ElevateCompleteEventArgs> ElevateComplete;
+        event EventHandler<ErrorEventArgs> Error;
+        event EventHandler<ExecuteBeginEventArgs> ExecuteBegin;
+        event EventHandler<ExecuteCompleteEventArgs> ExecuteComplete;
+        event EventHandler<ExecuteFilesInUseEventArgs> ExecuteFilesInUse;
+        event EventHandler<ExecuteMsiMessageEventArgs> ExecuteMsiMessage;
+        event EventHandler<ExecutePackageBeginEventArgs> ExecutePackageBegin;
+        event EventHandler<ExecutePackageCompleteEventArgs> ExecutePackageComplete;
+        event EventHandler<ExecutePatchTargetEventArgs> ExecutePatchTarget;
+        event EventHandler<ExecuteProgressEventArgs> ExecuteProgress;
+        event EventHandler<LaunchApprovedExeBeginArgs> LaunchApprovedExeBegin;
+        event EventHandler<LaunchApprovedExeCompleteArgs> LaunchApprovedExeComplete;
+        event EventHandler<PlanBeginEventArgs> PlanBegin;
+        event EventHandler<PlanCompatibleMsiPackageBeginEventArgs> PlanCompatibleMsiPackageBegin;
+        event EventHandler<PlanCompatibleMsiPackageCompleteEventArgs> PlanCompatibleMsiPackageComplete;
+        event EventHandler<PlanCompleteEventArgs> PlanComplete;
+        event EventHandler<PlanMsiFeatureEventArgs> PlanMsiFeature;
+        event EventHandler<PlanPackageBeginEventArgs> PlanPackageBegin;
+        event EventHandler<PlanPackageCompleteEventArgs> PlanPackageComplete;
+        event EventHandler<PlanRelatedBundleEventArgs> PlanRelatedBundle;
+        event EventHandler<PlanTargetMsiPackageEventArgs> PlanTargetMsiPackage;
+        event EventHandler<ProgressEventArgs> Progress;
+        event EventHandler<RegisterBeginEventArgs> RegisterBegin;
+        event EventHandler<RegisterCompleteEventArgs> RegisterComplete;
+        event EventHandler<ResolveSourceEventArgs> ResolveSource;
+        event EventHandler<ShutdownEventArgs> Shutdown;
+        event EventHandler<StartupEventArgs> Startup;
+        event EventHandler<SystemShutdownEventArgs> SystemShutdown;
+        event EventHandler<UnregisterBeginEventArgs> UnregisterBegin;
+        event EventHandler<UnregisterCompleteEventArgs> UnregisterComplete;
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Mba.Core/IEngine.cs b/src/WixToolset.Mba.Core/IEngine.cs
new file mode 100644
index 00000000..46b8158a
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IEngine.cs
@@ -0,0 +1,176 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.ComponentModel;
+    using System.Security;
+
+    public interface IEngine
+    {
+        /// <summary>
+        /// Gets or sets numeric variables for the engine.
+        /// </summary>
+        IVariables<long> NumericVariables { get; }
+
+        /// <summary>
+        /// Gets the number of packages in the bundle.
+        /// </summary>
+        int PackageCount { get; }
+
+        /// <summary>
+        /// Gets or sets string variables for the engine using SecureStrings.
+        /// </summary>
+        IVariables<SecureString> SecureStringVariables { get; }
+
+        /// <summary>
+        /// Gets or sets string variables for the engine.
+        /// </summary>
+        IVariables<string> StringVariables { get; }
+
+        /// <summary>
+        /// Gets or sets <see cref="Version"/> variables for the engine.
+        /// 
+        /// The <see cref="Version"/> class can keep track of when the build and revision fields are undefined, but the engine can't.
+        /// Therefore, the build and revision fields must be defined when setting a <see cref="Version"/> variable.
+        /// Use the NormalizeVersion method to make sure the engine can accept the Version.
+        /// 
+        /// To keep track of versions without build or revision fields, use StringVariables instead.
+        /// </summary>
+        /// <exception cref="OverflowException">The given <see cref="Version"/> was invalid.</exception>
+        IVariables<Version> VersionVariables { get; }
+
+        /// <summary>
+        /// Install the packages.
+        /// </summary>
+        /// <param name="hwndParent">The parent window for the installation user interface.</param>
+        void Apply(IntPtr hwndParent);
+
+        /// <summary>
+        /// Close the splash screen if it is still open. Does nothing if the splash screen is not or
+        /// never was opened.
+        /// </summary>
+        void CloseSplashScreen();
+
+        /// <summary>
+        /// Determine if all installation conditions are fulfilled.
+        /// </summary>
+        void Detect();
+
+        /// <summary>
+        /// Determine if all installation conditions are fulfilled.
+        /// </summary>
+        /// <param name="hwndParent">The parent window for the installation user interface.</param>
+        void Detect(IntPtr hwndParent);
+
+        /// <summary>
+        /// Elevate the install.
+        /// </summary>
+        /// <param name="hwndParent">The parent window of the elevation dialog.</param>
+        /// <returns>true if elevation succeeded; otherwise, false if the user cancelled.</returns>
+        /// <exception cref="Win32Exception">A Win32 error occurred.</exception>
+        bool Elevate(IntPtr hwndParent);
+
+        /// <summary>
+        /// Escapes the input string.
+        /// </summary>
+        /// <param name="input">The string to escape.</param>
+        /// <returns>The escaped string.</returns>
+        /// <exception cref="Win32Exception">A Win32 error occurred.</exception>
+        string EscapeString(string input);
+
+        /// <summary>
+        /// Evaluates the <paramref name="condition"/> string.
+        /// </summary>
+        /// <param name="condition">The string representing the condition to evaluate.</param>
+        /// <returns>Whether the condition evaluated to true or false.</returns>
+        bool EvaluateCondition(string condition);
+
+        /// <summary>
+        /// Formats the input string.
+        /// </summary>
+        /// <param name="format">The string to format.</param>
+        /// <returns>The formatted string.</returns>
+        /// <exception cref="Win32Exception">A Win32 error occurred.</exception>
+        string FormatString(string format);
+
+        /// <summary>
+        /// Launches a preapproved executable elevated.  As long as the engine already elevated, there will be no UAC prompt.
+        /// </summary>
+        /// <param name="hwndParent">The parent window of the elevation dialog (if the engine hasn't elevated yet).</param>
+        /// <param name="approvedExeForElevationId">Id of the ApprovedExeForElevation element specified when the bundle was authored.</param>
+        /// <param name="arguments">Optional arguments.</param>
+        void LaunchApprovedExe(IntPtr hwndParent, string approvedExeForElevationId, string arguments);
+
+        /// <summary>
+        /// Launches a preapproved executable elevated.  As long as the engine already elevated, there will be no UAC prompt.
+        /// </summary>
+        /// <param name="hwndParent">The parent window of the elevation dialog (if the engine hasn't elevated yet).</param>
+        /// <param name="approvedExeForElevationId">Id of the ApprovedExeForElevation element specified when the bundle was authored.</param>
+        /// <param name="arguments">Optional arguments.</param>
+        /// <param name="waitForInputIdleTimeout">Timeout in milliseconds. When set to something other than zero, the engine will call WaitForInputIdle for the new process with this timeout before calling OnLaunchApprovedExeComplete.</param>
+        void LaunchApprovedExe(IntPtr hwndParent, string approvedExeForElevationId, string arguments, int waitForInputIdleTimeout);
+
+        /// <summary>
+        /// Logs the <paramref name="message"/>.
+        /// </summary>
+        /// <param name="level">The logging level.</param>
+        /// <param name="message">The message to log.</param>
+        void Log(LogLevel level, string message);
+
+        /// <summary>
+        /// Determine the installation sequencing and costing.
+        /// </summary>
+        /// <param name="action">The action to perform when planning.</param>
+        void Plan(LaunchAction action);
+
+        /// <summary>
+        /// Set the update information for a bundle.
+        /// </summary>
+        /// <param name="localSource">Optional local source path for the update. Default is "update\[OriginalNameOfBundle].exe".</param>
+        /// <param name="downloadSource">Optional download source for the update.</param>
+        /// <param name="size">Size of the expected update.</param>
+        /// <param name="hashType">Type of the hash expected on the update.</param>
+        /// <param name="hash">Optional hash expected for the update.</param>
+        void SetUpdate(string localSource, string downloadSource, long size, UpdateHashType hashType, byte[] hash);
+
+        /// <summary>
+        /// Set the local source for a package or container.
+        /// </summary>
+        /// <param name="packageOrContainerId">The id that uniquely identifies the package or container.</param>
+        /// <param name="payloadId">The id that uniquely identifies the payload.</param>
+        /// <param name="path">The new source path.</param>
+        void SetLocalSource(string packageOrContainerId, string payloadId, string path);
+
+        /// <summary>
+        /// Set the new download URL for a package or container.
+        /// </summary>
+        /// <param name="packageOrContainerId">The id that uniquely identifies the package or container.</param>
+        /// <param name="payloadId">The id that uniquely identifies the payload.</param>
+        /// <param name="url">The new url.</param>
+        /// <param name="user">The user name for proxy authentication.</param>
+        /// <param name="password">The password for proxy authentication.</param>
+        void SetDownloadSource(string packageOrContainerId, string payloadId, string url, string user, string password);
+
+        /// <summary>
+        /// Sends error message when embedded.
+        /// </summary>
+        /// <param name="errorCode">Error code.</param>
+        /// <param name="message">Error message.</param>
+        /// <param name="uiHint">UI buttons to show on error dialog.</param>
+        int SendEmbeddedError(int errorCode, string message, int uiHint);
+
+        /// <summary>
+        /// Sends progress percentages when embedded.
+        /// </summary>
+        /// <param name="progressPercentage">Percentage completed thus far.</param>
+        /// <param name="overallPercentage">Overall percentage completed.</param>
+        int SendEmbeddedProgress(int progressPercentage, int overallPercentage);
+
+        /// <summary>
+        /// Shuts down the engine.
+        /// </summary>
+        /// <param name="exitCode">Exit code indicating reason for shut down.</param>
+        void Quit(int exitCode);
+    }
+}
diff --git a/src/WixToolset.Mba.Core/IPackageInfo.cs b/src/WixToolset.Mba.Core/IPackageInfo.cs
new file mode 100644
index 00000000..f4c7c558
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IPackageInfo.cs
@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    public interface IPackageInfo
+    {
+        CacheType CacheType { get; }
+        string Description { get; }
+        bool DisplayInternalUI { get; }
+        string DisplayName { get; }
+        string Id { get; }
+        string InstallCondition { get; }
+        bool Permanent { get; }
+        string ProductCode { get; }
+        PackageType Type { get; }
+        string UpgradeCode { get; }
+        string Version { get; }
+        bool Vital { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/WixToolset.Mba.Core/IVariables.cs b/src/WixToolset.Mba.Core/IVariables.cs
new file mode 100644
index 00000000..15da4c84
--- /dev/null
+++ b/src/WixToolset.Mba.Core/IVariables.cs
@@ -0,0 +1,27 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+
+    /// <summary>
+    /// An accessor for numeric, string, and version variables for the engine.
+    /// </summary>
+    public interface IVariables<T>
+    {
+        /// <summary>
+        /// Gets or sets the variable given by <paramref name="name"/>.
+        /// </summary>
+        /// <param name="name">The name of the variable to get/set.</param>
+        /// <returns>The value of the given variable.</returns>
+        /// <exception cref="Exception">An error occurred getting the variable.</exception>
+        T this[string name] { get; set; }
+
+        /// <summary>
+        /// Gets whether the variable given by <paramref name="name"/> exists.
+        /// </summary>
+        /// <param name="name">The name of the variable to check.</param>
+        /// <returns>True if the variable given by <paramref name="name"/> exists; otherwise, false.</returns>
+        bool Contains(string name);
+    }
+}
diff --git a/src/WixToolset.Mba.Core/NativeMethods.cs b/src/WixToolset.Mba.Core/NativeMethods.cs
new file mode 100644
index 00000000..1964cb45
--- /dev/null
+++ b/src/WixToolset.Mba.Core/NativeMethods.cs
@@ -0,0 +1,37 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Contains native constants, functions, and structures for this assembly.
+    /// </summary>
+    internal static class NativeMethods
+    {
+        #region Error Constants
+        internal const int S_OK = 0;
+        internal const int E_MOREDATA = unchecked((int)0x800700ea);
+        internal const int E_INSUFFICIENT_BUFFER = unchecked((int)0x8007007a);
+        internal const int E_CANCELLED = unchecked((int)0x800704c7);
+        internal const int E_ALREADYINITIALIZED = unchecked((int)0x800704df);
+        internal const int E_NOTFOUND = unchecked((int)0x80070490);
+        internal const int E_NOTIMPL = unchecked((int)0x80004001);
+        internal const int E_UNEXPECTED = unchecked((int)0x8000ffff);
+        #endregion
+
+        #region Functions
+        [DllImport("shell32.dll", ExactSpelling = true, SetLastError = true)]
+        internal static extern IntPtr CommandLineToArgvW(
+            [MarshalAs(UnmanagedType.LPWStr)] string lpCmdLine,
+            out int pNumArgs
+            );
+
+        [DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
+        internal static extern IntPtr LocalFree(
+            IntPtr hMem
+            );
+        #endregion
+    }
+}
diff --git a/src/WixToolset.Mba.Core/PackageInfo.cs b/src/WixToolset.Mba.Core/PackageInfo.cs
new file mode 100644
index 00000000..99ebb33a
--- /dev/null
+++ b/src/WixToolset.Mba.Core/PackageInfo.cs
@@ -0,0 +1,181 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml;
+    using System.Xml.XPath;
+
+    public enum CacheType
+    {
+        No,
+        Yes,
+        Always,
+    }
+
+    public enum PackageType
+    {
+        Unknown,
+        Exe,
+        Msi,
+        Msp,
+        Msu,
+        UpgradeBundle,
+        AddonBundle,
+        PatchBundle,
+    }
+
+    public class PackageInfo : IPackageInfo
+    {
+        public string Id { get; internal set; }
+        public string DisplayName { get; internal set; }
+        public string Description { get; internal set; }
+        public PackageType Type { get; internal set; }
+        public bool Permanent { get; internal set; }
+        public bool Vital { get; internal set; }
+        public bool DisplayInternalUI { get; internal set; }
+        public string ProductCode { get; internal set; }
+        public string UpgradeCode { get; internal set; }
+        public string Version { get; internal set; }
+        public string InstallCondition { get; internal set; }
+        public CacheType CacheType { get; internal set; }
+
+        internal PackageInfo() { }
+
+        public static IEnumerable<IPackageInfo> ParsePackagesFromXml(XPathNavigator root)
+        {
+            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(root.NameTable);
+            namespaceManager.AddNamespace("p", BootstrapperApplicationData.XMLNamespace);
+            XPathNodeIterator nodes = root.Select("/p:BootstrapperApplicationData/p:WixPackageProperties", namespaceManager);
+
+            foreach (XPathNavigator node in nodes)
+            {
+                var package = new PackageInfo();
+
+                string id = BootstrapperApplicationData.GetAttribute(node, "Package");
+                if (id == null)
+                {
+                    throw new Exception("Failed to get package identifier for package.");
+                }
+                package.Id = id;
+
+                package.DisplayName = BootstrapperApplicationData.GetAttribute(node, "DisplayName");
+
+                package.Description = BootstrapperApplicationData.GetAttribute(node, "Description");
+
+                PackageType? packageType = GetPackageTypeAttribute(node, "PackageType");
+                if (!packageType.HasValue)
+                {
+                    throw new Exception("Failed to get package type for package.");
+                }
+                package.Type = packageType.Value;
+
+                bool? permanent = BootstrapperApplicationData.GetYesNoAttribute(node, "Permanent");
+                if (!permanent.HasValue)
+                {
+                    throw new Exception("Failed to get permanent settings for package.");
+                }
+                package.Permanent = permanent.Value;
+
+                bool? vital = BootstrapperApplicationData.GetYesNoAttribute(node, "Vital");
+                if (!vital.HasValue)
+                {
+                    throw new Exception("Failed to get vital setting for package.");
+                }
+                package.Vital = vital.Value;
+
+                bool? displayInternalUI = BootstrapperApplicationData.GetYesNoAttribute(node, "DisplayInternalUI");
+                package.DisplayInternalUI = displayInternalUI.HasValue && displayInternalUI.Value;
+
+                package.ProductCode = BootstrapperApplicationData.GetAttribute(node, "ProductCode");
+
+                package.UpgradeCode = BootstrapperApplicationData.GetAttribute(node, "UpgradeCode");
+
+                package.Version = BootstrapperApplicationData.GetAttribute(node, "Version");
+
+                package.InstallCondition = BootstrapperApplicationData.GetAttribute(node, "InstallCondition");
+
+                yield return package;
+            }
+        }
+
+        public static CacheType? GetCacheTypeAttribute(XPathNavigator node, string attributeName)
+        {
+            string attributeValue = BootstrapperApplicationData.GetAttribute(node, attributeName);
+
+            if (attributeValue == null)
+            {
+                return null;
+            }
+
+            if (attributeValue.Equals("yes", StringComparison.InvariantCulture))
+            {
+                return CacheType.Yes;
+            }
+            else if (attributeValue.Equals("always", StringComparison.InvariantCulture))
+            {
+                return CacheType.Always;
+            }
+            else
+            {
+                return CacheType.No;
+            }
+        }
+
+        public static PackageType? GetPackageTypeAttribute(XPathNavigator node, string attributeName)
+        {
+            string attributeValue = BootstrapperApplicationData.GetAttribute(node, attributeName);
+
+            if (attributeValue == null)
+            {
+                return null;
+            }
+
+            if (attributeValue.Equals("Exe", StringComparison.InvariantCulture))
+            {
+                return PackageType.Exe;
+            }
+            else if (attributeValue.Equals("Msi", StringComparison.InvariantCulture))
+            {
+                return PackageType.Msi;
+            }
+            else if (attributeValue.Equals("Msp", StringComparison.InvariantCulture))
+            {
+                return PackageType.Msp;
+            }
+            else if (attributeValue.Equals("Msu", StringComparison.InvariantCulture))
+            {
+                return PackageType.Msu;
+            }
+            else
+            {
+                return PackageType.Unknown;
+            }
+        }
+
+        public static PackageInfo GetRelatedBundleAsPackage(string id, RelationType relationType, bool perMachine, Version version)
+        {
+            PackageInfo package = new PackageInfo();
+            package.Id = id;
+            package.Version = version.ToString();
+
+            switch (relationType)
+            {
+                case RelationType.Addon:
+                    package.Type = PackageType.AddonBundle;
+                    break;
+                case RelationType.Patch:
+                    package.Type = PackageType.PatchBundle;
+                    break;
+                case RelationType.Upgrade:
+                    package.Type = PackageType.UpgradeBundle;
+                    break;
+                default:
+                    throw new Exception(string.Format("Unknown related bundle type: {0}", relationType));
+            }
+
+            return package;
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/SupportedFrameworkElement.cs b/src/WixToolset.Mba.Core/SupportedFrameworkElement.cs
new file mode 100644
index 00000000..37a31b69
--- /dev/null
+++ b/src/WixToolset.Mba.Core/SupportedFrameworkElement.cs
@@ -0,0 +1,47 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Configuration;
+
+    /// <summary>
+    /// Handler for the supportedFramework configuration section.
+    /// </summary>
+    public sealed class SupportedFrameworkElement : ConfigurationElement
+    {
+        private static readonly ConfigurationProperty versionProperty = new ConfigurationProperty("version", typeof(string), null, ConfigurationPropertyOptions.IsRequired);
+        private static readonly ConfigurationProperty runtimeVersionProperty = new ConfigurationProperty("runtimeVersion", typeof(string));
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="SupportedFrameworkElement"/> class.
+        /// </summary>
+        public SupportedFrameworkElement()
+        {
+        }
+
+        /// <summary>
+        /// Gets the version of the supported framework.
+        /// </summary>
+        /// <remarks>
+        /// The assembly specified by this name must contain a value matching the NETFX version registry key under
+        /// "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP".
+        /// </remarks>
+        [ConfigurationProperty("version", IsRequired = true)]
+        public string Version
+        {
+            get { return (string)base[versionProperty]; }
+            set { base[versionProperty] = value; }
+        }
+
+        /// <summary>
+        /// Gets the runtime version required by this supported framework.
+        /// </summary>
+        [ConfigurationProperty("runtimeVersion", IsRequired = false)]
+        public string RuntimeVersion
+        {
+            get { return (string)base[runtimeVersionProperty]; }
+            set { base[runtimeVersionProperty] = value; }
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/SupportedFrameworkElementCollection.cs b/src/WixToolset.Mba.Core/SupportedFrameworkElementCollection.cs
new file mode 100644
index 00000000..1a5aa2de
--- /dev/null
+++ b/src/WixToolset.Mba.Core/SupportedFrameworkElementCollection.cs
@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.BootstrapperCore
+{
+    using System;
+    using System.Configuration;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Handler for the supportedFramework collection.
+    /// </summary>
+    [SuppressMessage("Microsoft.Design", "CA1010:CollectionsShouldImplementGenericInterface")]
+    [ConfigurationCollection(typeof(SupportedFrameworkElement), AddItemName = "supportedFramework", CollectionType = ConfigurationElementCollectionType.BasicMap)]
+    public sealed class SupportedFrameworkElementCollection : ConfigurationElementCollection
+    {
+        public override ConfigurationElementCollectionType CollectionType
+        {
+            get { return ConfigurationElementCollectionType.BasicMap; }
+        }
+
+        protected override string ElementName
+        {
+            get { return "supportedFramework"; }
+        }
+
+        protected override ConfigurationElement CreateNewElement()
+        {
+            return new SupportedFrameworkElement();
+        }
+
+        protected override object GetElementKey(ConfigurationElement element)
+        {
+            return (element as SupportedFrameworkElement).Version;
+        }
+    }
+}
diff --git a/src/WixToolset.Mba.Core/WixToolset.BootstrapperCore.config b/src/WixToolset.Mba.Core/WixToolset.BootstrapperCore.config
new file mode 100644
index 00000000..1e284001
--- /dev/null
+++ b/src/WixToolset.Mba.Core/WixToolset.BootstrapperCore.config
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+
+<configuration>
+    <configSections>
+        <sectionGroup name="wix.bootstrapper" type="WixToolset.BootstrapperCore.BootstrapperSectionGroup, WixToolset.BootstrapperCore">
+            <section name="host" type="WixToolset.BootstrapperCore.HostSection, WixToolset.BootstrapperCore" />
+        </sectionGroup>
+    </configSections>
+    <startup useLegacyV2RuntimeActivationPolicy="true">
+        <supportedRuntime version="v4.0" />
+        <supportedRuntime version="v2.0.50727" />
+    </startup>
+    <wix.bootstrapper>
+        <!-- Example only. Use only if the startup/supportedRuntime above cannot discern supported frameworks. -->
+        <!--
+        <supportedFramework version="v4\Client" />
+        <supportedFramework version="v3.5" />
+        <supportedFramework version="v3.0" />
+        -->
+
+        <!-- Example only. Replace the host/@assemblyName attribute with assembly that implements BootstrapperApplication. -->
+        <host assemblyName="AssemblyWithClassThatInheritsFromBootstrapperApplication" />
+    </wix.bootstrapper>
+</configuration>
diff --git a/src/balutil/inc/IBootstrapperApplicationFactory.h b/src/balutil/inc/IBootstrapperApplicationFactory.h
new file mode 100644
index 00000000..e29c23bc
--- /dev/null
+++ b/src/balutil/inc/IBootstrapperApplicationFactory.h
@@ -0,0 +1,14 @@
+#pragma once
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+
+#include "precomp.h"
+
+DECLARE_INTERFACE_IID_(IBootstrapperApplicationFactory, IUnknown, "2965A12F-AC7B-43A0-85DF-E4B2168478A4")
+{
+    STDMETHOD(Create)(
+        __in IBootstrapperEngine* pEngine,
+        __in const BOOTSTRAPPER_COMMAND *pCommand,
+        __out IBootstrapperApplication **ppApplication
+        );
+};