#pragma once
// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.

#include <BootstrapperApplication.h>
#include <IBootstrapperEngine.h>

DECLARE_INTERFACE_IID_(IBootstrapperApplication, IUnknown, "53C31D56-49C0-426B-AB06-099D717C67FE")
{
    // BAProc - The PFN_BOOTSTRAPPER_APPLICATION_PROC can call this method to give the BA raw access to the callback from the engine.
    //          This might be used to help the BA support more than one version of the engine.
    STDMETHOD(BAProc)(
        __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
        __in const LPVOID pvArgs,
        __inout LPVOID pvResults
        ) = 0;

    // BAProcFallback - The PFN_BOOTSTRAPPER_APPLICATION_PROC can call this method
    //                  to give the BA the ability to use default behavior
    //                  and then forward the message to extensions.
    STDMETHOD_(void, BAProcFallback)(
        __in BOOTSTRAPPER_APPLICATION_MESSAGE message,
        __in const LPVOID pvArgs,
        __inout LPVOID pvResults,
        __inout HRESULT* phr
        ) = 0;

    // OnCreate - called when the bootstrapper application is created.
    //
    virtual STDMETHODIMP OnCreate(
        __in IBootstrapperEngine* pEngine,
        __in BOOTSTRAPPER_COMMAND* pCommand
        ) = 0;

    // OnDestroy - called before the bootstrapper application stops.
    //
    STDMETHOD(OnDestroy)(
        __in BOOL fReload
    ) = 0;

    // OnStartup - called when the engine is ready for the bootstrapper application to start.
    //
    STDMETHOD(OnStartup)() = 0;

    // OnShutdown - called after the bootstrapper application quits the engine.
    STDMETHOD(OnShutdown)(
        __inout BOOTSTRAPPER_SHUTDOWN_ACTION* pAction
        ) = 0;

    // OnDetectBegin - called when the engine begins detection.
    STDMETHOD(OnDetectBegin)(
        __in BOOL fCached,
        __in BOOTSTRAPPER_REGISTRATION_TYPE registrationType,
        __in DWORD cPackages,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectForwardCompatibleBundle - called when the engine detects a forward compatible bundle.
    STDMETHOD(OnDetectForwardCompatibleBundle)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_RELATION_TYPE relationType,
        __in_z LPCWSTR wzBundleTag,
        __in BOOL fPerMachine,
        __in_z LPCWSTR wzVersion,
        __in BOOL fMissingFromCache,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectUpdateBegin - called when the engine begins detection for bundle update.
    STDMETHOD(OnDetectUpdateBegin)(
        __in_z LPCWSTR wzUpdateLocation,
        __inout BOOL* pfCancel,
        __inout BOOL* pfSkip
        ) = 0;

    // OnDetectUpdate - called when the engine has an update candidate for bundle update.
    STDMETHOD(OnDetectUpdate)(
        __in_z_opt LPCWSTR wzUpdateLocation,
        __in DWORD64 dw64Size,
        __in_z_opt LPCWSTR wzHash,
        __in BOOTSTRAPPER_UPDATE_HASH_TYPE hashAlgorithm,
        __in_z LPCWSTR wzVersion,
        __in_z_opt LPCWSTR wzTitle,
        __in_z_opt LPCWSTR wzSummary,
        __in_z_opt LPCWSTR wzContentType,
        __in_z_opt LPCWSTR wzContent,
        __inout BOOL* pfCancel,
        __inout BOOL* pfStopProcessingUpdates
        ) = 0;

    // OnDetectUpdateComplete - called when the engine completes detection for bundle update.
    STDMETHOD(OnDetectUpdateComplete)(
        __in HRESULT hrStatus,
        __inout BOOL* pfIgnoreError
        ) = 0;

    // OnDetectRelatedBundle - called when the engine detects a related bundle.
    STDMETHOD(OnDetectRelatedBundle)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_RELATION_TYPE relationType,
        __in_z LPCWSTR wzBundleTag,
        __in BOOL fPerMachine,
        __in_z LPCWSTR wzVersion,
        __in BOOL fMissingFromCache,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectPackageBegin - called when the engine begins detecting a package.
    STDMETHOD(OnDetectPackageBegin)(
        __in_z LPCWSTR wzPackageId,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectCompatibleMsiPackage - called when the engine detects that a package is not installed but a newer package using the same provider key is.
    STDMETHOD(OnDetectCompatibleMsiPackage)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzCompatiblePackageId,
        __in_z LPCWSTR wzCompatiblePackageVersion,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectRelatedMsiPackage - called when the engine begins detects a related package.
    STDMETHOD(OnDetectRelatedMsiPackage)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzUpgradeCode,
        __in_z LPCWSTR wzProductCode,
        __in BOOL fPerMachine,
        __in_z LPCWSTR wzVersion,
        __in BOOTSTRAPPER_RELATED_OPERATION operation,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectPatchTarget - called when the engine detects a target product
    //                       for an MSP package.
    STDMETHOD(OnDetectPatchTarget)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzProductCode,
        __in BOOTSTRAPPER_PACKAGE_STATE patchState,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectMsiFeature - called when the engine detects a feature in an MSI package.
    STDMETHOD(OnDetectMsiFeature)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzFeatureId,
        __in BOOTSTRAPPER_FEATURE_STATE state,
        __inout BOOL* pfCancel
        ) = 0;

    // OnDetectPackageComplete - called after the engine detects a package.
    //
    STDMETHOD(OnDetectPackageComplete)(
        __in_z LPCWSTR wzPackageId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_PACKAGE_STATE state,
        __in BOOL fCached
        ) = 0;

    // OnDetectPackageComplete - called after the engine completes detection.
    //
    STDMETHOD(OnDetectComplete)(
        __in HRESULT hrStatus,
        __in BOOL fEligibleForCleanup
        ) = 0;

    // OnPlanBegin - called when the engine begins planning.
    STDMETHOD(OnPlanBegin)(
        __in DWORD cPackages,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanRelatedBundle - called when the engine begins planning a related bundle.
    STDMETHOD(OnPlanRelatedBundle)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_REQUEST_STATE recommendedState,
        __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanRollbackBoundary - called when the engine is planning a rollback boundary.
    STDMETHOD(OnPlanRollbackBoundary)(
        __in_z LPCWSTR wzRollbackBoundaryId,
        __in BOOL fRecommendedTransaction,
        __inout BOOL* pfTransaction,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanPackageBegin - called when the engine has begun getting the BA's input
    //                      for planning a package.
    STDMETHOD(OnPlanPackageBegin)(
        __in_z LPCWSTR wzPackageId,
        __in BOOTSTRAPPER_PACKAGE_STATE state,
        __in BOOL fCached,
        __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT installCondition,
        __in BOOTSTRAPPER_PACKAGE_CONDITION_RESULT repairCondition,
        __in BOOTSTRAPPER_REQUEST_STATE recommendedState,
        __in BOOTSTRAPPER_CACHE_TYPE recommendedCacheType,
        __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState,
        __inout BOOTSTRAPPER_CACHE_TYPE* pRequestedCacheType,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanCompatibleMsiPackageBegin - called when the engine plans a newer, compatible package using the same provider key.
    STDMETHOD(OnPlanCompatibleMsiPackageBegin)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzCompatiblePackageId,
        __in_z LPCWSTR wzCompatiblePackageVersion,
        __in BOOL fRecommendedRemove,
        __inout BOOL* pfRequestRemove,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanCompatibleMsiPackageComplete - called after the engine plans the package.
    //
    STDMETHOD(OnPlanCompatibleMsiPackageComplete)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzCompatiblePackageId,
        __in HRESULT hrStatus,
        __in BOOL fRequestedRemove
        ) = 0;

    // OnPlanPatchTarget - called when the engine is about to plan a target
    //                     of an MSP package.
    STDMETHOD(OnPlanPatchTarget)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzProductCode,
        __in BOOTSTRAPPER_REQUEST_STATE recommendedState,
        __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanMsiFeature - called when the engine plans a feature in an
    //                    MSI package.
    STDMETHOD(OnPlanMsiFeature)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzFeatureId,
        __in BOOTSTRAPPER_FEATURE_STATE recommendedState,
        __inout BOOTSTRAPPER_FEATURE_STATE* pRequestedState,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanMsiPackage - called when the engine plans an MSI or MSP package.
    //
    STDMETHOD(OnPlanMsiPackage)(
        __in_z LPCWSTR wzPackageId,
        __in BOOL fExecute, // false means rollback.
        __in BOOTSTRAPPER_ACTION_STATE action,
        __in BOOTSTRAPPER_MSI_FILE_VERSIONING recommendedFileVersioning,
        __inout BOOL* pfCancel,
        __inout BURN_MSI_PROPERTY* pActionMsiProperty,
        __inout INSTALLUILEVEL* pUiLevel,
        __inout BOOL* pfDisableExternalUiHandler,
        __inout BOOTSTRAPPER_MSI_FILE_VERSIONING* pFileVersioning
        ) = 0;

    // OnPlanPackageComplete - called after the engine has completed getting the BA's input
    //                         for planning a package.
    STDMETHOD(OnPlanPackageComplete)(
        __in_z LPCWSTR wzPackageId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_REQUEST_STATE requested
        ) = 0;

    // OnPlannedCompatiblePackage - called after the engine has completed planning a compatible package.
    STDMETHOD(OnPlannedCompatiblePackage)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzCompatiblePackageId,
        __in BOOL fRemove
        ) = 0;

    // OnPlannedPackage - called after the engine has completed planning a package.
    STDMETHOD(OnPlannedPackage)(
        __in_z LPCWSTR wzPackageId,
        __in BOOTSTRAPPER_ACTION_STATE execute,
        __in BOOTSTRAPPER_ACTION_STATE rollback,
        __in BOOL fPlannedCache,
        __in BOOL fPlannedUncache
        ) = 0;

    // OnPlanComplete - called when the engine completes planning.
    //
    STDMETHOD(OnPlanComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnApplyBegin - called when the engine begins applying the plan.
    //
    STDMETHOD(OnApplyBegin)(
        __in DWORD dwPhaseCount,
        __inout BOOL* pfCancel
        ) = 0;

    // OnElevateBegin - called before the engine displays an elevation prompt.
    //                  Will only happen once per execution of the engine,
    //                  assuming the elevation was successful.
    STDMETHOD(OnElevateBegin)(
        __inout BOOL* pfCancel
        ) = 0;

    // OnElevateComplete - called after the engine attempted to elevate.
    //
    STDMETHOD(OnElevateComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnProgress - called when the engine makes progress.
    //
    STDMETHOD(OnProgress)(
        __in DWORD dwProgressPercentage,
        __in DWORD dwOverallPercentage,
        __inout BOOL* pfCancel
        ) = 0;

    // OnError - called when the engine encounters an error.
    //
    // nResult:
    //  uiFlags is a combination of valid ID* return values appropriate for
    //          the error.
    //
    //  IDNOACTION instructs the engine to pass the error through to default
    //             handling which usually results in the apply failing.
    STDMETHOD(OnError)(
        __in BOOTSTRAPPER_ERROR_TYPE errorType,
        __in_z_opt LPCWSTR wzPackageId,
        __in DWORD dwCode,
        __in_z_opt LPCWSTR wzError,
        __in DWORD dwUIHint,
        __in DWORD cData,
        __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
        __in int nRecommendation,
        __inout int* pResult
        ) = 0;

    // OnRegisterBegin - called when the engine registers the bundle.
    //
    STDMETHOD(OnRegisterBegin)(
        __in BOOTSTRAPPER_REGISTRATION_TYPE recommendedRegistrationType,
        __inout BOOL* pfCancel,
        __inout BOOTSTRAPPER_REGISTRATION_TYPE* pRegistrationType
        ) = 0;

    // OnRegisterComplete - called when the engine registration is
    //                      complete.
    //
    STDMETHOD(OnRegisterComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnCacheBegin - called when the engine begins caching.
    //
    STDMETHOD(OnCacheBegin)(
        __inout BOOL* pfCancel
        ) = 0;

    // OnCachePackageBegin - called when the engine begins caching
    //                       a package.
    //
    STDMETHOD(OnCachePackageBegin)(
        __in_z LPCWSTR wzPackageId,
        __in DWORD cCachePayloads,
        __in DWORD64 dw64PackageCacheSize,
        __in BOOL fVital,
        __inout BOOL* pfCancel
        )  = 0;

    // OnCacheAcquireBegin - called when the engine begins acquiring a payload or container.
    //
    // Notes:
    //  It is expected the BA may call IBootstrapperEngine::SetLocalSource() or IBootstrapperEngine::SetDownloadSource()
    //  to update the source location before returning.
    //
    STDMETHOD(OnCacheAcquireBegin)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in_z LPCWSTR wzSource,
        __in_z_opt LPCWSTR wzDownloadUrl,
        __in_z_opt LPCWSTR wzPayloadContainerId,
        __in BOOTSTRAPPER_CACHE_OPERATION recommendation,
        __inout BOOTSTRAPPER_CACHE_OPERATION* pAction,
        __inout BOOL* pfCancel
        ) = 0;

    // OnCacheAcquireProgress - called when the engine makes progress acquiring the payload or container.
    //
    STDMETHOD(OnCacheAcquireProgress)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in DWORD64 dw64Progress,
        __in DWORD64 dw64Total,
        __in DWORD dwOverallPercentage,
        __inout BOOL* pfCancel
        ) = 0;

    // OnCacheAcquireResolving - called to allow the BA to override the acquisition action for the payload or container.
    //
    // Parameters:
    //  wzPackageOrContainerId will be NULL when resolving a layout-only payload.
    //  wzPayloadId will be NULL when resolving a container.
    //  wzDownloadUrl will be NULL if the container or payload does not provide a DownloadURL.
    //  wzPayloadContainerId will not be NULL if acquiring a payload that is in a container.
    //
    //  rgSearchPaths are the search paths used for source resolution.
    //  fFoundLocal is TRUE when dwRecommendedSearchPath indicates that the file was found.
    //  dwRecommendedSearchPath is the index into rgSearchPaths for the recommended local file.
    //
    STDMETHOD(OnCacheAcquireResolving)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in_z LPCWSTR* rgSearchPaths,
        __in DWORD cSearchPaths,
        __in BOOL fFoundLocal,
        __in DWORD dwRecommendedSearchPath,
        __in_z_opt LPCWSTR wzDownloadUrl,
        __in_z_opt LPCWSTR wzPayloadContainerId,
        __in BOOTSTRAPPER_CACHE_RESOLVE_OPERATION recommendation,
        __inout DWORD* pdwChosenSearchPath,
        __inout BOOTSTRAPPER_CACHE_RESOLVE_OPERATION* pAction,
        __inout BOOL* pfCancel
        ) = 0;

    // OnCacheAcquireComplete - called after the engine acquired the payload or container.
    //
    // Notes:
    //  It is expected the BA may call IBootstrapperEngine::SetLocalSource() or IBootstrapperEngine::SetDownloadSource()
    //  to update the source location before returning BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION_RETRY.
    //
    STDMETHOD(OnCacheAcquireComplete)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_CACHEACQUIRECOMPLETE_ACTION* pAction
        ) = 0;

    // OnCacheVerifyBegin - called when the engine begins to verify then copy
    //                      a payload or container to the package cache folder.
    //
    STDMETHOD(OnCacheVerifyBegin)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCacheVerifyProgress)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in DWORD64 dw64Progress,
        __in DWORD64 dw64Total,
        __in DWORD dwOverallPercentage,
        __in BOOTSTRAPPER_CACHE_VERIFY_STEP verifyStep,
        __inout BOOL* pfCancel
        ) = 0;

    // OnCacheVerifyComplete - called after the engine verifies and copies
    //                         a payload or container to the package cache folder.
    //
    STDMETHOD(OnCacheVerifyComplete)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_CACHEVERIFYCOMPLETE_ACTION* pAction
        ) = 0;

    // OnCachePackageComplete - called after the engine attempts to copy or download all
    //                          payloads of a package into the package cache folder.
    //
    STDMETHOD(OnCachePackageComplete)(
        __in_z LPCWSTR wzPackageId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_CACHEPACKAGECOMPLETE_ACTION* pAction
        )  = 0;

    // OnCacheComplete - called when the engine caching is complete.
    //
    STDMETHOD(OnCacheComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnExecuteBegin - called when the engine begins executing the plan.
    //
    STDMETHOD(OnExecuteBegin)(
        __in DWORD cExecutingPackages,
        __inout BOOL* pfCancel
        ) = 0;

    // OnExecutePackageBegin - called when the engine begins executing a package.
    //
    STDMETHOD(OnExecutePackageBegin)(
        __in_z LPCWSTR wzPackageId,
        __in BOOL fExecute, // false means rollback.
        __in BOOTSTRAPPER_ACTION_STATE action,
        __in INSTALLUILEVEL uiLevel,
        __in BOOL fDisableExternalUiHandler,
        __inout BOOL* pfCancel
        ) = 0;

    // OnExecutePatchTarget - called for each patch in an MspPackage targeting the product
    //                        when the engine begins executing the MspPackage.
    //
    STDMETHOD(OnExecutePatchTarget)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzTargetProductCode,
        __inout BOOL* pfCancel
        ) = 0;

    // OnExecuteProgress - called when the engine makes progress executing a package.
    //
    STDMETHOD(OnExecuteProgress)(
        __in_z LPCWSTR wzPackageId,
        __in DWORD dwProgressPercentage,
        __in DWORD dwOverallPercentage,
        __inout BOOL* pfCancel
        ) = 0;

    // OnExecuteMsiMessage - called when the engine receives an MSI package message.
    //
    // Return:
    //  uiFlags is a combination of valid ID* return values appropriate for
    //          the message.
    //
    //  IDNOACTION instructs the engine to pass the message through to default
    //             handling which usually results in the execution continuing.
    STDMETHOD(OnExecuteMsiMessage)(
        __in_z LPCWSTR wzPackageId,
        __in INSTALLMESSAGE messageType,
        __in DWORD dwUIHint,
        __in_z LPCWSTR wzMessage,
        __in DWORD cData,
        __in_ecount_z_opt(cData) LPCWSTR* rgwzData,
        __in int nRecommendation,
        __inout int* pResult
        ) = 0;

    // OnExecuteFilesInUse - called when the engine receives a files in use message
    //                       while executing a package.
    //
    // Return value depends on the source:
    //  BOOTSTRAPPER_FILES_IN_USE_TYPE_MSI: https://docs.microsoft.com/en-us/windows/win32/msi/installvalidate-action
    //  BOOTSTRAPPER_FILES_IN_USE_TYPE_MSI_RM: https://docs.microsoft.com/en-us/windows/win32/msi/using-restart-manager-with-an-external-ui-
    //  BOOTSTRAPPER_FILES_IN_USE_TYPE_NETFX: https://docs.microsoft.com/en-us/dotnet/framework/deployment/how-to-get-progress-from-the-dotnet-installer
    STDMETHOD(OnExecuteFilesInUse)(
        __in_z LPCWSTR wzPackageId,
        __in DWORD cFiles,
        __in_ecount_z(cFiles) LPCWSTR* rgwzFiles,
        __in int nRecommendation,
        __in BOOTSTRAPPER_FILES_IN_USE_TYPE source,
        __inout int* pResult
        ) = 0;

    // OnExecutePackageComplete - called when a package execution is complete.
    //
    STDMETHOD(OnExecutePackageComplete)(
        __in_z LPCWSTR wzPackageId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_APPLY_RESTART restart,
        __in BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_EXECUTEPACKAGECOMPLETE_ACTION* pAction
        ) = 0;

    // OnExecuteComplete - called when the engine execution is complete.
    //
    STDMETHOD(OnExecuteComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnUnregisterBegin - called when the engine unregisters the bundle.
    //
    STDMETHOD(OnUnregisterBegin)(
        __in BOOTSTRAPPER_REGISTRATION_TYPE recommendedRegistrationType,
        __inout BOOTSTRAPPER_REGISTRATION_TYPE* pRegistrationType
        ) = 0;

    // OnUnregisterComplete - called when the engine unregistration is complete.
    //
    STDMETHOD(OnUnregisterComplete)(
        __in HRESULT hrStatus
        ) = 0;

    // OnApplyComplete - called after the plan has been applied.
    //
    STDMETHOD(OnApplyComplete)(
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_APPLY_RESTART restart,
        __in BOOTSTRAPPER_APPLYCOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_APPLYCOMPLETE_ACTION* pAction
        ) = 0;

    // OnLaunchApprovedExeBegin - called before trying to launch the preapproved executable.
    //
    STDMETHOD(OnLaunchApprovedExeBegin)(
        __inout BOOL* pfCancel
        ) = 0;

    // OnLaunchApprovedExeComplete - called after trying to launch the preapproved executable.
    //
    STDMETHOD(OnLaunchApprovedExeComplete)(
        __in HRESULT hrStatus,
        __in DWORD dwProcessId
        ) = 0;

    STDMETHOD(OnBeginMsiTransactionBegin)(
        __in_z LPCWSTR wzTransactionId,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnBeginMsiTransactionComplete)(
        __in_z LPCWSTR wzTransactionId,
        __in HRESULT hrStatus
        ) = 0;

    STDMETHOD(OnCommitMsiTransactionBegin)(
        __in_z LPCWSTR wzTransactionId,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCommitMsiTransactionComplete)(
        __in_z LPCWSTR wzTransactionId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_APPLY_RESTART restart,
        __in BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION* pAction
        ) = 0;

    STDMETHOD(OnRollbackMsiTransactionBegin)(
        __in_z LPCWSTR wzTransactionId
        ) = 0;

    STDMETHOD(OnRollbackMsiTransactionComplete)(
        __in_z LPCWSTR wzTransactionId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_APPLY_RESTART restart,
        __in BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION recommendation,
        __inout BOOTSTRAPPER_EXECUTEMSITRANSACTIONCOMPLETE_ACTION* pAction
        ) = 0;

    STDMETHOD(OnPauseAutomaticUpdatesBegin)(
        ) = 0;

    STDMETHOD(OnPauseAutomaticUpdatesComplete)(
        __in HRESULT hrStatus
        ) = 0;

    STDMETHOD(OnSystemRestorePointBegin)(
        ) = 0;

    STDMETHOD(OnSystemRestorePointComplete)(
        __in HRESULT hrStatus
        ) = 0;

    STDMETHOD(OnPlanForwardCompatibleBundle)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_RELATION_TYPE relationType,
        __in_z LPCWSTR wzBundleTag,
        __in BOOL fPerMachine,
        __in_z LPCWSTR wzVersion,
        __in BOOL fRecommendedIgnoreBundle,
        __inout BOOL* pfCancel,
        __inout BOOL* pfIgnoreBundle
        ) = 0;

    STDMETHOD(OnCacheContainerOrPayloadVerifyBegin)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCacheContainerOrPayloadVerifyProgress)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in DWORD64 dw64Progress,
        __in DWORD64 dw64Total,
        __in DWORD dwOverallPercentage,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCacheContainerOrPayloadVerifyComplete)(
        __in_z_opt LPCWSTR wzPackageOrContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in HRESULT hrStatus
        ) = 0;

    STDMETHOD(OnCachePayloadExtractBegin)(
        __in_z_opt LPCWSTR wzContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCachePayloadExtractProgress)(
        __in_z_opt LPCWSTR wzContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in DWORD64 dw64Progress,
        __in DWORD64 dw64Total,
        __in DWORD dwOverallPercentage,
        __inout BOOL* pfCancel
        ) = 0;

    STDMETHOD(OnCachePayloadExtractComplete)(
        __in_z_opt LPCWSTR wzContainerId,
        __in_z_opt LPCWSTR wzPayloadId,
        __in HRESULT hrStatus
        ) = 0;

    // OnPlanRestoreRelatedBundle - called when the engine begins planning an upgrade related bundle for restoring in case of failure.
    STDMETHOD(OnPlanRestoreRelatedBundle)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_REQUEST_STATE recommendedState,
        __inout BOOTSTRAPPER_REQUEST_STATE* pRequestedState,
        __inout BOOL* pfCancel
        ) = 0;

    // OnPlanRelatedBundleType - called when the engine begins planning the related bundle relation type.
    STDMETHOD(OnPlanRelatedBundleType)(
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE recommendedType,
        __inout BOOTSTRAPPER_RELATED_BUNDLE_PLAN_TYPE* pRequestedType,
        __inout BOOL* pfCancel
        ) = 0;

    // OnApplyDowngrade - called when the plan determined that nothing should happen to prevent downgrading.
    //
    STDMETHOD(OnApplyDowngrade)(
        __in HRESULT hrRecommended,
        __inout HRESULT* phrStatus
        ) = 0;

    // OnExecuteProcessCancel - called when a package that spawned a process is cancelled.
    //
    STDMETHOD(OnExecuteProcessCancel)(
        __in_z LPCWSTR wzPackageId,
        __in DWORD dwProcessId,
        __in BOOTSTRAPPER_EXECUTEPROCESSCANCEL_ACTION recommendation,
        __inout BOOTSTRAPPER_EXECUTEPROCESSCANCEL_ACTION* pAction
        ) = 0;

    // OnDetectRelatedBundlePackage - called when the engine detects a related bundle for a BundlePackage.
    STDMETHOD(OnDetectRelatedBundlePackage)(
        __in_z LPCWSTR wzPackageId,
        __in_z LPCWSTR wzBundleId,
        __in BOOTSTRAPPER_RELATION_TYPE relationType,
        __in BOOL fPerMachine,
        __in_z LPCWSTR wzVersion,
        __inout BOOL* pfCancel
        ) = 0;

    // OnCachePackageNonVitalValidationFailure - called when the engine failed validating a package in the package cache that is non-vital to execution.
    STDMETHOD(OnCachePackageNonVitalValidationFailure)(
        __in_z LPCWSTR wzPackageId,
        __in HRESULT hrStatus,
        __in BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION recommendation,
        __inout BOOTSTRAPPER_CACHEPACKAGENONVITALVALIDATIONFAILURE_ACTION* pAction
        ) = 0;
};