New-Item -ItemType Directory -Force -Path "C:\Users\$($user.Name)\AppData\Roaming\Folder1\Folder2\"
    Copy-File -Path "$dirFiles\config_update.xml" -Destination "C:\Users\$($user.Name)\AppData\Roaming\Folder1\Folder2\config_update.xml"

    If (!(Test-Path -Path "C:\Users\$($user.Name)\AppData\Roaming\Folder1\Folder2\" -ErrorAction SilentlyContinue )) { New-Item "C:\Users\$($user.Name)\AppData\Roaming\Folder1\Folder2\" -Type Directory -ErrorAction SilentlyContinue | Out-Null }

If (!(Test-Path -Path "C:\Users\$env:Username\AppData\Roaming\Folder1\Folder2\" -ErrorAction SilentlyContinue )) { New-Item "C:\Users\$env:Username\AppData\Roaming\Folder1\Folder2\" -Type Directory -ErrorAction SilentlyContinue | Out-Null }
Copy-File -Path "$dirFiles\config_update.xml" -Destination "C:\Users\$env:Username\AppData\Roaming\Folder1\Folder2\config_update.xml"

Function Get-PendingReboot 
{ 
<# 
.SYNOPSIS 
    Gets the pending reboot status on a local or remote computer. 
 
.DESCRIPTION 
    This function will query the registry on a local or remote computer and determine if the 
    system is pending a reboot, from either Microsoft Patching or a Software Installation. 
    For Windows 2008+ the function will query the CBS registry key as another factor in determining 
    pending reboot state.  "PendingFileRenameOperations" and "Auto Update\RebootRequired" are observed 
    as being consistant across Windows Server 2003 & 2008. 
   
    CBServicing = Component Based Servicing (Windows 2008) 
    WindowsUpdate = Windows Update / Auto Update (Windows 2003 / 2008) 
    CCMClientSDK = SCCM 2012 Clients only (DetermineIfRebootPending method) otherwise $null value 
    PendFileRename = PendingFileRenameOperations (Windows 2003 / 2008) 
 
.PARAMETER ComputerName 
    A single Computer or an array of computer names.  The default is localhost ($env:COMPUTERNAME). 
 
.PARAMETER ErrorLog 
    A single path to send error data to a log file. 
 
.EXAMPLE 
    PS C:\> Get-PendingReboot -ComputerName (Get-Content C:\ServerList.txt) | Format-Table -AutoSize 
   
    Computer CBServicing WindowsUpdate CCMClientSDK PendFileRename PendFileRenVal RebootPending 
    -------- ----------- ------------- ------------ -------------- -------------- ------------- 
    DC01           False         False                       False                        False 
    DC02           False         False                       False                        False 
    FS01           False         False                       False                        False 
 
    This example will capture the contents of C:\ServerList.txt and query the pending reboot 
    information from the systems contained in the file and display the output in a table. The 
    null values are by design, since these systems do not have the SCCM 2012 client installed, 
    nor was the PendingFileRenameOperations value populated. 
 
.EXAMPLE 
    PS C:\> Get-PendingReboot 
   
    Computer       : WKS01 
    CBServicing    : False 
    WindowsUpdate  : True 
    CCMClient      : False 
    PendFileRename : False 
    PendFileRenVal :  
    RebootPending  : True 
   
    This example will query the local machine for pending reboot information. 
   
.EXAMPLE 
    PS C:\> $Servers = Get-Content C:\Servers.txt 
    PS C:\> Get-PendingReboot -Computer $Servers | Export-Csv C:\PendingRebootReport.csv -NoTypeInformation 
   
    This example will create a report that contains pending reboot information. 
 
.LINK 
    Component-Based Servicing: 
    http://technet.microsoft.com/en-us/library/cc756291(v=WS.10).aspx 
   
    PendingFileRename/Auto Update: 
    http://support.microsoft.com/kb/2723674 
    http://technet.microsoft.com/en-us/library/cc960241.aspx 
    http://blogs.msdn.com/b/hansr/archive/2006/02/17/patchreboot.aspx 
 
    SCCM 2012/CCM_ClientSDK: 
    http://msdn.microsoft.com/en-us/library/jj902723.aspx 
 
.NOTES 
    Author:  Brian Wilhite 
    Email:   bwilhite1@carolina.rr.com 
    Date:    08/29/2012 
    PSVer:   2.0/3.0 
    Updated: 05/30/2013 
    UpdNote: Added CCMClient property - Used with SCCM 2012 Clients only 
             Added ValueFromPipelineByPropertyName=$true to the ComputerName Parameter 
             Removed $Data variable from the PSObject - it is not needed 
             Bug with the way CCMClientSDK returned null value if it was false 
             Removed unneeded variables 
             Added PendFileRenVal - Contents of the PendingFileRenameOperations Reg Entry 
#> 
 
[CmdletBinding()] 
param( 
  [Parameter(Position=0,ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true)] 
  [Alias("CN","Computer")] 
  [String[]]$ComputerName="$env:COMPUTERNAME", 
  [String]$ErrorLog 
  ) 
 
Begin 
  { 
    # Adjusting ErrorActionPreference to stop on all errors, since using [Microsoft.Win32.RegistryKey] 
        # does not have a native ErrorAction Parameter, this may need to be changed if used within another 
        # function. 
    $TempErrAct = $ErrorActionPreference 
    $ErrorActionPreference = "Stop" 
  }#End Begin Script Block 
Process 
  { 
    Foreach ($Computer in $ComputerName) 
      { 
        Try 
          { 
            # Setting pending values to false to cut down on the number of else statements 
            $PendFileRename,$Pending,$SCCM = $false,$false,$false 
                         
                        # Setting CBSRebootPend to null since not all versions of Windows has this value 
                        $CBSRebootPend = $null 
             
            # Querying WMI for build version 
            $WMI_OS = Get-WmiObject -Class Win32_OperatingSystem -Property BuildNumber, CSName -ComputerName $Computer 
 
            # Making registry connection to the local/remote computer 
            $RegCon = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey([Microsoft.Win32.RegistryHive]"LocalMachine",$Computer) 
             
            # If Vista/2008 & Above query the CBS Reg Key 
            If ($WMI_OS.BuildNumber -ge 6001) 
              { 
                $RegSubKeysCBS = $RegCon.OpenSubKey("SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\").GetSubKeyNames() 
                $CBSRebootPend = $RegSubKeysCBS -contains "RebootPending" 
                   
              }#End If ($WMI_OS.BuildNumber -ge 6001) 
               
            # Query WUAU from the registry 
            $RegWUAU = $RegCon.OpenSubKey("SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\") 
            $RegWUAURebootReq = $RegWUAU.GetSubKeyNames() 
            $WUAURebootReq = $RegWUAURebootReq -contains "RebootRequired" 
             
            # Query PendingFileRenameOperations from the registry 
            $RegSubKeySM = $RegCon.OpenSubKey("SYSTEM\CurrentControlSet\Control\Session Manager\") 
            $RegValuePFRO = $RegSubKeySM.GetValue("PendingFileRenameOperations",$null) 
             
            # Closing registry connection 
            $RegCon.Close() 
             
            # If PendingFileRenameOperations has a value set $RegValuePFRO variable to $true 
            If ($RegValuePFRO) 
              { 
                $PendFileRename = $true 
 
              }#End If ($RegValuePFRO) 
 
            # Determine SCCM 2012 Client Reboot Pending Status 
            # To avoid nested 'if' statements and unneeded WMI calls to determine if the CCM_ClientUtilities class exist, setting EA = 0 
            $CCMClientSDK = $null 
                        $CCMSplat = @{ 
                            NameSpace='ROOT\ccm\ClientSDK' 
                            Class='CCM_ClientUtilities' 
                            Name='DetermineIfRebootPending' 
                            ComputerName=$Computer 
                            ErrorAction='SilentlyContinue' 
                            } 
                        $CCMClientSDK = Invoke-WmiMethod @CCMSplat 
            If ($CCMClientSDK) 
                            { 
                                If ($CCMClientSDK.ReturnValue -ne 0) 
                      { 
                        Write-Warning "Error: DetermineIfRebootPending returned error code $($CCMClientSDK.ReturnValue)" 
                             
                      }#End If ($CCMClientSDK -and $CCMClientSDK.ReturnValue -ne 0) 
 
                    If ($CCMClientSDK.IsHardRebootPending -or $CCMClientSDK.RebootPending) 
                      { 
                        $SCCM = $true 
 
                      }#End If ($CCMClientSDK.IsHardRebootPending -or $CCMClientSDK.RebootPending) 
 
                            }#End If ($CCMClientSDK) 
                        Else 
                            { 
                                $SCCM = $null 
 
                            }                         
                         
                        # If any of the variables are true, set $Pending variable to $true 
            If ($CBSRebootPend -or $WUAURebootReq -or $SCCM -or $PendFileRename) 
              { 
                $Pending = $true 
 
              }#End If ($CBS -or $WUAU -or $PendFileRename) 
               
            # Creating Custom PSObject and Select-Object Splat 
                        $SelectSplat = @{ 
                            Property=('Computer','CBServicing','WindowsUpdate','CCMClientSDK','PendFileRename','PendFileRenVal','RebootPending') 
                            } 
            New-Object -TypeName PSObject -Property @{ 
                Computer=$WMI_OS.CSName 
                CBServicing=$CBSRebootPend 
                WindowsUpdate=$WUAURebootReq 
                CCMClientSDK=$SCCM 
                PendFileRename=$PendFileRename 
                                PendFileRenVal=$RegValuePFRO 
                RebootPending=$Pending 
                } | Select-Object @SelectSplat 
 
          }#End Try 
 
        Catch 
          { 
            Write-Warning "$Computer`: $_" 
             
            # If $ErrorLog, log the file to a user specified location/path 
            If ($ErrorLog) 
              { 
                Out-File -InputObject "$Computer`,$_" -FilePath $ErrorLog -Append 
 
              }#End If ($ErrorLog) 
               
          }#End Catch 
           
      }#End Foreach ($Computer in $ComputerName) 
       
  }#End Process 
   
End 
  { 
    # Resetting ErrorActionPref 
    $ErrorActionPreference = $TempErrAct 
  }
  }

$Reboot = get-pendingreboot | % {$_.RebootPending}
If ($Reboot -eq $True) {
reboot however you feel like here.
}

Requested Execution Level=asInvoker

Requested Execution Level=requireAdministrator

$FullScreenWindowSource = @'
        using System;
        using System.Text;
        using System.Runtime.InteropServices;

        namespace ScreenDetection
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct RECT
            {
                public int Left;
                public int Top;
                public int Right;
                public int Bottom;
            }
            
            public class FullScreen
            {
                [DllImport("user32.dll")]
                private static extern IntPtr GetForegroundWindow();
                
                [DllImport("user32.dll")]
                private static extern IntPtr GetDesktopWindow();
                
                [DllImport("user32.dll")]
                private static extern IntPtr GetShellWindow();
                
                [DllImport("user32.dll", SetLastError = true)]
                private static extern int GetWindowRect(IntPtr hWnd, out RECT rc);

                [DllImport("user32.dll")]
                static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
                
                private static IntPtr desktopHandle;
                private static IntPtr shellHandle;
                
                public static bool IsFullScreenWindow(string fullScreenWindowTitle)
                {
                    desktopHandle = GetDesktopWindow();
                    shellHandle   = GetShellWindow();
                    
                    bool runningFullScreen = false;
                    RECT appBounds;
                    System.Drawing.Rectangle screenBounds;
                    const int nChars = 256;
                    StringBuilder Buff = new StringBuilder(nChars);
                    string mainWindowTitle = "";
                    IntPtr hWnd;
                    hWnd = GetForegroundWindow();
                    
                    if (hWnd != null && !hWnd.Equals(IntPtr.Zero))
                    {
                        if (!(hWnd.Equals(desktopHandle) || hWnd.Equals(shellHandle)))
                        {
                            if (GetWindowText(hWnd, Buff, nChars) > 0)
                            {
                                mainWindowTitle = Buff.ToString();
                                //Console.WriteLine(mainWindowTitle)
                            }
                            
                            // If the main window title contains the text being searched for, then check to see if the window is in fullscreen mode.
                            if ((!string.IsNullOrEmpty(fullScreenWindowTitle)) && mainWindowTitle.Contains(fullScreenWindowTitle))
                            {
                                GetWindowRect(hWnd, out appBounds);
                                screenBounds = System.Windows.Forms.Screen.FromHandle(hWnd).Bounds;
                                if ((appBounds.Bottom - appBounds.Top) == screenBounds.Height && (appBounds.Right - appBounds.Left) == screenBounds.Width)
                                {
                                    runningFullScreen = true;
                                }
                            }
                        }
                    }
                    
                    return runningFullScreen;
                }
            }
        }
'@
        
        If (-not ([System.Management.Automation.PSTypeName]'ScreenDetection.FullScreen').Type)
        {
            $ReferencedAssemblies = ('System.Drawing','System.Windows.Forms')
            Add-Type -TypeDefinition $FullScreenWindowSource -ReferencedAssemblies $ReferencedAssemblies -Language CSharp
        }
        
        [boolean]$IsPowerPointFullScreen = [ScreenDetection.FullScreen]::IsFullScreenWindow('PowerPoint Slide Show')

• All users collection
• Specific computer collections
• OSD
  

Function Test-VPNConnection
{
<#
.SYNOPSIS
    Check to see if there is an active VPN connection.
    
.DESCRIPTION
    Check to see if there is an active VPN connection by using the Win32_NetworkAdapter and the 
    Win32_NetworkAdapterConfiguration WMI classes.
    
.PARAMETER LikeAdapterDescription
    Matches on the network adapter description field using wild card matching.
    
.PARAMETER NotMatchAdapterDescription
    Excludes on the network adapter description field using regex matching.
    
.PARAMETER LikeAdapterDNSDomain
    Matches on the network adapter DNS Domain field using wild card matching.
    
.PARAMETER LikeAdapterDHCPServer
    Matches on the network adapter DHCP Server field using wild card matching.
    
.PARAMETER LikeAdapterDefaultGateway
    Matches on the network adapter Default Gateway field using wild card matching. 
    
.PARAMETER DisplayNetworkAdapterTable
    Logs the full list of network adapters and also the filterd list of possible VPN connection
     network adapters.
    
.EXAMPLE
    Test-VPNConnection
    
.NOTES
.LINK
    
#>
    [CmdletBinding()]
    Param
    (
        [Parameter(Mandatory=$false)]
        [ValidateNotNullorEmpty()]
        [string[]]$LikeAdapterDescription = ('*vpn*','*juniper*','*check point*'),
        
        [Parameter(Mandatory=$false)]
        [ValidateNotNullorEmpty()]
        [string[]]$NotMatchAdapterDescription = ('^WAN Miniport','^Microsoft','^VMware Virtual','VirtualBox','^Bluetooth Device','^RAS Async Adapter','USB'),
        
        [Parameter(Mandatory=$false)]
        [ValidateNotNullorEmpty()]
        [string[]]$LikeAdapterDNSDomain = ('*.com'),
        
        [Parameter(Mandatory=$false)]
        [ValidateNotNullorEmpty()]
        [string[]]$LikeAdapterDHCPServer,
        
        [Parameter(Mandatory=$false)]
        [ValidateNotNullorEmpty()]
        [string[]]$LikeAdapterDefaultGateway,
        
        [Parameter(Mandatory=$false)]
        [switch]$DisplayNetworkAdapterTable = $false
    )
    
    Begin
    {
        ## Get the name of this function
        [string]${CmdletName} = $PSCmdlet.MyInvocation.MyCommand.Name
        
        #Write-FunctionHeader -CmdletName ${CmdletName} -CmdletBoundParameters $PSBoundParameters
        
        [scriptblock]$NotMatchDescription = {
                [CmdletBinding()]
                Param
                (
                    [Parameter(Mandatory=$true,Position=0,ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true)]
                    $sbInputObject,
                    
                    [Parameter(Mandatory=$true,Position=1)]
                    $sbNotMatchAdapterDescription
                )
                $SendToPipeline = $false
                ForEach ($sbNotMatchDesc in $sbNotMatchAdapterDescription)
                {
                    If (-not ($sbInputObject.Description -imatch $sbNotMatchDesc))
                    {
                        $SendToPipeline = $true
                    }
                    Else
                    {
                        $SendToPipeline = $false
                        Break
                    }
                }
                Write-Output $SendToPipeline
            }
    }
    Process
    {
        Try
        {
            [psobject[]]$AllNetworkAdapter           = Get-WmiObject Win32_NetworkAdapter -ErrorAction 'Stop' |
                                                       Select-Object -Property DeviceID, PNPDeviceID, Manufacturer
            
            [psobject[]]$AllNetworkAdapterConfigTemp = Get-WmiObject Win32_NetworkAdapterConfiguration -ErrorAction 'Stop' |
                                                       Select-Object -Property @{L='DeviceID'; E={$_.Index}}, DNSDomain, DefaultIPGateway, DHCPServer, IPEnabled, PhysicalAdapter, Manufacturer, Description
            $AllNetworkAdapterConfig = $null
            ForEach ($AdapterConfig in $AllNetworkAdapterConfigTemp)
            {
                ForEach ($Adapter in $AllNetworkAdapter)
                {
                    If ($AdapterConfig.DeviceID -eq $Adapter.DeviceID)
                    {
                        ## Note: We create our own custom PhysicalAdapter property b/c the one in the
                        ##       Win32_NetworkAdapter class is not accurate.
                        $AdapterConfig.PhysicalAdapter        = [boolean]($Adapter.PNPDeviceID  -imatch '^PCI\\')
                        $AdapterConfig.Manufacturer           = $Adapter.Manufacturer
                        [psobject[]]$AllNetworkAdapterConfig += $AdapterConfig
                    }
                }
            }
            
            ## This table contains the major markers that might help user create the criteria for detecting VPN connections.
            [string]$AllNetworkAdapterConfigTable   = $AllNetworkAdapterConfig |
                                                      Format-Table DNSDomain, DefaultIPGateway, DHCPServer, IPEnabled, PhysicalAdapter, Manufacturer, Description -AutoSize -Wrap | Out-String
            
            ## Sanitize list of Network Adapters by removing:
            ##  a) adapters which we know are not VPN connections
            ##  b) adapters which are not connected (IP Enabled)
            [psobject[]]$NetworkAdapterConfig       = $AllNetworkAdapterConfig |
                                                      Where-Object  { -not ($_.PhysicalAdapter) } |
                                                      Where-Object  {
                                                                        &$NotMatchDescription -sbInputObject $_ -sbNotMatchAdapterDescription $NotMatchAdapterDescription
                                                                    } |
                                                      Where-Object  { $_.IpEnabled }
            [string]$NetworkAdapterConfigTable      = $NetworkAdapterConfig |
                                                      Format-Table DNSDomain, DefaultIPGateway, DHCPServer, IPEnabled, PhysicalAdapter, Manufacturer, Description -AutoSize -Wrap | Out-String
            
            ## Display Network Adapter Tables
            If ($DisplayNetworkAdapterTable)
            {
                Write-Host "All network adapters: `n$AllNetworkAdapterConfigTable" -ForegroundColor 'Magenta'
                Write-Host "Filtered to possible VPN network adapters: `n$NetworkAdapterConfigTable" -ForegroundColor 'Yellow'
            }
            
            ## Precedence Order 1:
            ##  Detect VPN connection based on name of manufacturer in network adapter description field. Search is case insensitive.
            If ($LikeAdapterDescription)
            {
                ForEach ($LikeDescription in $LikeAdapterDescription)
                {
                    If ([boolean]($NetworkAdapterConfig | Where-Object {($_ | Select-Object -ExpandProperty Description) -ilike $LikeDescription}))
                    {
                        Return $true
                    }
                }
            }
            
            ## Precedence Order 2:
            ##  Detect VPN based on DNS domain (e.g.: contoso.com).
            If ($LikeAdapterDNSDomain)
            {
                ForEach ($LikeDNSDomain in $LikeAdapterDNSDomain)
                {
                    If ([boolean]($NetworkAdapterConfig | Where-Object {($_ | Select-Object -ExpandProperty DNSDomain) -ilike $LikeDNSDomain}))
                    {
                        Return $true
                    }
                }
            }
            
            ## Precedence Order 3:
            ##  Detect VPN connection based on the DHCP Server of the network adapter
            If ($LikeAdapterDHCPServer)
            {
                ForEach ($LikeDHCPServer in $LikeAdapterDHCPServer)
                {
                    If ([boolean]($NetworkAdapterConfig | Where-Object {($_ | Select-Object -ExpandProperty DHCPServer) -ilike $LikeDHCPServer}))
                    {
                        Return $true
                    }
                }
            }
            
            ## Precedence Order 4:
            ##  Detect VPN connection based on the default gateway for the network adapter
            If ($LikeAdapterDefaultGateway)
            {
                ForEach ($LIkeDefaultGateway in $LikeAdapterDefaultGateway)
                {
                    If ([boolean]($NetworkAdapterConfig | Where-Object {($_ | Select-Object -ExpandProperty DefaultIPGateway) -ilike $LIkeDefaultGateway}))
                    {
                        Return $true
                    }
                }
            }
            Return $false
        }
        Catch
        {
            #Write-Log " `n$(Resolve-Error)"
            Return $false
        }
    }
    End
    {
         #Write-FunctionFooter -CmdletName ${CmdletName}
    }
}

If (Test-VPNConnection -DisplayNetworkAdapterTable)
{
    Write-Host 'VPN Connection Detected' -ForegroundColor 'Green'
}
Else
{
    Write-Host 'VPN Connection Not Detected' -ForegroundColor 'Green'
}

Function ConvertTo-LargestByteSize
{
<#
.SYSNOPSIS
    Converts a size in bytes to its upper most value.
    
.DESCRIPTION
    Converts a size in bytes to its upper most value.
    
.PARAMETER Size
    The size in bytes to convert
    
.EXAMPLE
    ConvertTo-LargestByteSize -Size 568956
    555 KB
    
    Description
    -----------
    Converts the byte value 568956 to upper most value of 555 KB
    
.EXAMPLE
    Get-ChildItem  |
    Where-Object {-not ($_.PSIsContainer)} |
    Select-Object -First 5 |
    Select-Object -Property Name, @{L='Size';E={$_ | ConvertTo-LargestByteSize}}
    
    Name                                                           Size
    ----                                                           ----
    Data1.cap                                                      14.4 MB
    Data2.cap                                                      12.5 MB
    Image.iso                                                      5.72 GB
    Index.txt                                                      23.9 KB
    SomeSite.lnk                                                   1.52 KB
    SomeFile.ini                                                   152 bytes
    
    Description
    -----------
    Used with Get-ChildItem and custom formatting with Select-Object to list the uppermost size.
    
.NOTES
.LINK
#>
    [CmdletBinding()]
    Param
    (
        [Parameter(ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)]
        [long]$Size
    )
    Begin
    {
        $ConvertToLargestByteSizeSource =  @'
        using System;
        using System.Text;
        using System.Runtime.InteropServices;
        
        namespace Convert
        {
            public class Byte
            {
                [DllImport("shlwapi.dll", CharSet = CharSet.Auto)]
                public static extern long StrFormatByteSize(long fileSize, StringBuilder buffer, int bufferSize);
                
                public static string ConvertToLargestByteSize(long size)
                {
                    const int nChars = 256;
                    StringBuilder Buff = new StringBuilder(nChars);
                    
                    StrFormatByteSize(size, Buff, Buff.Capacity);
                    return Buff.ToString();
                }
            }
        }
'@
        If (-not ([System.Management.Automation.PSTypeName]'Convert.Byte').Type)
        {
            Add-Type -TypeDefinition $ConvertToLargestByteSizeSource -Language CSharp
        }
    }
    Process
    {
        Write-Log "Converting [$Size bytes] to upper most size"
        [string]$LargestByteSize = [Convert.Byte]::ConvertToLargestByteSize($Size)
        Write-Output $LargestByteSize
    }
}

#*===============================================
#* PRE-INSTALLATION
If ($deploymentType -ne "uninstall") { $installPhase = "Pre-Installation"
#*===============================================

    # =========================================================
    # If proccess open = Show-InstallationWelcome
    # If proccess NOT open = Block-AppExecution 
    # =========================================================

    if (Get-Process -Name ProcessName1,ProcessName2,ProcessName3 -ErrorAction SilentlyContinue)
        {
        Show-InstallationWelcome -CloseApps "ProcessName1,ProcessName2,ProcessName3"  -BlockExecution -AllowDefer -DeferTimes "20" -CheckDiskSpace -PersistPrompt
        }

    Block-AppExecution -ProcessName ProcessName1,ProcessName2,ProcessName3


    # =========================================================
    # Install
    # =========================================================

Whatever


    # =========================================================
    # Unblock 
    # =========================================================
    UnBlock-AppExecution


#*===============================================
#* POST-INSTALLATION
$installPhase = "Post-Installation"
#*===============================================

• Block applications if the proccess are not launched ?