Migrate PInvoke to Core.Native out of Core

17 files changed, 2199 insertions, 0 deletions

diff --git a/src/WixToolset.Core.Native/Msi/Database.cs b/src/WixToolset.Core.Native/Msi/Database.cs
new file mode 100644
index 00000000..a44e8cf9
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/Database.cs
@@ -0,0 +1,257 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.Globalization;
+    using System.IO;
+    using System.Threading;
+
+    /// <summary>
+    /// Wrapper class for managing MSI API database handles.
+    /// </summary>
+    public sealed class Database : MsiHandle
+    {
+        private const int STG_E_LOCKVIOLATION = unchecked((int)0x80030021);
+
+        /// <summary>
+        /// Constructor that opens an MSI database.
+        /// </summary>
+        /// <param name="path">Path to the database to be opened.</param>
+        /// <param name="type">Persist mode to use when opening the database.</param>
+        public Database(string path, OpenDatabase type)
+        {
+            var error = MsiInterop.MsiOpenDatabase(path, new IntPtr((int)type), out var handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Maximum length of stream in an MSI database.
+        /// </summary>
+        public static int MsiMaxStreamNameLength => MsiInterop.MsiMaxStreamNameLength;
+
+        /// <summary>
+        /// Apply a transform to the MSI.
+        /// </summary>
+        /// <param name="transformFile">Path to transform to apply.</param>
+        public void ApplyTransform(string transformFile)
+        {
+            // get the curret validation bits
+            var conditions = TransformErrorConditions.None;
+            using (var summaryInfo = new SummaryInformation(transformFile))
+            {
+                var value = summaryInfo.GetProperty((int)SummaryInformation.Transform.ValidationFlags);
+                try
+                {
+                    var validationFlags = Int32.Parse(value, CultureInfo.InvariantCulture);
+                    conditions = (TransformErrorConditions)(validationFlags & 0xffff);
+                }
+                catch (FormatException)
+                {
+                    // fallback to default of None
+                }
+            }
+
+            this.ApplyTransform(transformFile, conditions);
+        }
+
+        /// <summary>
+        /// Applies a transform to this database.
+        /// </summary>
+        /// <param name="transformFile">Path to the transform file being applied.</param>
+        /// <param name="errorConditions">Specifies the error conditions that are to be suppressed.</param>
+        public void ApplyTransform(string transformFile, TransformErrorConditions errorConditions)
+        {
+            var error = MsiInterop.MsiDatabaseApplyTransform(this.Handle, transformFile, errorConditions);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Commits changes made to the database.
+        /// </summary>
+        public void Commit()
+        {
+            // Retry this call 3 times to deal with an MSI internal locking problem.
+            const int retryWait = 300;
+            const int retryLimit = 3;
+            var error = 0;
+
+            for (var i = 1; i <= retryLimit; ++i)
+            {
+                error = MsiInterop.MsiDatabaseCommit(this.Handle);
+
+                if (0 == error)
+                {
+                    return;
+                }
+                else
+                {
+                    var exception = new MsiException(error);
+
+                    // We need to see if the error code is contained in any of the strings in ErrorInfo.
+                    // Join the array together and search for the error code to cover the string array.
+                    if (!String.Join(", ", exception.ErrorInfo).Contains(STG_E_LOCKVIOLATION.ToString()))
+                    {
+                        break;
+                    }
+
+                    Console.Error.WriteLine(String.Format("Failed to create the database. Info: {0}. Retrying ({1} of {2})", String.Join(", ", exception.ErrorInfo), i, retryLimit));
+                    Thread.Sleep(retryWait);
+                }
+            }
+
+            throw new MsiException(error);
+        }
+
+        /// <summary>
+        /// Creates and populates the summary information stream of an existing transform file.
+        /// </summary>
+        /// <param name="referenceDatabase">Required database that does not include the changes.</param>
+        /// <param name="transformFile">The name of the generated transform file.</param>
+        /// <param name="errorConditions">Required error conditions that should be suppressed when the transform is applied.</param>
+        /// <param name="validations">Required when the transform is applied to a database;
+        /// shows which properties should be validated to verify that this transform can be applied to the database.</param>
+        public void CreateTransformSummaryInfo(Database referenceDatabase, string transformFile, TransformErrorConditions errorConditions, TransformValidations validations)
+        {
+            var error = MsiInterop.MsiCreateTransformSummaryInfo(this.Handle, referenceDatabase.Handle, transformFile, errorConditions, validations);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Imports an installer text archive table (idt file) into an open database.
+        /// </summary>
+        /// <param name="idtPath">Specifies the path to the file to import.</param>
+        /// <exception cref="WixInvalidIdtException">Attempted to import an IDT file with an invalid format or unsupported data.</exception>
+        /// <exception cref="MsiException">Another error occured while importing the IDT file.</exception>
+        public void Import(string idtPath)
+        {
+            var folderPath = Path.GetFullPath(Path.GetDirectoryName(idtPath));
+            var fileName = Path.GetFileName(idtPath);
+
+            var error = MsiInterop.MsiDatabaseImport(this.Handle, folderPath, fileName);
+            if (1627 == error) // ERROR_FUNCTION_FAILED
+            {
+                throw new WixInvalidIdtException(idtPath);
+            }
+            else if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Exports an installer table from an open database to a text archive file (idt file).
+        /// </summary>
+        /// <param name="tableName">Specifies the name of the table to export.</param>
+        /// <param name="folderPath">Specifies the name of the folder that contains archive files. If null or empty string, uses current directory.</param>
+        /// <param name="fileName">Specifies the name of the exported table archive file.</param>
+        public void Export(string tableName, string folderPath, string fileName)
+        {
+            if (String.IsNullOrEmpty(folderPath))
+            {
+                folderPath = Environment.CurrentDirectory;
+            }
+
+            var error = MsiInterop.MsiDatabaseExport(this.Handle, tableName, folderPath, fileName);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Creates a transform that, when applied to the reference database, results in this database.
+        /// </summary>
+        /// <param name="referenceDatabase">Required database that does not include the changes.</param>
+        /// <param name="transformFile">The name of the generated transform file. This is optional.</param>
+        /// <returns>true if a transform is generated; false if a transform is not generated because
+        /// there are no differences between the two databases.</returns>
+        public bool GenerateTransform(Database referenceDatabase, string transformFile)
+        {
+            var error = MsiInterop.MsiDatabaseGenerateTransform(this.Handle, referenceDatabase.Handle, transformFile, 0, 0);
+            if (0 != error && 0xE8 != error) // ERROR_NO_DATA(0xE8) means no differences were found
+            {
+                throw new MsiException(error);
+            }
+
+            return (0xE8 != error);
+        }
+
+        /// <summary>
+        /// Merges two databases together.
+        /// </summary>
+        /// <param name="mergeDatabase">The database to merge into the base database.</param>
+        /// <param name="tableName">The name of the table to receive merge conflict information.</param>
+        public void Merge(Database mergeDatabase, string tableName)
+        {
+            var error = MsiInterop.MsiDatabaseMerge(this.Handle, mergeDatabase.Handle, tableName);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Prepares a database query and creates a <see cref="View">View</see> object.
+        /// </summary>
+        /// <param name="query">Specifies a SQL query string for querying the database.</param>
+        /// <returns>A view object is returned if the query was successful.</returns>
+        public View OpenView(string query)
+        {
+            return new View(this, query);
+        }
+
+        /// <summary>
+        /// Prepares and executes a database query and creates a <see cref="View">View</see> object.
+        /// </summary>
+        /// <param name="query">Specifies a SQL query string for querying the database.</param>
+        /// <returns>A view object is returned if the query was successful.</returns>
+        public View OpenExecuteView(string query)
+        {
+            var view = new View(this, query);
+
+            view.Execute();
+            return view;
+        }
+
+        /// <summary>
+        /// Verifies the existence or absence of a table.
+        /// </summary>
+        /// <param name="tableName">Table name to to verify the existence of.</param>
+        /// <returns>Returns true if the table exists, false if it does not.</returns>
+        public bool TableExists(string tableName)
+        {
+            var result = MsiInterop.MsiDatabaseIsTablePersistent(this.Handle, tableName);
+            return MsiInterop.MSICONDITIONTRUE == result;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Record">Record</see> containing the names of all the primary 
+        /// key columns for a specified table.
+        /// </summary>
+        /// <param name="tableName">Specifies the name of the table from which to obtain 
+        /// primary key names.</param>
+        /// <returns>Returns a <see cref="Record">Record</see> containing the names of all the 
+        /// primary key columns for a specified table.</returns>
+        public Record PrimaryKeys(string tableName)
+        {
+            var error = MsiInterop.MsiDatabaseGetPrimaryKeys(this.Handle, tableName, out var recordHandle);
+            if (error != 0)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/InstallLogModes.cs b/src/WixToolset.Core.Native/Msi/InstallLogModes.cs
new file mode 100644
index 00000000..f7012b35
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/InstallLogModes.cs
@@ -0,0 +1,111 @@
+// 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.Core.Native.Msi
+{
+    using System;
+
+    /// <summary>
+    /// Windows Installer log modes.
+    /// </summary>
+    [Flags]
+    public enum InstallLogModes
+    {
+        /// <summary>
+        /// Premature termination of installation.
+        /// </summary>
+        FatalExit = (1 << ((int)InstallMessage.FatalExit >> 24)),
+
+        /// <summary>
+        /// The error messages are logged.
+        /// </summary>
+        Error = (1 << ((int)InstallMessage.Error >> 24)),
+
+        /// <summary>
+        /// The warning messages are logged.
+        /// </summary>
+        Warning = (1 << ((int)InstallMessage.Warning >> 24)),
+
+        /// <summary>
+        /// The user requests are logged.
+        /// </summary>
+        User = (1 << ((int)InstallMessage.User >> 24)),
+
+        /// <summary>
+        /// The status messages that are not displayed are logged.
+        /// </summary>
+        Info = (1 << ((int)InstallMessage.Info >> 24)),
+
+        /// <summary>
+        /// Request to determine a valid source location.
+        /// </summary>
+        ResolveSource = (1 << ((int)InstallMessage.ResolveSource >> 24)),
+
+        /// <summary>
+        /// The was insufficient disk space.
+        /// </summary>
+        OutOfDiskSpace = (1 << ((int)InstallMessage.OutOfDiskSpace >> 24)),
+
+        /// <summary>
+        /// The start of new installation actions are logged.
+        /// </summary>
+        ActionStart = (1 << ((int)InstallMessage.ActionStart >> 24)),
+
+        /// <summary>
+        /// The data record with the installation action is logged.
+        /// </summary>
+        ActionData = (1 << ((int)InstallMessage.ActionData >> 24)),
+
+        /// <summary>
+        /// The parameters for user-interface initialization are logged.
+        /// </summary>
+        CommonData = (1 << ((int)InstallMessage.CommonData >> 24)),
+
+        /// <summary>
+        /// Logs the property values at termination.
+        /// </summary>
+        PropertyDump = (1 << ((int)InstallMessage.Progress >> 24)),
+
+        /// <summary>
+        /// Sends large amounts of information to a log file not generally useful to users.
+        /// May be used for technical support.
+        /// </summary>
+        Verbose = (1 << ((int)InstallMessage.Initilize >> 24)),
+
+        /// <summary>
+        /// Sends extra debugging information, such as handle creation information, to the log file.
+        /// </summary>
+        ExtraDebug = (1 << ((int)InstallMessage.Terminate >> 24)),
+
+        /// <summary>
+        /// Progress bar information. This message includes information on units so far and total number of units.
+        /// See MsiProcessMessage for an explanation of the message format.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Progress = (1 << ((int)InstallMessage.Progress >> 24)),
+
+        /// <summary>
+        /// If this is not a quiet installation, then the basic UI has been initialized.
+        /// If this is a full UI installation, the full UI is not yet initialized.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Initialize = (1 << ((int)InstallMessage.Initilize >> 24)),
+
+        /// <summary>
+        /// If a full UI is being used, the full UI has ended.
+        /// If this is not a quiet installation, the basic UI has not yet ended.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Terminate = (1 << ((int)InstallMessage.Terminate >> 24)),
+
+        /// <summary>
+        /// Sent prior to display of the full UI dialog.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        ShowDialog = (1 << ((int)InstallMessage.ShowDialog >> 24)),
+
+        /// <summary>
+        /// Files in use information. When this message is received, a FilesInUse Dialog should be displayed.
+        /// </summary>
+        FilesInUse = (1 << ((int)InstallMessage.FilesInUse >> 24))
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/InstallMessage.cs b/src/WixToolset.Core.Native/Msi/InstallMessage.cs
new file mode 100644
index 00000000..35773e13
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/InstallMessage.cs
@@ -0,0 +1,88 @@
+// 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.Core.Native.Msi
+{
+    using System;
+
+    /// <summary>
+    /// Windows Installer message types.
+    /// </summary>
+    [Flags]
+    public enum InstallMessage
+    {
+        /// <summary>
+        /// Premature termination, possibly fatal out of memory.
+        /// </summary>
+        FatalExit = 0x00000000,
+
+        /// <summary>
+        /// Formatted error message, [1] is message number in Error table.
+        /// </summary>
+        Error = 0x01000000,
+
+        /// <summary>
+        /// Formatted warning message, [1] is message number in Error table.
+        /// </summary>
+        Warning = 0x02000000,
+
+        /// <summary>
+        /// User request message, [1] is message number in Error table.
+        /// </summary>
+        User = 0x03000000,
+
+        /// <summary>
+        /// Informative message for log, not to be displayed.
+        /// </summary>
+        Info = 0x04000000,
+
+        /// <summary>
+        /// List of files in use that need to be replaced.
+        /// </summary>
+        FilesInUse = 0x05000000,
+
+        /// <summary>
+        /// Request to determine a valid source location.
+        /// </summary>
+        ResolveSource = 0x06000000,
+
+        /// <summary>
+        /// Insufficient disk space message.
+        /// </summary>
+        OutOfDiskSpace = 0x07000000,
+
+        /// <summary>
+        /// Progress: start of action, [1] action name, [2] description, [3] template for ACTIONDATA messages.
+        /// </summary>
+        ActionStart = 0x08000000,
+
+        /// <summary>
+        /// Action data. Record fields correspond to the template of ACTIONSTART message.
+        /// </summary>
+        ActionData = 0x09000000,
+
+        /// <summary>
+        /// Progress bar information. See the description of record fields below.
+        /// </summary>
+        Progress = 0x0A000000,
+
+        /// <summary>
+        /// To enable the Cancel button set [1] to 2 and [2] to 1. To disable the Cancel button set [1] to 2 and [2] to 0.
+        /// </summary>
+        CommonData = 0x0B000000,
+
+        /// <summary>
+        /// Sent prior to UI initialization, no string data.
+        /// </summary>
+        Initilize = 0x0C000000,
+
+        /// <summary>
+        /// Sent after UI termination, no string data.
+        /// </summary>
+        Terminate = 0x0D000000,
+
+        /// <summary>
+        /// Sent prior to display or authored dialog or wizard.
+        /// </summary>
+        ShowDialog = 0x0E000000
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/InstallUILevels.cs b/src/WixToolset.Core.Native/Msi/InstallUILevels.cs
new file mode 100644
index 00000000..e84b5215
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/InstallUILevels.cs
@@ -0,0 +1,72 @@
+// 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.Core.Native.Msi
+{
+    using System;
+
+    /// <summary>
+    /// Windows Installer UI levels.
+    /// </summary>
+    [Flags]
+    public enum InstallUILevels
+    {
+        /// <summary>
+        /// No change in the UI level. However, if phWnd is not Null, the parent window can change.
+        /// </summary>
+        NoChange = 0,
+
+        /// <summary>
+        /// The installer chooses an appropriate user interface level.
+        /// </summary>
+        Default = 1,
+
+        /// <summary>
+        /// Completely silent installation.
+        /// </summary>
+        None = 2,
+
+        /// <summary>
+        /// Simple progress and error handling.
+        /// </summary>
+        Basic = 3,
+
+        /// <summary>
+        /// Authored user interface with wizard dialog boxes suppressed.
+        /// </summary>
+        Reduced = 4,
+
+        /// <summary>
+        /// Authored user interface with wizards, progress, and errors.
+        /// </summary>
+        Full = 5,
+
+        /// <summary>
+        /// If combined with the Basic value, the installer shows simple progress dialog boxes but
+        /// does not display a Cancel button on the dialog. This prevents users from canceling the install.
+        /// Available with Windows Installer version 2.0.
+        /// </summary>
+        HideCancel = 0x20,
+
+        /// <summary>
+        /// If combined with the Basic value, the installer shows simple progress
+        /// dialog boxes but does not display any modal dialog boxes or error dialog boxes.
+        /// </summary>
+        ProgressOnly = 0x40,
+
+        /// <summary>
+        /// If combined with any above value, the installer displays a modal dialog
+        /// box at the end of a successful installation or if there has been an error.
+        /// No dialog box is displayed if the user cancels.
+        /// </summary>
+        EndDialog = 0x80,
+
+        /// <summary>
+        /// If this value is combined with the None value, the installer displays only the dialog
+        /// boxes used for source resolution. No other dialog boxes are shown. This value has no
+        /// effect if the UI level is not INSTALLUILEVEL_NONE. It is used with an external user
+        /// interface designed to handle all of the UI except for source resolution. In this case,
+        /// the installer handles source resolution. This value is only available with Windows Installer 2.0 and later.
+        /// </summary>
+        SourceResOnly = 0x100
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/Installer.cs b/src/WixToolset.Core.Native/Msi/Installer.cs
new file mode 100644
index 00000000..2bb41078
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/Installer.cs
@@ -0,0 +1,113 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.Diagnostics;
+    using System.Text;
+
+    /// <summary>
+    /// A callback function that the installer calls for progress notification and error messages.
+    /// </summary>
+    /// <param name="context">Pointer to an application context.
+    /// This parameter can be used for error checking.</param>
+    /// <param name="messageType">Specifies a combination of one message box style,
+    /// one message box icon type, one default button, and one installation message type.</param>
+    /// <param name="message">Specifies the message text.</param>
+    /// <returns>-1 for an error, 0 if no action was taken, 1 if OK, 3 to abort.</returns>
+    public delegate int InstallUIHandler(IntPtr context, uint messageType, string message);
+
+    /// <summary>
+    /// Represents the Windows Installer, provides wrappers to
+    /// create the top-level objects and access their methods.
+    /// </summary>
+    public static class Installer
+    {
+        /// <summary>
+        /// Takes the path to a file and returns a 128-bit hash of that file.
+        /// </summary>
+        /// <param name="filePath">Path to file that is to be hashed.</param>
+        /// <param name="options">The value in this column must be 0. This parameter is reserved for future use.</param>
+        /// <param name="hash">Int array that receives the returned file hash information.</param>
+        public static void GetFileHash(string filePath, int options, out int[] hash)
+        {
+            var hashInterop = new MSIFILEHASHINFO();
+            hashInterop.FileHashInfoSize = 20;
+
+            var error = MsiInterop.MsiGetFileHash(filePath, Convert.ToUInt32(options), hashInterop);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            Debug.Assert(20 == hashInterop.FileHashInfoSize);
+
+            hash = new int[4];
+            hash[0] = hashInterop.Data0;
+            hash[1] = hashInterop.Data1;
+            hash[2] = hashInterop.Data2;
+            hash[3] = hashInterop.Data3;
+        }
+
+        /// <summary>
+        /// Returns the version string and language string in the format that the installer 
+        /// expects to find them in the database.  If you just want version information, set 
+        /// lpLangBuf and pcchLangBuf to zero. If you just want language information, set 
+        /// lpVersionBuf and pcchVersionBuf to zero.
+        /// </summary>
+        /// <param name="filePath">Specifies the path to the file.</param>
+        /// <param name="version">Returns the file version. Set to 0 for language information only.</param>
+        /// <param name="language">Returns the file language. Set to 0 for version information only.</param>
+        public static void GetFileVersion(string filePath, out string version, out string language)
+        {
+            var versionLength = 20;
+            var languageLength = 20;
+            var versionBuffer = new StringBuilder(versionLength);
+            var languageBuffer = new StringBuilder(languageLength);
+
+            var error = MsiInterop.MsiGetFileVersion(filePath, versionBuffer, ref versionLength, languageBuffer, ref languageLength);
+            if (234 == error)
+            {
+                versionBuffer.EnsureCapacity(++versionLength);
+                languageBuffer.EnsureCapacity(++languageLength);
+                error = MsiInterop.MsiGetFileVersion(filePath, versionBuffer, ref versionLength, languageBuffer, ref languageLength);
+            }
+            else if (1006 == error)
+            {
+                // file has no version or language, so no error
+                error = 0;
+            }
+
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            version = versionBuffer.ToString();
+            language = languageBuffer.ToString();
+        }
+
+        /// <summary>
+        /// Enables an external user-interface handler.
+        /// </summary>
+        /// <param name="installUIHandler">Specifies a callback function.</param>
+        /// <param name="messageFilter">Specifies which messages to handle using the external message handler.</param>
+        /// <param name="context">Pointer to an application context that is passed to the callback function.</param>
+        /// <returns>The return value is the previously set external handler, or null if there was no previously set handler.</returns>
+        public static InstallUIHandler SetExternalUI(InstallUIHandler installUIHandler, int messageFilter, IntPtr context)
+        {
+            return MsiInterop.MsiSetExternalUI(installUIHandler, messageFilter, context);
+        }
+
+        /// <summary>
+        /// Enables the installer's internal user interface.
+        /// </summary>
+        /// <param name="uiLevel">Specifies the level of complexity of the user interface.</param>
+        /// <param name="hwnd">Pointer to a window. This window becomes the owner of any user interface created.</param>
+        /// <returns>The previous user interface level is returned. If an invalid dwUILevel is passed, then INSTALLUILEVEL_NOCHANGE is returned.</returns>
+        public static int SetInternalUI(int uiLevel, ref IntPtr hwnd)
+        {
+            return MsiInterop.MsiSetInternalUI(uiLevel, ref hwnd);
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/ModifyView.cs b/src/WixToolset.Core.Native/Msi/ModifyView.cs
new file mode 100644
index 00000000..989de174
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/ModifyView.cs
@@ -0,0 +1,75 @@
+// 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.Core.Native.Msi
+{
+    /// <summary>
+    /// Enumeration of different modify modes.
+    /// </summary>
+    public enum ModifyView
+    {
+        /// <summary>
+        /// Writes current data in the cursor to a table row. Updates record if the primary 
+        /// keys match an existing row and inserts if they do not match. Fails with a read-only 
+        /// database. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Assign = 3,   // Writes current data in the cursor to a table row. Updates record if the primary keys match an existing row and inserts if they do not match. Fails with a read-only database. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Remove a row from the table. You must first call the Fetch function with the same
+        /// record. Fails if the row has been deleted. Works only with read-write records. This
+        /// mode cannot be used with a view containing joins.
+        /// </summary>
+        Delete = 6,   // Remove a row from the table. You must first call the MsiViewFetch function with the same record. Fails if the row has been deleted. Works only with read-write records. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Inserts a record. Fails if a row with the same primary keys exists. Fails with a read-only
+        /// database. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Insert = 1,   // Inserts a record. Fails if a row with the same primary keys exists. Fails with a read-only database. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Inserts a temporary record. The information is not persistent. Fails if a row with the 
+        /// same primary key exists. Works only with read-write records. This mode cannot be 
+        /// used with a view containing joins.
+        /// </summary>
+        InsertTemporary = 7,   // Inserts a temporary record. The information is not persistent. Fails if a row with the same primary key exists. Works only with read-write records. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Inserts or validates a record in a table. Inserts if primary keys do not match any row
+        /// and validates if there is a match. Fails if the record does not match the data in
+        /// the table. Fails if there is a record with a duplicate key that is not identical.
+        /// Works only with read-write records. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Merge = 5,   // Inserts or validates a record in a table. Inserts if primary keys do not match any row and validates if there is a match. Fails if the record does not match the data in the table. Fails if there is a record with a duplicate key that is not identical. Works only with read-write records. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Refreshes the information in the record. Must first call Fetch with the
+        /// same record. Fails for a deleted row. Works with read-write and read-only records.
+        /// </summary>
+        Refresh = 0,   // Refreshes the information in the record. Must first call MsiViewFetch with the same record. Fails for a deleted row. Works with read-write and read-only records.
+
+        /// <summary>
+        /// Updates or deletes and inserts a record into a table. Must first call Fetch with
+        /// the same record. Updates record if the primary keys are unchanged. Deletes old row and
+        /// inserts new if primary keys have changed. Fails with a read-only database. This mode cannot
+        /// be used with a view containing joins.
+        /// </summary>
+        Replace = 4,   // Updates or deletes and inserts a record into a table. Must first call MsiViewFetch with the same record. Updates record if the primary keys are unchanged. Deletes old row and inserts new if primary keys have changed. Fails with a read-only database. This mode cannot be used with a view containing joins.
+
+        /// <summary>
+        /// Refreshes the information in the supplied record without changing the position in the
+        /// result set and without affecting subsequent fetch operations. The record may then
+        /// be used for subsequent Update, Delete, and Refresh. All primary key columns of the
+        /// table must be in the query and the record must have at least as many fields as the
+        /// query. Seek cannot be used with multi-table queries. This mode cannot be used with
+        /// a view containing joins. See also the remarks.
+        /// </summary>
+        Seek = -1,   // Refreshes the information in the supplied record without changing the position in the result set and without affecting subsequent fetch operations. The record may then be used for subsequent Update, Delete, and Refresh. All primary key columns of the table must be in the query and the record must have at least as many fields as the query. Seek cannot be used with multi-table queries. This mode cannot be used with a view containing joins. See also the remarks.
+
+        /// <summary>
+        /// Updates an existing record. Non-primary keys only. Must first call Fetch. Fails with a
+        /// deleted record. Works only with read-write records.
+        /// </summary>
+        Update = 2,   // Updates an existing record. Nonprimary keys only. Must first call MsiViewFetch. Fails with a deleted record. Works only with read-write records.
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/MsiException.cs b/src/WixToolset.Core.Native/Msi/MsiException.cs
new file mode 100644
index 00000000..07c83d81
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/MsiException.cs
@@ -0,0 +1,77 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.ComponentModel;
+
+    /// <summary>
+    /// Exception that wraps MsiGetLastError().
+    /// </summary>
+    [Serializable]
+    public sealed class MsiException : Win32Exception
+    {
+        /// <summary>
+        /// Instantiate a new MsiException with a given error.
+        /// </summary>
+        /// <param name="error">The error code from the MsiXxx() function call.</param>
+        public MsiException(int error) : base(error)
+        {
+            uint handle = MsiInterop.MsiGetLastErrorRecord();
+            if (0 != handle)
+            {
+                using (Record record = new Record(handle))
+                {
+                    this.MsiError = record.GetInteger(1);
+
+                    int errorInfoCount = record.GetFieldCount() - 1;
+                    this.ErrorInfo = new string[errorInfoCount];
+                    for (int i = 0; i < errorInfoCount; ++i)
+                    {
+                        this.ErrorInfo[i] = record.GetString(i + 2);
+                    }
+                }
+            }
+            else
+            {
+                this.MsiError = 0;
+                this.ErrorInfo = new string[0];
+            }
+
+            this.Error = error;
+        }
+
+        /// <summary>
+        /// Gets the error number.
+        /// </summary>
+        public int Error { get; private set; }
+
+        /// <summary>
+        /// Gets the internal MSI error number.
+        /// </summary>
+        public int MsiError { get; private set; }
+
+        /// <summary>
+        /// Gets any additional the error information.
+        /// </summary>
+        public string[] ErrorInfo { get; private set; }
+
+        /// <summary>
+        /// Overrides Message property to return useful error message.
+        /// </summary>
+        public override string Message
+        {
+            get
+            {
+                if (0 == this.MsiError)
+                {
+                    return base.Message;
+                }
+                else
+                {
+                    return String.Format("Internal MSI failure. Win32 error: {0}, MSI error: {1}, detail: {2}", this.Error, this.MsiError, String.Join(", ", this.ErrorInfo));
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/MsiHandle.cs b/src/WixToolset.Core.Native/Msi/MsiHandle.cs
new file mode 100644
index 00000000..dc2ce605
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/MsiHandle.cs
@@ -0,0 +1,117 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.ComponentModel;
+#if !DEBUG
+    using System.Diagnostics;
+#endif
+    using System.Threading;
+
+    /// <summary>
+    /// Wrapper class for MSI handle.
+    /// </summary>
+    public abstract class MsiHandle : IDisposable
+    {
+        private bool disposed;
+        private uint handle;
+        private int owningThread;
+#if DEBUG
+        private string creationStack;
+#endif
+
+        /// <summary>
+        /// MSI handle destructor.
+        /// </summary>
+        ~MsiHandle()
+        {
+            this.Dispose(false);
+        }
+
+        /// <summary>
+        /// Gets or sets the MSI handle.
+        /// </summary>
+        /// <value>The MSI handle.</value>
+        internal uint Handle
+        {
+            get
+            {
+                if (this.disposed)
+                {
+                    throw new ObjectDisposedException("MsiHandle");
+                }
+
+                return this.handle;
+            }
+
+            set
+            {
+                if (this.disposed)
+                {
+                    throw new ObjectDisposedException("MsiHandle");
+                }
+
+                this.handle = value;
+                this.owningThread = Thread.CurrentThread.ManagedThreadId;
+#if DEBUG
+                this.creationStack = Environment.StackTrace;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Close the MSI handle.
+        /// </summary>
+        public void Close()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        /// <param name="disposing">true to dispose the managed objects.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (0 != this.handle)
+                {
+                    if (Thread.CurrentThread.ManagedThreadId == this.owningThread)
+                    {
+                        int error = MsiInterop.MsiCloseHandle(this.handle);
+                        if (0 != error)
+                        {
+                            throw new Win32Exception(error);
+                        }
+                        this.handle = 0;
+                    }
+                    else
+                    {
+                        // Don't try to close the handle on a different thread than it was opened.
+                        // This will occasionally cause MSI to AV.
+                        string message = String.Format("Leaked msi handle {0} created on thread {1} by type {2}.  This handle cannot be closed on thread {3}",
+                            this.handle, this.owningThread, this.GetType(), Thread.CurrentThread.ManagedThreadId);
+#if DEBUG
+                        throw new InvalidOperationException(String.Format("{0}.  Created {1}", message, this.creationStack));
+#else
+                        Debug.WriteLine(message);
+#endif
+                    }
+                }
+
+                this.disposed = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/MsiInterop.cs b/src/WixToolset.Core.Native/Msi/MsiInterop.cs
new file mode 100644
index 00000000..0d16fcb2
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/MsiInterop.cs
@@ -0,0 +1,397 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.Text;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Class exposing static functions and structs from MSI API.
+    /// </summary>
+    internal static class MsiInterop
+    {
+        // Patching constants
+        internal const int MsiMaxStreamNameLength = 62; // http://msdn2.microsoft.com/library/aa370551.aspx
+
+        internal const int MSICONDITIONFALSE = 0;   // The table is temporary.
+        internal const int MSICONDITIONTRUE = 1;   // The table is persistent.
+        internal const int MSICONDITIONNONE = 2;   // The table is unknown.
+        internal const int MSICONDITIONERROR = 3;   // An invalid handle or invalid parameter was passed to the function.
+
+        /*
+        internal const int MSIDBOPENREADONLY = 0;
+        internal const int MSIDBOPENTRANSACT = 1;
+        internal const int MSIDBOPENDIRECT = 2;
+        internal const int MSIDBOPENCREATE = 3;
+        internal const int MSIDBOPENCREATEDIRECT = 4;
+        internal const int MSIDBOPENPATCHFILE = 32;
+
+        internal const int MSIMODIFYSEEK = -1;   // Refreshes the information in the supplied record without changing the position in the result set and without affecting subsequent fetch operations. The record may then be used for subsequent Update, Delete, and Refresh. All primary key columns of the table must be in the query and the record must have at least as many fields as the query. Seek cannot be used with multi-table queries. This mode cannot be used with a view containing joins. See also the remarks.
+        internal const int MSIMODIFYREFRESH = 0;   // Refreshes the information in the record. Must first call MsiViewFetch with the same record. Fails for a deleted row. Works with read-write and read-only records.
+        internal const int MSIMODIFYINSERT = 1;   // Inserts a record. Fails if a row with the same primary keys exists. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYUPDATE = 2;   // Updates an existing record. Nonprimary keys only. Must first call MsiViewFetch. Fails with a deleted record. Works only with read-write records.
+        internal const int MSIMODIFYASSIGN = 3;   // Writes current data in the cursor to a table row. Updates record if the primary keys match an existing row and inserts if they do not match. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYREPLACE = 4;   // Updates or deletes and inserts a record into a table. Must first call MsiViewFetch with the same record. Updates record if the primary keys are unchanged. Deletes old row and inserts new if primary keys have changed. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYMERGE = 5;   // Inserts or validates a record in a table. Inserts if primary keys do not match any row and validates if there is a match. Fails if the record does not match the data in the table. Fails if there is a record with a duplicate key that is not identical. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYDELETE = 6;   // Remove a row from the table. You must first call the MsiViewFetch function with the same record. Fails if the row has been deleted. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYINSERTTEMPORARY = 7;   // Inserts a temporary record. The information is not persistent. Fails if a row with the same primary key exists. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATE = 8;   // Validates a record. Does not validate across joins. You must first call the MsiViewFetch function with the same record. Obtain validation errors with MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATENEW = 9;   // Validate a new record. Does not validate across joins. Checks for duplicate keys. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATEFIELD = 10;   // Validates fields of a fetched or new record. Can validate one or more fields of an incomplete record. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATEDELETE = 11;   // Validates a record that will be deleted later. You must first call MsiViewFetch. Fails if another row refers to the primary keys of this row. Validation does not check for the existence of the primary keys of this row in properties or strings. Does not check if a column is a foreign key to multiple tables. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+
+        internal const uint VTI2 = 2;
+        internal const uint VTI4 = 3;
+        internal const uint VTLPWSTR = 30;
+        internal const uint VTFILETIME = 64;
+        */
+
+        internal const int MSICOLINFONAMES = 0;  // return column names
+        internal const int MSICOLINFOTYPES = 1;  // return column definitions, datatype code followed by width
+
+        /// <summary>
+        /// PInvoke of MsiCloseHandle.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCloseHandle", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiCloseHandle(uint database);
+
+        /// <summary>
+        /// PInvoke of MsiCreateRecord
+        /// </summary>
+        /// <param name="parameters">Count of columns in the record.</param>
+        /// <returns>Handle referencing the record.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCreateRecord", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern uint MsiCreateRecord(int parameters);
+
+        /// <summary>
+        /// Creates summary information of an existing transform to include validation and error conditions.
+        /// </summary>
+        /// <param name="database">The handle to the database that contains the new database summary information.</param>
+        /// <param name="referenceDatabase">The handle to the database that contains the original summary information.</param>
+        /// <param name="transformFile">The name of the transform to which the summary information is added.</param>
+        /// <param name="errorConditions">The error conditions that should be suppressed when the transform is applied.</param>
+        /// <param name="validations">Specifies the properties to be validated to verify that the transform can be applied to the database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCreateTransformSummaryInfoW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiCreateTransformSummaryInfo(uint database, uint referenceDatabase, string transformFile, TransformErrorConditions errorConditions, TransformValidations validations);
+
+        /// <summary>
+        /// Applies a transform to a database.
+        /// </summary>
+        /// <param name="database">Handle to the database obtained from MsiOpenDatabase to transform.</param>
+        /// <param name="transformFile">Specifies the name of the transform file to apply.</param>
+        /// <param name="errorConditions">Error conditions that should be suppressed.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseApplyTransformW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseApplyTransform(uint database, string transformFile, TransformErrorConditions errorConditions);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseCommit.
+        /// </summary>
+        /// <param name="database">Handle to a databse.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseCommit", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseCommit(uint database);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseExportW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <param name="folderPath">Folder path.</param>
+        /// <param name="fileName">File name.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseExportW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseExport(uint database, string tableName, string folderPath, string fileName);
+
+        /// <summary>
+        /// Generates a transform file of differences between two databases.
+        /// </summary>
+        /// <param name="database">Handle to the database obtained from MsiOpenDatabase that includes the changes.</param>
+        /// <param name="databaseReference">Handle to the database obtained from MsiOpenDatabase that does not include the changes.</param>
+        /// <param name="transformFile">A null-terminated string that specifies the name of the transform file being generated.
+        /// This parameter can be null. If szTransformFile is null, you can use MsiDatabaseGenerateTransform to test whether two
+        /// databases are identical without creating a transform. If the databases are identical, the function returns ERROR_NO_DATA.
+        /// If the databases are different the function returns NOERROR.</param>
+        /// <param name="reserved1">This is a reserved argument and must be set to 0.</param>
+        /// <param name="reserved2">This is a reserved argument and must be set to 0.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseGenerateTransformW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseGenerateTransform(uint database, uint databaseReference, string transformFile, int reserved1, int reserved2);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseImportW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="folderPath">Folder path.</param>
+        /// <param name="fileName">File name.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseImportW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseImport(uint database, string folderPath, string fileName);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseMergeW.
+        /// </summary>
+        /// <param name="database">The handle to the database obtained from MsiOpenDatabase.</param>
+        /// <param name="databaseMerge">The handle to the database obtained from MsiOpenDatabase to merge into the base database.</param>
+        /// <param name="tableName">The name of the table to receive merge conflict information.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseMergeW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseMerge(uint database, uint databaseMerge, string tableName);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseOpenViewW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="query">SQL query.</param>
+        /// <param name="view">View handle.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseOpenViewW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseOpenView(uint database, string query, out uint view);
+
+        /// <summary>
+        /// PInvoke of MsiGetFileHashW.
+        /// </summary>
+        /// <param name="filePath">File path.</param>
+        /// <param name="options">Hash options (must be 0).</param>
+        /// <param name="hash">Buffer to recieve hash.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetFileHashW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetFileHash(string filePath, uint options, MSIFILEHASHINFO hash);
+
+        /// <summary>
+        /// PInvoke of MsiGetFileVersionW.
+        /// </summary>
+        /// <param name="filePath">File path.</param>
+        /// <param name="versionBuf">Buffer to receive version info.</param>
+        /// <param name="versionBufSize">Size of version buffer.</param>
+        /// <param name="langBuf">Buffer to recieve lang info.</param>
+        /// <param name="langBufSize">Size of lang buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetFileVersionW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetFileVersion(string filePath, StringBuilder versionBuf, ref int versionBufSize, StringBuilder langBuf, ref int langBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiGetLastErrorRecord.
+        /// </summary>
+        /// <returns>Handle to error record if one exists.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetLastErrorRecord", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern uint MsiGetLastErrorRecord();
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseGetPrimaryKeysW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <param name="record">Handle to receive resulting record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseGetPrimaryKeysW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseGetPrimaryKeys(uint database, string tableName, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiDoActionW.
+        /// </summary>
+        /// <param name="product">Handle to the installation provided to a DLL custom action or
+        /// obtained through MsiOpenPackage, MsiOpenPackageEx, or MsiOpenProduct.</param>
+        /// <param name="action">Specifies the action to execute.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDoActionW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDoAction(uint product, string action);
+
+        /// <summary>
+        /// PInvoke of MsiGetSummaryInformationW.  Can use either database handle or database path as input.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="databasePath">Path to a database.</param>
+        /// <param name="updateCount">Max number of updated values.</param>
+        /// <param name="summaryInfo">Handle to summary information.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetSummaryInformationW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetSummaryInformation(uint database, string databasePath, uint updateCount, ref uint summaryInfo);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseIsTablePersitentW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <returns>MSICONDITION</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseIsTablePersistentW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseIsTablePersistent(uint database, string tableName);
+
+        /// <summary>
+        /// PInvoke of MsiOpenDatabaseW.
+        /// </summary>
+        /// <param name="databasePath">Path to database.</param>
+        /// <param name="persist">Persist mode.</param>
+        /// <param name="database">Handle to database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiOpenDatabaseW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiOpenDatabase(string databasePath, IntPtr persist, out uint database);
+
+        /// <summary>
+        /// PInvoke of MsiOpenPackageW.
+        /// </summary>
+        /// <param name="packagePath">The path to the package.</param>
+        /// <param name="product">A pointer to a variable that receives the product handle.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiOpenPackageW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiOpenPackage(string packagePath, out uint product);
+
+        /// <summary>
+        /// PInvoke of MsiRecordIsNull.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to check for null value.</param>
+        /// <returns>true if the field is null, false if not, and an error code for any error.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordIsNull", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordIsNull(uint record, int field);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetInteger.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to retrieve integer from.</param>
+        /// <returns>Integer value.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetInteger", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetInteger(uint record, int field);
+
+        /// <summary>
+        /// PInvoke of MsiRectordSetInteger.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set integer value in.</param>
+        /// <param name="value">Value to set field to.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetInteger", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetInteger(uint record, int field, int value);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetStringW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to get string value from.</param>
+        /// <param name="valueBuf">Buffer to recieve value.</param>
+        /// <param name="valueBufSize">Size of buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetStringW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetString(uint record, int field, StringBuilder valueBuf, ref int valueBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiRecordSetStringW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set string value in.</param>
+        /// <param name="value">String value.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetStringW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetString(uint record, int field, string value);
+
+        /// <summary>
+        /// PInvoke of MsiRecordSetStreamW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set stream value in.</param>
+        /// <param name="filePath">Path to file to set stream value to.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetStreamW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetStream(uint record, int field, string filePath);
+
+        /// <summary>
+        /// PInvoke of MsiRecordReadStreamW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to read stream from.</param>
+        /// <param name="dataBuf">Data buffer to recieve stream value.</param>
+        /// <param name="dataBufSize">Size of data buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordReadStream", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordReadStream(uint record, int field, byte[] dataBuf, ref int dataBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetFieldCount.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <returns>Count of fields in the record.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetFieldCount", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetFieldCount(uint record);
+
+        /// <summary>
+        /// PInvoke of MsiSetExternalUIW.
+        /// </summary>
+        /// <param name="installUIHandler">Specifies a callback function that conforms to the INSTALLUI_HANDLER specification.</param>
+        /// <param name="installLogMode">Specifies which messages to handle using the external message handler. If the external
+        /// handler returns a non-zero result, then that message will not be sent to the UI, instead the message will be logged
+        /// if logging has been enabled.</param>
+        /// <param name="context">Pointer to an application context that is passed to the callback function.
+        /// This parameter can be used for error checking.</param>
+        /// <returns>The return value is the previously set external handler, or zero (0) if there was no previously set handler.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSetExternalUIW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern InstallUIHandler MsiSetExternalUI(InstallUIHandler installUIHandler, int installLogMode, IntPtr context);
+
+        /// <summary>
+        /// PInvoke of MsiSetInternalUI.
+        /// </summary>
+        /// <param name="uiLevel">Specifies the level of complexity of the user interface.</param>
+        /// <param name="hwnd">Pointer to a window. This window becomes the owner of any user interface created.
+        /// A pointer to the previous owner of the user interface is returned.
+        /// If this parameter is null, the owner of the user interface does not change.</param>
+        /// <returns>The previous user interface level is returned. If an invalid dwUILevel is passed, then INSTALLUILEVEL_NOCHANGE is returned.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSetInternalUI", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiSetInternalUI(int uiLevel, ref IntPtr hwnd);
+
+        /// <summary>
+        /// PInvoke of MsiSummaryInfoGetPropertyW.
+        /// </summary>
+        /// <param name="summaryInfo">Handle to summary info.</param>
+        /// <param name="property">Property to get value from.</param>
+        /// <param name="dataType">Data type of property.</param>
+        /// <param name="integerValue">Integer to receive integer value.</param>
+        /// <param name="fileTimeValue">File time to receive file time value.</param>
+        /// <param name="stringValueBuf">String buffer to receive string value.</param>
+        /// <param name="stringValueBufSize">Size of string buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSummaryInfoGetPropertyW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiSummaryInfoGetProperty(uint summaryInfo, int property, out uint dataType, out int integerValue, ref System.Runtime.InteropServices.ComTypes.FILETIME fileTimeValue, StringBuilder stringValueBuf, ref int stringValueBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiViewGetColumnInfo.
+        /// </summary>
+        /// <param name="view">Handle to view.</param>
+        /// <param name="columnInfo">Column info.</param>
+        /// <param name="record">Handle for returned record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewGetColumnInfo", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewGetColumnInfo(uint view, int columnInfo, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewExecute.
+        /// </summary>
+        /// <param name="view">Handle of view to execute.</param>
+        /// <param name="record">Handle to a record that supplies the parameters for the view.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewExecute", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewExecute(uint view, uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewFetch.
+        /// </summary>
+        /// <param name="view">Handle of view to fetch a row from.</param>
+        /// <param name="record">Handle to receive record info.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewFetch", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewFetch(uint view, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewModify.
+        /// </summary>
+        /// <param name="view">Handle of view to modify.</param>
+        /// <param name="modifyMode">Modify mode.</param>
+        /// <param name="record">Handle of record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewModify", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewModify(uint view, int modifyMode, uint record);
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/OpenDatabase.cs b/src/WixToolset.Core.Native/Msi/OpenDatabase.cs
new file mode 100644
index 00000000..18a78f77
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/OpenDatabase.cs
@@ -0,0 +1,40 @@
+// 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.Core.Native.Msi
+{
+    /// <summary>
+    /// Enum of predefined persist modes used when opening a database.
+    /// </summary>
+    public enum OpenDatabase
+    {
+        /// <summary>
+        /// Open a database read-only, no persistent changes.
+        /// </summary>
+        ReadOnly = 0,
+
+        /// <summary>
+        /// Open a database read/write in transaction mode.
+        /// </summary>
+        Transact = 1,
+
+        /// <summary>
+        /// Open a database direct read/write without transaction.
+        /// </summary>
+        Direct = 2,
+
+        /// <summary>
+        /// Create a new database, transact mode read/write.
+        /// </summary>
+        Create = 3,
+
+        /// <summary>
+        /// Create a new database, direct mode read/write.
+        /// </summary>
+        CreateDirect = 4,
+
+        /// <summary>
+        /// Indicates a patch file is being opened.
+        /// </summary>
+        OpenPatchFile = 32
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/Record.cs b/src/WixToolset.Core.Native/Msi/Record.cs
new file mode 100644
index 00000000..c25e76e2
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/Record.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.Core.Native.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Text;
+
+    /// <summary>
+    /// Wrapper class around msi.dll interop for a record.
+    /// </summary>
+    public sealed class Record : MsiHandle
+    {
+        /// <summary>
+        /// Creates a record with the specified number of fields.
+        /// </summary>
+        /// <param name="fieldCount">Number of fields in record.</param>
+        public Record(int fieldCount)
+        {
+            this.Handle = MsiInterop.MsiCreateRecord(fieldCount);
+            if (0 == this.Handle)
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        /// <summary>
+        /// Creates a record from a handle.
+        /// </summary>
+        /// <param name="handle">Handle to create record from.</param>
+        internal Record(uint handle)
+        {
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Gets a string value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get string.</param>
+        public string this[int field]
+        {
+            get => this.GetString(field);
+            set => this.SetString(field, value);
+        }
+
+        /// <summary>
+        /// Determines if the value is null at the specified location.
+        /// </summary>
+        /// <param name="field">Index into record of the field to query.</param>
+        /// <returns>true if the value is null, false otherwise.</returns>
+        public bool IsNull(int field)
+        {
+            var error = MsiInterop.MsiRecordIsNull(this.Handle, field);
+
+            switch (error)
+            {
+                case 0:
+                    return false;
+                case 1:
+                    return true;
+                default:
+                    throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets integer value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get integer</param>
+        /// <returns>Integer value</returns>
+        public int GetInteger(int field)
+        {
+            return MsiInterop.MsiRecordGetInteger(this.Handle, field);
+        }
+
+        /// <summary>
+        /// Sets integer value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to set integer.</param>
+        /// <param name="value">Value to set into record.</param>
+        public void SetInteger(int field, int value)
+        {
+            var error = MsiInterop.MsiRecordSetInteger(this.Handle, field, value);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets string value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get string.</param>
+        /// <returns>String value</returns>
+        public string GetString(int field)
+        {
+            var bufferSize = 256;
+            var buffer = new StringBuilder(bufferSize);
+            var error = MsiInterop.MsiRecordGetString(this.Handle, field, buffer, ref bufferSize);
+            if (234 == error)
+            {
+                buffer.EnsureCapacity(++bufferSize);
+                error = MsiInterop.MsiRecordGetString(this.Handle, field, buffer, ref bufferSize);
+            }
+
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+
+            return (0 < buffer.Length ? buffer.ToString() : null);
+        }
+
+        /// <summary>
+        /// Set string value at specified location
+        /// </summary>
+        /// <param name="field">Index into record to set string.</param>
+        /// <param name="value">Value to set into record</param>
+        public void SetString(int field, string value)
+        {
+            var error = MsiInterop.MsiRecordSetString(this.Handle, field, value);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Get stream at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get stream.</param>
+        /// <param name="buffer">buffer to receive bytes from stream.</param>
+        /// <param name="requestedBufferSize">Buffer size to read.</param>
+        /// <returns>Stream read into string.</returns>
+        public int GetStream(int field, byte[] buffer, int requestedBufferSize)
+        {
+            var bufferSize = buffer.Length;
+            if (requestedBufferSize > 0)
+            {
+                bufferSize = requestedBufferSize;
+            }
+
+            var error = MsiInterop.MsiRecordReadStream(this.Handle, field, buffer, ref bufferSize);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+
+            return bufferSize;
+        }
+
+        /// <summary>
+        /// Sets a stream at a specified location.
+        /// </summary>
+        /// <param name="field">Index into record to set stream.</param>
+        /// <param name="path">Path to file to read into stream.</param>
+        public void SetStream(int field, string path)
+        {
+            var error = MsiInterop.MsiRecordSetStream(this.Handle, field, path);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of fields in record.
+        /// </summary>
+        /// <returns>Count of fields in record.</returns>
+        public int GetFieldCount()
+        {
+            var size = MsiInterop.MsiRecordGetFieldCount(this.Handle);
+            if (0 > size)
+            {
+                throw new Win32Exception();
+            }
+
+            return size;
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/Session.cs b/src/WixToolset.Core.Native/Msi/Session.cs
new file mode 100644
index 00000000..743fb2be
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/Session.cs
@@ -0,0 +1,42 @@
+// 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.Core.Native.Msi
+{
+    using System.Globalization;
+
+    /// <summary>
+    /// Controls the installation process.
+    /// </summary>
+    public sealed class Session : MsiHandle
+    {
+        /// <summary>
+        /// Instantiate a new Session.
+        /// </summary>
+        /// <param name="database">The database to open.</param>
+        public Session(Database database)
+        {
+            var packagePath = "#" + database.Handle.ToString(CultureInfo.InvariantCulture);
+
+            var error = MsiInterop.MsiOpenPackage(packagePath, out var handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Executes a built-in action, custom action, or user-interface wizard action.
+        /// </summary>
+        /// <param name="action">Specifies the action to execute.</param>
+        public void DoAction(string action)
+        {
+            var error = MsiInterop.MsiDoAction(this.Handle, action);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/SummaryInformation.cs b/src/WixToolset.Core.Native/Msi/SummaryInformation.cs
new file mode 100644
index 00000000..a7ba5717
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/SummaryInformation.cs
@@ -0,0 +1,243 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.Globalization;
+    using System.Text;
+    using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+
+    /// <summary>
+    /// Summary information for the MSI files.
+    /// </summary>
+    public sealed class SummaryInformation : MsiHandle
+    {
+        /// <summary>
+        /// Summary information properties for transforms.
+        /// </summary>
+        public enum Transform
+        {
+            /// <summary>PID_CODEPAGE = code page for the summary information stream</summary>
+            CodePage = 1,
+
+            /// <summary>PID_TITLE = typically just "Transform"</summary>
+            Title = 2,
+
+            /// <summary>PID_SUBJECT = original subject of target</summary>
+            TargetSubject = 3,
+
+            /// <summary>PID_AUTHOR = original manufacturer of target</summary>
+            TargetManufacturer = 4,
+
+            /// <summary>PID_KEYWORDS = keywords for the transform, typically including at least "Installer"</summary>
+            Keywords = 5,
+
+            /// <summary>PID_COMMENTS = describes what this package does</summary>
+            Comments = 6,
+
+            /// <summary>PID_TEMPLATE = target platform;language</summary>
+            TargetPlatformAndLanguage = 7,
+
+            /// <summary>PID_LASTAUTHOR = updated platform;language</summary>
+            UpdatedPlatformAndLanguage = 8,
+
+            /// <summary>PID_REVNUMBER = {productcode}version;{newproductcode}newversion;upgradecode</summary>
+            ProductCodes = 9,
+
+            /// <summary>PID_LASTPRINTED should be null for transforms</summary>
+            Reserved11 = 11,
+
+            ///.<summary>PID_CREATE_DTM = the timestamp when the transform was created</summary>
+            CreationTime = 12,
+
+            /// <summary>PID_PAGECOUNT = minimum installer version</summary>
+            InstallerRequirement = 14,
+
+            /// <summary>PID_CHARCOUNT = validation and error flags</summary>
+            ValidationFlags = 16,
+
+            /// <summary>PID_APPNAME = the application that created the transform</summary>
+            CreatingApplication = 18,
+
+            /// <summary>PID_SECURITY = whether read-only is enforced; should always be 4 for transforms</summary>
+            Security = 19,
+        }
+
+        /// <summary>
+        /// Summary information properties for patches.
+        /// </summary>
+        public enum Patch
+        {
+            /// <summary>PID_CODEPAGE = code page of the summary information stream</summary>
+            CodePage = 1,
+
+            /// <summary>PID_TITLE = a brief description of the package type</summary>
+            Title = 2,
+
+            /// <summary>PID_SUBJECT = package name</summary>
+            PackageName = 3,
+
+            /// <summary>PID_AUTHOR = manufacturer of the patch package</summary>
+            Manufacturer = 4,
+
+            /// <summary>PID_KEYWORDS = alternate sources for the patch package</summary>
+            Sources = 5,
+
+            /// <summary>PID_COMMENTS = general purpose of the patch package</summary>
+            Comments = 6,
+
+            /// <summary>PID_TEMPLATE = semicolon delimited list of ProductCodes</summary>
+            ProductCodes = 7,
+
+            /// <summary>PID_LASTAUTHOR = semicolon delimited list of transform names</summary>
+            TransformNames = 8,
+
+            /// <summary>PID_REVNUMBER = GUID patch code</summary>
+            PatchCode = 9,
+
+            /// <summary>PID_LASTPRINTED should be null for patches</summary>
+            Reserved11 = 11,
+
+            /// <summary>PID_PAGECOUNT should be null for patches</summary>
+            Reserved14 = 14,
+
+            /// <summary>PID_WORDCOUNT = minimum installer version</summary>
+            InstallerRequirement = 15,
+
+            /// <summary>PID_CHARCOUNT should be null for patches</summary>
+            Reserved16 = 16,
+
+            /// <summary>PID_SECURITY = read-only attribute of the patch package</summary>
+            Security = 19,
+        }
+
+        /// <summary>
+        /// Summary information values for the InstallerRequirement property.
+        /// </summary>
+        public enum InstallerRequirement
+        {
+            /// <summary>Any version of the installer will do</summary>
+            Version10 = 1,
+
+            /// <summary>At least 1.2</summary>
+            Version12 = 2,
+
+            /// <summary>At least 2.0</summary>
+            Version20 = 3,
+
+            /// <summary>At least 3.0</summary>
+            Version30 = 4,
+
+            /// <summary>At least 3.1</summary>
+            Version31 = 5,
+        }
+
+        /// <summary>
+        /// Instantiate a new SummaryInformation class from an open database.
+        /// </summary>
+        /// <param name="db">Database to retrieve summary information from.</param>
+        public SummaryInformation(Database db)
+        {
+            if (null == db)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            uint handle = 0;
+            var error = MsiInterop.MsiGetSummaryInformation(db.Handle, null, 0, ref handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Instantiate a new SummaryInformation class from a database file.
+        /// </summary>
+        /// <param name="databaseFile">The database file.</param>
+        public SummaryInformation(string databaseFile)
+        {
+            if (null == databaseFile)
+            {
+                throw new ArgumentNullException("databaseFile");
+            }
+
+            uint handle = 0;
+            var error = MsiInterop.MsiGetSummaryInformation(0, databaseFile, 0, ref handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Gets a summary information property.
+        /// </summary>
+        /// <param name="index">Index of the summary information property.</param>
+        /// <returns>The summary information property.</returns>
+        public string GetProperty(int index)
+        {
+            var bufSize = 64;
+            var stringValue = new StringBuilder(bufSize);
+
+            FILETIME timeValue;
+            timeValue.dwHighDateTime = 0;
+            timeValue.dwLowDateTime = 0;
+
+            var error = MsiInterop.MsiSummaryInfoGetProperty(this.Handle, index, out var dataType, out var intValue, ref timeValue, stringValue, ref bufSize);
+            if (234 == error)
+            {
+                stringValue.EnsureCapacity(++bufSize);
+                error = MsiInterop.MsiSummaryInfoGetProperty(this.Handle, index, out dataType, out intValue, ref timeValue, stringValue, ref bufSize);
+            }
+
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            switch ((VT)dataType)
+            {
+                case VT.EMPTY:
+                    return String.Empty;
+                case VT.LPSTR:
+                    return stringValue.ToString();
+                case VT.I2:
+                case VT.I4:
+                    return Convert.ToString(intValue, CultureInfo.InvariantCulture);
+                case VT.FILETIME:
+                    var longFileTime = (((long)timeValue.dwHighDateTime) << 32) | unchecked((uint)timeValue.dwLowDateTime);
+                    var dateTime = DateTime.FromFileTime(longFileTime);
+                    return dateTime.ToString("yyyy/MM/dd HH:mm:ss", CultureInfo.InvariantCulture);
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+
+        /// <summary>
+        /// Variant types in the summary information table.
+        /// </summary>
+        private enum VT : uint
+        {
+            /// <summary>Variant has not been assigned.</summary>
+            EMPTY = 0,
+
+            /// <summary>Null variant type.</summary>
+            NULL = 1,
+
+            /// <summary>16-bit integer variant type.</summary>
+            I2 = 2,
+
+            /// <summary>32-bit integer variant type.</summary>
+            I4 = 3,
+
+            /// <summary>String variant type.</summary>
+            LPSTR = 30,
+
+            /// <summary>Date time (FILETIME, converted to Variant time) variant type.</summary>
+            FILETIME = 64,
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/TransformErrorConditions.cs b/src/WixToolset.Core.Native/Msi/TransformErrorConditions.cs
new file mode 100644
index 00000000..313dceeb
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/TransformErrorConditions.cs
@@ -0,0 +1,58 @@
+// 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.Core.Native.Msi
+{
+    using System;
+
+    /// <summary>
+    /// The errors to suppress when applying a transform.
+    /// </summary>
+    [Flags]
+    public enum TransformErrorConditions
+    {
+        /// <summary>
+        /// None of the following conditions.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Suppress error when adding a row that exists.
+        /// </summary>
+        AddExistingRow = 0x1,
+
+        /// <summary>
+        /// Suppress error when deleting a row that does not exist.
+        /// </summary>
+        DeleteMissingRow = 0x2,
+
+        /// <summary>
+        /// Suppress error when adding a table that exists.
+        /// </summary>
+        AddExistingTable = 0x4,
+
+        /// <summary>
+        /// Suppress error when deleting a table that does not exist.
+        /// </summary>
+        DeleteMissingTable = 0x8,
+
+        /// <summary>
+        /// Suppress error when updating a row that does not exist.
+        /// </summary>
+        UpdateMissingRow = 0x10,
+
+        /// <summary>
+        /// Suppress error when transform and database code pages do not match, and their code pages are neutral.
+        /// </summary>
+        ChangeCodepage = 0x20,
+
+        /// <summary>
+        /// Create the temporary _TransformView table when applying a transform.
+        /// </summary>
+        ViewTransform = 0x100,
+
+        /// <summary>
+        /// Suppress all errors but the option to create the temporary _TransformView table.
+        /// </summary>
+        All = 0x3F
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/TransformValidations.cs b/src/WixToolset.Core.Native/Msi/TransformValidations.cs
new file mode 100644
index 00000000..52bddeaf
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/TransformValidations.cs
@@ -0,0 +1,73 @@
+// 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.Core.Native.Msi
+{
+    using System;
+
+    /// <summary>
+    /// The validation to run while applying a transform.
+    /// </summary>
+    [Flags]
+    public enum TransformValidations
+    {
+        /// <summary>
+        /// Do not validate properties.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Default language must match base database.
+        /// </summary>
+        Language = 0x1,
+
+        /// <summary>
+        /// Product must match base database.
+        /// </summary>
+        Product = 0x2,
+
+        /// <summary>
+        /// Check major version only.
+        /// </summary>
+        MajorVersion = 0x8,
+
+        /// <summary>
+        /// Check major and minor versions only.
+        /// </summary>
+        MinorVersion = 0x10,
+
+        /// <summary>
+        /// Check major, minor, and update versions.
+        /// </summary>
+        UpdateVersion = 0x20,
+
+        /// <summary>
+        /// Installed version &lt; base version.
+        /// </summary>
+        NewLessBaseVersion = 0x40,
+
+        /// <summary>
+        /// Installed version &lt;= base version.
+        /// </summary>
+        NewLessEqualBaseVersion = 0x80,
+
+        /// <summary>
+        /// Installed version = base version.
+        /// </summary>
+        NewEqualBaseVersion = 0x100,
+
+        /// <summary>
+        /// Installed version &gt;= base version.
+        /// </summary>
+        NewGreaterEqualBaseVersion = 0x200,
+
+        /// <summary>
+        /// Installed version &gt; base version.
+        /// </summary>
+        NewGreaterBaseVersion = 0x400,
+
+        /// <summary>
+        /// UpgradeCode must match base database.
+        /// </summary>
+        UpgradeCode = 0x800
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/View.cs b/src/WixToolset.Core.Native/Msi/View.cs
new file mode 100644
index 00000000..6305a9de
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/View.cs
@@ -0,0 +1,206 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+
+    /// <summary>
+    /// Wrapper class for MSI API views.
+    /// </summary>
+    public sealed class View : MsiHandle
+    {
+        /// <summary>
+        /// Constructor that creates a view given a database handle and a query.
+        /// </summary>
+        /// <param name="db">Handle to the database to run the query on.</param>
+        /// <param name="query">Query to be executed.</param>
+        public View(Database db, string query)
+        {
+            if (null == db)
+            {
+                throw new ArgumentNullException(nameof(db));
+            }
+
+            if (null == query)
+            {
+                throw new ArgumentNullException(nameof(query));
+            }
+
+            var error = MsiInterop.MsiDatabaseOpenView(db.Handle, query, out var handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Enumerator that automatically disposes of the retrieved Records.
+        /// </summary>
+        public IEnumerable<Record> Records => new ViewEnumerable(this);
+
+        /// <summary>
+        /// Executes a view with no customizable parameters.
+        /// </summary>
+        public void Execute()
+        {
+            this.Execute(null);
+        }
+
+        /// <summary>
+        /// Executes a query substituing the values from the records into the customizable parameters 
+        /// in the view.
+        /// </summary>
+        /// <param name="record">Record containing parameters to be substituded into the view.</param>
+        public void Execute(Record record)
+        {
+            var error = MsiInterop.MsiViewExecute(this.Handle, null == record ? 0 : record.Handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Fetches the next row in the view.
+        /// </summary>
+        /// <returns>Returns the fetched record; otherwise null.</returns>
+        public Record Fetch()
+        {
+            var error = MsiInterop.MsiViewFetch(this.Handle, out var recordHandle);
+            if (259 == error)
+            {
+                return null;
+            }
+            else if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+
+        /// <summary>
+        /// Updates a fetched record.
+        /// </summary>
+        /// <param name="type">Type of modification mode.</param>
+        /// <param name="record">Record to be modified.</param>
+        public void Modify(ModifyView type, Record record)
+        {
+            var error = MsiInterop.MsiViewModify(this.Handle, Convert.ToInt32(type, CultureInfo.InvariantCulture), record.Handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Get the column names in a record.
+        /// </summary>
+        /// <returns></returns>
+        public Record GetColumnNames()
+        {
+            return this.GetColumnInfo(MsiInterop.MSICOLINFONAMES);
+        }
+
+        /// <summary>
+        /// Get the column types in a record.
+        /// </summary>
+        /// <returns></returns>
+        public Record GetColumnTypes()
+        {
+            return this.GetColumnInfo(MsiInterop.MSICOLINFOTYPES);
+        }
+
+        /// <summary>
+        /// Returns a record containing column names or definitions.
+        /// </summary>
+        /// <param name="columnType">Specifies a flag indicating what type of information is needed. Either MSICOLINFO_NAMES or MSICOLINFO_TYPES.</param>
+        /// <returns>The record containing information about the column.</returns>
+        public Record GetColumnInfo(int columnType)
+        {
+
+            var error = MsiInterop.MsiViewGetColumnInfo(this.Handle, columnType, out var recordHandle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+
+        private class ViewEnumerable : IEnumerable<Record>
+        {
+            private readonly View view;
+
+            public ViewEnumerable(View view) => this.view = view;
+
+            public IEnumerator<Record> GetEnumerator() => new ViewEnumerator(this.view);
+
+            IEnumerator IEnumerable.GetEnumerator() => new ViewEnumerator(this.view);
+        }
+
+        private class ViewEnumerator : IEnumerator<Record>
+        {
+            private readonly View view;
+            private readonly List<Record> records = new List<Record>();
+            private int position = -1;
+            private bool disposed;
+
+            public ViewEnumerator(View view) => this.view = view;
+
+            public Record Current => this.records[this.position];
+
+            object IEnumerator.Current => this.records[this.position];
+
+            public bool MoveNext()
+            {
+                if (this.position + 1 >= this.records.Count)
+                {
+                    var record = this.view.Fetch();
+
+                    if (record == null)
+                    {
+                        return false;
+                    }
+
+                    this.records.Add(record);
+                    this.position = this.records.Count - 1;
+                }
+                else
+                {
+                    ++this.position;
+                }
+
+                return true;
+            }
+
+            public void Reset() => this.position = -1;
+
+            public void Dispose()
+            {
+                this.Dispose(true);
+            }
+
+            protected virtual void Dispose(bool disposing)
+            {
+                if (!this.disposed)
+                {
+                    if (disposing)
+                    {
+                        foreach (var record in this.records)
+                        {
+                            record.Dispose();
+                        }
+                    }
+
+                    this.disposed = true;
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core.Native/Msi/WixInvalidIdtException.cs b/src/WixToolset.Core.Native/Msi/WixInvalidIdtException.cs
new file mode 100644
index 00000000..268ddc11
--- /dev/null
+++ b/src/WixToolset.Core.Native/Msi/WixInvalidIdtException.cs
@@ -0,0 +1,49 @@
+// 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.Core.Native.Msi
+{
+    using System;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// WiX invalid idt exception.
+    /// </summary>
+    [Serializable]
+    public sealed class WixInvalidIdtException : WixException
+    {
+        /// <summary>
+        /// Instantiate a new WixInvalidIdtException.
+        /// </summary>
+        public WixInvalidIdtException()
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixInvalidIdtException.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="innerException"></param>
+        public WixInvalidIdtException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixInvalidIdtException.
+        /// </summary>
+        /// <param name="idtFile">The invalid idt file.</param>
+        public WixInvalidIdtException(string idtFile) :
+            base(ErrorMessages.InvalidIdt(new SourceLineNumber(idtFile), idtFile))
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixInvalidIdtException.
+        /// </summary>
+        /// <param name="idtFile">The invalid idt file.</param>
+        /// <param name="tableName">The table name of the invalid idt file.</param>
+        public WixInvalidIdtException(string idtFile, string tableName) :
+            base(ErrorMessages.InvalidIdt(new SourceLineNumber(idtFile), idtFile, tableName))
+        {
+        }
+    }
+}